From d2f618d69d1f07295cea59617b57ce2e68ecf418 Mon Sep 17 00:00:00 2001 From: Daniel Killebrew Date: Fri, 19 Sep 2025 15:34:55 -0400 Subject: [PATCH 1/4] Create module for rounding Supports the 5 IEEE rounding modes --- docs_src/dslx_std.md | 246 + xls/dslx/stdlib/BUILD | 5 + xls/dslx/stdlib/round.x | 459 + xls/dslx/stdlib/tests/BUILD | 6 + xls/dslx/stdlib/tests/gen_round_tests.py | 332 + xls/dslx/stdlib/tests/round_tests.x | 30771 +++++++++++++++++++++ 6 files changed, 31819 insertions(+) create mode 100644 xls/dslx/stdlib/round.x create mode 100644 xls/dslx/stdlib/tests/gen_round_tests.py create mode 100644 xls/dslx/stdlib/tests/round_tests.x diff --git a/docs_src/dslx_std.md b/docs_src/dslx_std.md index 5cfddef980..83f850e7b1 100644 --- a/docs_src/dslx_std.md +++ b/docs_src/dslx_std.md @@ -1551,6 +1551,252 @@ fn test_distinct_with_invalid() { } ``` +## Rounding functions: `import round` + +XLS provides rounding primitives that implement the rounding behavior defined by the [IEEE +754](https://en.wikipedia.org/wiki/IEEE_754) floating-point specification using the five +standard rounding +modes\[[1](https://en.wikipedia.org/wiki/Rounding#Directed_rounding_to_an_integer)\]\[[2](https://en.wikipedia.org/wiki/Rounding#Rounding_to_the_nearest_integer)\]. +Although IEEE 754 describes rounding for floating-point, these more primitive functions operate +on integer encodings so they can be shared across floating-point pipelines and fixed-point +logic. + +The API accepts unsigned, two's-complement signed, and sign-and-magnitude representations. +Runtime variants keep the full input width and zero out the rounded-off bits while compile-time +variants return only the retained most-significant bits. All functions return the rounded value +together with an overflow flag that reports when the mathematically rounded result requires more +bits than were supplied. + +!!! NOTE + The best way to interpret the semantics of these routines is to treat `unrounded` as a + fixed-point quantity with `num_bits_rounded` fractional bits, and the value is being rounded + to an integer. For unsigned and sign-and-magnitude inputs the corresponding Real value's + magnitude is `unrounded / 2^num_bits_rounded`, so the IEEE-754 rounding rules apply directly + to that Real number. This viewpoint also explains how round-to-nearest-even behaves when + there are zero retained bits: the surviving integer portion is zero (an even value), so ties + resolve toward zero. + +### Rounding modes and sign tags + +#### `RoundingMode` + +```dslx-snippet +pub enum RoundingMode : u3 { + RNE = 0, + RNA = 1, + RTZ = 2, + RTN = 3, + RTP = 4, +} +``` + +Represents the IEEE-754 rounding selector. The variants correspond to: + +- `RoundingMode::RNE` - Round to the nearest representable value; ties go to the even integer. +- `RoundingMode::RNA` - Round to the nearest representable value; ties go away from zero. +- `RoundingMode::RTZ` - Round toward zero (floor for non-negative values, ceiling for negative ones). +- `RoundingMode::RTN` - Round toward negative infinity. +- `RoundingMode::RTP` - Round toward positive infinity. + +The naming scheme is: "RN" for Round to Nearest and "RT" for directed rounding (Round Toward). + +#### `Sign` + +```dslx-snippet +pub enum Sign : u1 { + NonNegative = 0, + Negative = 1, +} +``` + +Annotates whether a sign-and-magnitude operand is non-negative or negative. The core `round` +function and the sign-and-magnitude wrappers use this. Two's-complement functions infer the sign +from the most significant bit and set this for the caller. + +### Core rounding primitive + +#### `round` + +```dslx-snippet +pub fn round + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], sign: Sign, unrounded: xN[S][N]) + -> (u1, xN[S][N]) +``` + +Rounds the `num_bits_rounded` least-significant bits of `unrounded` according to the selected +IEEE-754 mode. + +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `num_bits_rounded` - Number of fractional bits to round away; zero keeps the value unchanged and + values larger than `N` (argument bit width) treat the entire input as fraction. +- `sign` - Sign tag when interpreting sign-and-magnitude inputs. +- `unrounded` - Integer or magnitude to process. +- Returns `(overflow, rounded)` - Rounded value with the same width/signedness; `overflow` is 1 + when the mathematically rounded result cannot be represented in `N` bits. When every bit is + rounded away the returned magnitude is zero and `overflow` marks rounding modes that would + otherwise produce ±1. + +### Unsigned functions + +#### `round_u` + +```dslx-snippet +pub fn round_u + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], unrounded: uN[N]) -> (u1, uN[N]) +``` + +Rounds an unsigned value. + +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `num_bits_rounded` - Number of fractional bits to round away. +- `unrounded` - Unsigned integer being rounded; the result zeroes the bits rounded away. +- Returns `(overflow, rounded)` - Rounded unsigned value; `overflow` signals that rounding would + exceed the original range. + +```dslx +let (overflow, rounded) = + round_u(RoundingMode::RNE, u32:3, u8:0b0001_1100); +assert_eq(u1:0, overflow); +assert_eq(u8:0b0010_0000, rounded); +``` + +#### `round_trunc_u` + +```dslx-snippet +pub fn round_trunc_u + (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) +``` + +Rounds an unsigned value and returns only the most-significant `R` bits. + +- `NumBitsRounded` - Compile-time constant that sets how many least-significant bits are + discarded. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `unrounded` - Unsigned integer being rounded. +- Returns `(overflow, rounded_msb)` - Rounded value with width `R = N - NumBitsRounded`. + +#### `round_trunc_to_u` + +```dslx-snippet +pub fn round_trunc_to_u + (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) +``` + +Rounds an unsigned value so the result fits within at most `AtMost` bits. If R >= N then no bits +are rounded. + +- `AtMost` - Compile-time cap on the output width. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `unrounded` - Unsigned integer being rounded. +- Returns `(overflow, rounded_msb)` - Rounded value with width `min(AtMost, N)`. + +### Signed functions + +#### `round_s` + +```dslx-snippet +pub fn round_s + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], unrounded: sN[N]) -> (u1, sN[N]) +``` + +Rounds a signed value. + +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `num_bits_rounded` - Number of fractional bits to round away. +- `unrounded` - Signed integer being rounded (the rounded result zeroes the bits rounded away). +- Returns `(overflow, rounded)` - Rounded signed value; `overflow` signals that the rounded + integer would require more than `N` bits. + +#### `round_trunc_s` + +```dslx-snippet +pub fn round_trunc_s + (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) +``` + +Rounds a signed value and returns only the most-significant `R` bits. + +- `num_bits_rounded` - Compile-time constant controlling how many bits to drop. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `unrounded` - Signed integer being rounded. +- Returns `(overflow, rounded_msb)` - Rounded value of width `R`; when `R == 0` the numeric + result is `0` and only the overflow flag is meaningful. + +#### `round_trunc_to_s` + +```dslx-snippet +pub fn round_trunc_to_s + (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) +``` + +Rounds a signed value so the result fits within at most `AtMost` bits. If R >= N then no bits +are rounded. + +- `AtMost` - Compile-time cap on the output width. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `unrounded` - Signed integer being rounded. +- Returns `(overflow, rounded_msb)` - Rounded value with width `min(AtMost, N)`. + +### Sign-and-magnitude functions + +#### `round_sm` + +```dslx-snippet +pub fn round_sm + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], sign: Sign, magnitude: uN[N]) + -> (u1, uN[N]) +``` + +Rounds a sign-and-magnitude value. + +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `num_bits_rounded` - Number of fractional bits to round away. +- `sign` - Sign tag for the input magnitude. +- `magnitude` - Magnitude being rounded. +- Returns `(overflow, rounded)` - Rounded magnitude of width `N`; `overflow` signals loss of + range. + +#### `round_trunc_sm` + +```dslx-snippet +pub fn round_trunc_sm + (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) +``` + +Rounds a sign-and-magnitude value and returns only the most-significant `R` bits. + +- `num_bits_rounded` - Compile-time constant controlling how many bits are discarded. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `sign` - Sign tag for the input magnitude. +- `magnitude` - Magnitude being rounded. +- Returns `(overflow, rounded_msb)` - Rounded magnitude with width `R`. + +#### `round_trunc_to_sm` + +```dslx-snippet +pub fn round_trunc_to_sm + (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) +``` + +Rounds a sign-and-magnitude value so the result fits within at most `AtMost` bits. If R >= N +then no bits are rounded. + +- `AtMost` - Compile-time cap on output width. +- `rounding_mode` - See [`RoundingMode`](#roundingmode). +- `sign` - Sign tag for the input magnitude. +- `magnitude` - Magnitude being rounded. +- Returns `(overflow, rounded_msb)` - Rounded magnitude with width `min(AtMost, N)`. + ## `import acm_random` Port of diff --git a/xls/dslx/stdlib/BUILD b/xls/dslx/stdlib/BUILD index 349c19e304..b5bd4e88d3 100644 --- a/xls/dslx/stdlib/BUILD +++ b/xls/dslx/stdlib/BUILD @@ -645,6 +645,11 @@ xls_dslx_test( dslx_test_args = {"compare": "jit"}, ) +xls_dslx_library( + name = "round_dslx", + srcs = ["round.x"], +) + filegroup( name = "x_files", srcs = glob(["*.x"]), diff --git a/xls/dslx/stdlib/round.x b/xls/dslx/stdlib/round.x new file mode 100644 index 0000000000..09bee9e1b6 --- /dev/null +++ b/xls/dslx/stdlib/round.x @@ -0,0 +1,459 @@ +#![feature(type_inference_v2)] + +// Copyright 2025 The XLS Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Implements rounding for all rounding modes defined by the IEEE 754 standard. +// +// It handles unsigned, signed (two's complement), and sign-and-magnitude values. +// It handles all 5 IEEE 754 rounding modes. +// Versions with compile-time 'num bits rounded' argument are provided, truncating the rounded-away +// bits. +// Versions with runtime 'num bits rounded' argument are provided, returning the full-width rounded +// result, with the rounded-away bits zeroed. +// +// Note: XLS prunes unused specializations. If callers pass compile-time constants for +// `num_bits_rounded` or restrict `RoundingMode` via an adapter, the optimizer keeps only the +// cases that remain reachable. (E.g. wrap this API with your own enum of three rounding modes +// and convert to `RoundingMode`, then the others will fold away.) +// +// Let's say you only want 3 rounding modes. Your public API should be a new enum with only +// those 3 rounding modes, and a function that takes that enum, and translates it to the +// RoundingMode enum of this library. XLS optimizer will remove the unused rounding modes from +// the optimized code. + +import std; + +// Rounding modes defined by the IEEE 754 standard. +// +// Note that the first two (RNE, RNA) always round to the nearest value, and when two potential +// results are equally close, a tie-breaking rule is applied. The last three (RTZ, RTN, RTP) +// first establish a direction on the Extended Real number line, and then round to the nearest +// value in that direction. If there is a closer value in the opposite direction, it is never +// returned. +// +// On naming: those that round to the nearest value begin with "RN", and those that always round +// in the same direction begin with "RT". +pub enum RoundingMode : u3 { + // Round to Nearest, ties to Even. Of the two equally-close rounded results, the 'even' + // result's lsb is 0. + RNE = 0, + // Rounds to Nearest, ties Away from zero. Of the two equally-close rounded results, the + // value with the larger magnitude is returned. + RNA = 1, + // Round Toward Zero (i.e. floor(x) when x >= 0, or ceil(x) when x < 0) + RTZ = 2, + // Round Toward Negative infinity (i.e. floor(x)) + RTN = 3, + // Round Toward Positive infinity (i.e. ceil(x)) + RTP = 4, +} + +// Indicates a positive (more precisely: non-negative) or negative number. +pub enum Sign : u1 { + // positive or zero + NonNegative = 0, + // negative + Negative = 1, +} + +// Rounds off the `num_bits_rounded` least significant bits. Returns (overflow, rounded result). +// +// Works for: +// - unsigned integers +// - `sign` must be `NonNegative` (otherwise you have the sign-and-magnitude case, see below) +// - signed (two's complement) integers +// - `sign` is ignored. The most significant bit of `unrounded` is used to determine the sign. +// - sign and magnitude values +// - `sign` must be `Negative` when the represented value is a negative number, otherwise +// `sign` must be `NonNegative` +// - rounding may produce a zero magnitude from a negative input; callers must decide whether +// to keep or flip the sign in that case +// +// The `num_bits_rounded` lsbs of the rounded result will always be 0. +// +// Users should interpret `unrounded` as a fixed-point quantity with num_bits_rounded fractional +// bits, being rounded to an integer. For unsigned inputs the corresponding Real value is +// unrounded / 2^num_bits_rounded, and the IEEE-754 rounding modes apply directly to that Real +// number. This viewpoint also explains the RNE tie case when every retained bit is discarded: +// the surviving integer portion is zero (an even value), so ties resolve towards zero. +// +// Overflow is 1 when the Real rounded result isn't a representable result (because the increase +// in magnitude requires a wider result type). Some non-exhaustive examples of when that can +// occur: +// * RNE(3.5) = 4 -> overflow when round(RNE, 2, NonNegative, u4:0b11_10) +// * RTN(-1.0625) = -2 -> overflow when round(RTN, 4, Negative, u5:0b1_0001) +// * RTN(-0.03125) = -1 -> overflow when round(RTN, 5, NonNegative, s5:0b11111) +// The rounded result is 0 when overflow is 1. +// +// When num_bits_rounded > N, all source bits are treated as fractional. The rounded integer is 0 +// unless the rounding mode requires +/-1, in which case overflow is signaled and 0 is returned. +// +// As mentioned above, during a tie, RNE looks at the least significant retained bit to +// determine round up or down. When there are no retained bits (i.e. num_bits_rounded >= N), +// round down is chosen. E.g. +// round(RNE, 4 bits, unsigned, u5:0b1_1000) -> rounds up (retained msb is 1) +// round(RNE, 4 bits, unsigned, u4:0b1000) -> rounds down (no retained bits) +pub fn round + + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], sign: Sign, unrounded: xN[S][N]) + -> (u1, xN[S][N]) { + // Compute sign bit while avoiding issues when N is zero. + let unrounded_u = unrounded as uN[N]; + let sign_shift = std::usub_or_zero(N, u32:1) as uN[W_NBR]; + type SafeWord = uN[W_SAFE]; + let unrounded_sign_bit = std::lsb((unrounded_u as SafeWord) >> sign_shift); + + // determine sign when unrounded is two's complement + let sign = if S { + if unrounded_sign_bit == u1:1 { Sign::Negative } else { Sign::NonNegative } + } else { + sign + }; + + if N == u32:0 { + (u1:0, xN[S][N]:0) + } else if num_bits_rounded == uN[W_NBR]:0 { + (u1:0, unrounded) + } else if num_bits_rounded as u32 > N { + let is_zero = unrounded_u == uN[N]:0; + let is_strictly_negative = !is_zero && sign == Sign::Negative; + let is_strictly_positive = !is_zero && sign == Sign::NonNegative; + let overflow = match rounding_mode { + RoundingMode::RTN => if is_strictly_negative { u1:1 } else { u1:0 }, + RoundingMode::RTP => if is_strictly_positive { u1:1 } else { u1:0 }, + _ => u1:0, + }; + (overflow, xN[S][N]:0) + } else { + let negative_twos_complement = S && sign == Sign::Negative; + + // The bits rounded away; these bits are always 0 in the result. + let rounded_bits = std::keep_lsbs(unrounded_u, num_bits_rounded); + let rounded_bits_safe = rounded_bits as SafeWord; + + // The bits that will be returned, before any rounding adjustment. + let retained_bits = std::clear_lsbs(unrounded_u, num_bits_rounded); + + // Note: zero retained bits means retained_bits_are_odd is false. + let retained_bits_are_odd = std::lsb(retained_bits >> num_bits_rounded); + + let rounded_bits_are_nonzero = rounded_bits_safe != SafeWord:0; + + // This is the value of 0.5 when num_bits_rounded is interpreted as a negative binary + // exponent (and by implication, `unrounded` is a binary fixed point value). We are + // rounding the fixed point value to a nearby integer. This is 0.5 in this fixed point + // format. + let half_value = (SafeWord:1) << (num_bits_rounded as SafeWord - SafeWord:1); + + // as we defined half above, we use a similar definition of one + let one = (uN[NP1]:1) << num_bits_rounded; + let zero = uN[NP1]:0; + + // Beware rounded_gt_half when unrounded is two's complement and negative; it's + // misleading. + let rounded_gt_half = rounded_bits_safe > half_value; + let rounded_eq_half = rounded_bits_safe == half_value; + + let adjustment = match rounding_mode { + RoundingMode::RNE => { + // round to nearest, ties to even + // when |rounded_bits| > |half| or (|rounded_bits| == |half| and the retained bits + // are odd) + // the adjustment is: + // unsigned -> 1 + // sign & magnitude, positive value -> 1 + // sign & magnitude, negative value -> 1 + // two's complement, positive value -> 1 + // two's complement, negative value is more complex, see below + let tie_to_even = rounded_eq_half && retained_bits_are_odd; + if negative_twos_complement { + // recall that rounded > 0.5 means the (negative two's complement) value is + // closer to 0 than half. E.g. -4 + 0.75 = -3.25 is closer to 0 than -3.5 is. + let closer_to_zero_than_half_is = rounded_gt_half; + if closer_to_zero_than_half_is || tie_to_even { + // RNE(-3.25) -> -3, retained=-4, thus adjustment=1 + // RNE(-2.5) -> -2, retained=-3, thus adjustment=+1 + one + } else { + // case: further from 0 than half is (e.g. -4 + 0.25 = -3.75 which is + // further from 0 than -3.5 is) OR rounded=0.5 and retained bits are even. + // RNE(-3.75) -> -4, retained=-4, thus adjustment=0 + // RNE(-3.5) -> -4, retained=-4, thus adjustment=0 + zero + } + } else { + if rounded_gt_half || tie_to_even { one } else { zero } + } + }, + RoundingMode::RNA => { + // round to nearest, ties away from zero + // when |rounded_bits| >= |half| the adjustment is: + // unsigned -> 1 + // sign & magnitude, positive value -> 1 + // sign & magnitude, negative value -> 1 + // two's complement, positive value -> 1 + // two's complement, negative value -> 0 (because truncation is toward -∞) + // + // you'll notice that RNE and RNA are the same w.r.t. the adjustment, and only + // differ in the case of a tie (they agree when |rounded_bits| > |half|) + if negative_twos_complement { + // recall that rounded > 0.5 means the (negative two's complement) value is + // closer to 0 than half. E.g. -4 + 0.75 = -3.25 is closer to 0 than -3.5 is. + let closer_to_zero_than_half_is = rounded_gt_half; + if closer_to_zero_than_half_is { + // RNA(-3.25) -> -3, retained=-4, thus adjustment=1 + one + } else { + // RNA(-3.5) -> -4, retained=-4, thus adjustment=0 + // RNA(-3.75) -> -4, retained=-4, thus adjustment=0 + zero + } + } else { + // unsigned or sign-magnitude and positive two's-complement + if rounded_gt_half || rounded_eq_half { one } else { zero } + } + }, + RoundingMode::RTZ => { + // round toward zero + // when rounded_bits != zero, the adjustment is: + // unsigned -> 0 + // sign & magnitude, positive value -> 0 + // sign & magnitude, negative value -> 0 + // two's complement, positive value -> 0 + // two's complement, negative value -> 1 + if negative_twos_complement && rounded_bits_are_nonzero { one } else { zero } + }, + RoundingMode::RTN => { + // round toward negative infinity + // when rounded_bits != zero, the adjustment is: + // unsigned -> 0 + // sign & magnitude, positive value -> 0 + // sign & magnitude, negative value -> 1 + // two's complement, positive value -> 0 + // two's complement, negative value -> 0 (because truncation is toward -∞) + if rounded_bits_are_nonzero { + match (S, sign) { + (false, Sign::Negative) => one, + _ => zero, + } + } else { + zero + } + }, + RoundingMode::RTP => { + // round toward positive infinity + // when rounded_bits != zero, the adjustment is: + // unsigned -> 1 + // sign & magnitude, positive value -> 1 + // sign & magnitude, negative value -> 0 + // two's complement, positive value -> 1 + // two's complement, negative value -> 1 + if rounded_bits_are_nonzero { + match (S, sign) { + (false, Sign::Negative) => zero, + _ => one, + } + } else { + zero + } + }, + }; + + let sum = retained_bits as uN[NP1] + adjustment; + let (carry, rounded_u) = std::split_msbs(sum); + + let rounded_sign_bit = std::lsb((rounded_u as SafeWord) >> sign_shift); + let sign_changed = S && rounded_sign_bit != unrounded_sign_bit; + let adjustment_is_one = adjustment == one; + let rounding_all_bits = (num_bits_rounded as u32) == N; + let overflow = if !S { + // Unsigned or sign-and-magnitude: any carry-out indicates overflow. + carry + } else { + match (sign, adjustment_is_one) { + // Positive argument, no adjustment - never overflows. + (Sign::NonNegative, false) => false, + (Sign::NonNegative, true) => { + // Positive argument, adjustment of +1. + // - If we rounded away every bit, rely on the carry-out. + // - If we kept at least one integer bit, check for sign change. + if rounding_all_bits { carry } else { sign_changed } + }, + // Negative argument with +1 adjustment never overflows (-1 -> 0 etc.). + (Sign::Negative, true) => false, + (Sign::Negative, false) => { + // Negative argument with no adjustment. + // When every bit is rounded away the result is 0 (RTZ/RNE/RTP) + // or -1 (RTN/RNA). The latter is not representable because no integer bits + // remain. + if rounding_all_bits && + (rounding_mode == RoundingMode::RTN || rounding_mode == RoundingMode::RNA) { + true + } else { + false + } + }, + } + }; + + let rounded_u = if sign_changed { + // handles cases like: + // argument is two's complement, positive, and rounding away all bits + // RNE(0.9375) = 1 -> overflow + // round(RoundingMode::RNE, 4, NonNegative, s5:0b0_1111)) + // without this correction, result would be s5:0b1_0000, i.e. -1 + uN[N]:0 + } else { + rounded_u + }; + (overflow, rounded_u as xN[S][N]) + } +} + +// Rounds an unsigned integer: +// - rounds a runtime-specified number (`num_bits_rounded`) of least significant bits, +// - returns the full-width rounded result with the least significant `num_bits_rounded` bits +// zeroed. +// Returns (overflow, rounded result). +pub fn round_u + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], unrounded: uN[N]) -> (u1, uN[N]) { + round(rounding_mode, num_bits_rounded, Sign::NonNegative, unrounded) +} + +// Rounds an unsigned integer: +// - rounds a compile-time-constant (`num_bits_rounded`) number of least significant bits, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_u + + (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) { + const_assert!(NumBitsRounded <= N); + let (overflow, rounded) = round_u(rounding_mode, NumBitsRounded as uN[W_NBR], unrounded); + let (rounded_msbs, _) = std::split_msbs(rounded); + (overflow, rounded_msbs) +} + +// Rounds an unsigned integer: +// - such that after rounding it is `AtMost` (a compile-time constant) bits wide, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_to_u + + (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) { + if NumBitsRounded == u32:0 { + // This no-op cast is required by the type checker. When this branch is not taken, this + // cast op unifies the types of the branches. + let unrounded = unrounded as uN[R]; + (u1:0, unrounded) + } else { + round_trunc_u(rounding_mode, unrounded) + } +} + +// Rounds a signed integer: +// - rounds a runtime-specified number (`num_bits_rounded`) of least significant bits, +// - returns the full-width rounded result with the least significant `num_bits_rounded` bits +// zeroed. +// Returns (overflow, rounded result). +pub fn round_s + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], unrounded: sN[N]) -> (u1, sN[N]) { + round(rounding_mode, num_bits_rounded, Sign::NonNegative, unrounded) +} + +// Rounds a signed integer: +// - rounds a compile-time-constant (`num_bits_rounded`) number of least significant bits, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_s + + (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) { + const_assert!(num_bits_rounded <= N); + if R == u32:0 { + let (overflow, _) = round_s(rounding_mode, num_bits_rounded as uN[W_NBR], unrounded); + (overflow, zero!()) + } else { + let (overflow, rounded) = round_s(rounding_mode, num_bits_rounded as uN[W_NBR], unrounded); + let (rounded_msbs, _) = std::split_msbs(rounded as uN[N]); + (overflow, rounded_msbs as sN[R]) + } +} + +// Rounds a signed integer: +// - such that after rounding it is `AtMost` (a compile-time constant) bits wide, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_to_s + + (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) { + if NumBitsRounded == u32:0 { + let unrounded = unrounded as sN[R]; + (u1:0, unrounded) + } else { + round_trunc_s(rounding_mode, unrounded) + } +} + +// Rounds a sign-and-magnitude integer: +// - rounds a runtime-specified number (`num_bits_rounded`) of least significant bits, +// - returns the full-width rounded result with the least significant `num_bits_rounded` bits +// zeroed. +// Returns (overflow, rounded result). +pub fn round_sm + (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], sign: Sign, magnitude: uN[N]) + -> (u1, uN[N]) { + round(rounding_mode, num_bits_rounded, sign, magnitude) +} + +// Rounds a sign-and-magnitude integer: +// - rounds a compile-time-constant (`num_bits_rounded`) number of least significant bits, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_sm + + (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) { + const_assert!(num_bits_rounded <= N); + let (overflow, rounded) = + round_sm(rounding_mode, num_bits_rounded as uN[W_NBR], sign, magnitude); + let (rounded_msbs, _) = std::split_msbs(rounded); + (overflow, rounded_msbs) +} + +// Rounds a sign-and-magnitude integer: +// - such that after rounding it is `AtMost` (a compile-time constant) bits wide, +// - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off +// bits. +// Returns (overflow, rounded result). +pub fn round_trunc_to_sm + + (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) { + if NumBitsRounded == u32:0 { + let magnitude = magnitude as uN[R]; + (u1:0, magnitude) + } else { + round_trunc_sm(rounding_mode, sign, magnitude) + } +} diff --git a/xls/dslx/stdlib/tests/BUILD b/xls/dslx/stdlib/tests/BUILD index 2e59a71fb3..377ccda190 100644 --- a/xls/dslx/stdlib/tests/BUILD +++ b/xls/dslx/stdlib/tests/BUILD @@ -229,6 +229,12 @@ cc_test( ], ) +xls_dslx_test( + name = "round_dslx_test", + srcs = ["round_tests.x"], + deps = ["//xls/dslx/stdlib:round_dslx"], +) + cc_test( name = "float32_test", srcs = ["float32_test.cc"], diff --git a/xls/dslx/stdlib/tests/gen_round_tests.py b/xls/dslx/stdlib/tests/gen_round_tests.py new file mode 100644 index 0000000000..76edcceaa6 --- /dev/null +++ b/xls/dslx/stdlib/tests/gen_round_tests.py @@ -0,0 +1,332 @@ +"""Generate DSLX round() tests. + +This script produces a comprehensive set of DSLX tests that exercise the +`round` helper over: + * operand widths from 1 to 5 bits, + * every possible input value for the corresponding width, + * each `num_bits_rounded` in {0, 1, …, N, N+1}, + * every rounding mode {RNE, RNA, RTZ, RTN, RTP}, + * the three distinct interpretations requested: + * unsigned (Sign::NonNegative), + * sign-and-magnitude with Sign::Negative, + * signed two's-complement (sN). + +Each test function bundles the five rounding-mode checks for one +(width, value, num_bits_rounded) combination - totalling 372 functions. + +The generated DSL lives inside `round_tests.x`; everything between the +"AUTO-GENERATED" markers is replaced when this script runs. +""" + +from __future__ import annotations + +import argparse +import math +import subprocess +from enum import Enum, auto +from fractions import Fraction +from pathlib import Path + +# -------- Helper utilities ------------------------------------------------- + + +class RoundingMode(Enum): + RNE = auto() # convergent / bankers-rounding (nearest, ties-to-even) + RNA = auto() # away from zero + RTZ = auto() # towards zero + RTN = auto() # towards -∞ + RTP = auto() # towards +∞ + + def __str__(self): + # For codegen purposes (DSLX output) + return self.name + + +ROUNDING_MODES = [ + RoundingMode.RNE, + RoundingMode.RNA, + RoundingMode.RTZ, + RoundingMode.RTN, + RoundingMode.RTP, +] + +GENERATED_HEADER = [ + "// ---------------------------------------------------------------------------", + "// These tests are AUTO-GENERATED by gen_round_tests.py - do not edit manually.", + "// Everything below this comment will be overwritten.", + "// ---------------------------------------------------------------------------", +] +HEADER_TEXT = "\n".join(GENERATED_HEADER) + +MIN_WIDTH = 1 +MAX_WIDTH = 5 + + +def all_widths() -> range: + return range(MIN_WIDTH, MAX_WIDTH + 1) + + +def value_space(width: int) -> range: + return range(1 << width) + + +def num_bits_field_width(width: int) -> int: + # Mirrors DSLX's std::clog2(N + 1) used in round()'s type signature. + # Ensure at least one bit so we can represent zero. + return max(1, math.ceil(math.log2(width + 1))) + + +def nbits_space(width: int) -> list[int]: + # Include 0, the in-range values, and one value beyond the width. + in_range = list(range(0, width + 1)) + beyond = width + 1 + max_representable = (1 << num_bits_field_width(width)) - 1 + if beyond <= max_representable: + in_range.append(beyond) + return in_range + + +# --------------------------------------------------------------------------- + + +def fraction_from_bits(bits: int, nfrac: int, *, signed: bool, width: int) -> Fraction: + """Return the exact real value represented by *bits* interpreted as a + fixed-point number with *nfrac* fractional bits. + If *signed* is False, bits are treated as unsigned. + Otherwise two's-complement is assumed. + """ + if signed and bits & (1 << (width - 1)): + bits -= 1 << width # sign-extend negative value + return Fraction(bits, 1 << nfrac) + + +def round_fraction(value: Fraction, mode: RoundingMode) -> int: + """Round *value* to the nearest integer according to *mode*. + Returns the rounded integer (unbounded - overflow handled separately). + """ + assert isinstance(mode, RoundingMode) + + # Directed rounding modes. + if mode == RoundingMode.RTZ: # truncate towards zero + return math.trunc(value) + if mode == RoundingMode.RTN: # towards -∞ + return math.floor(value) + if mode == RoundingMode.RTP: # towards +∞ + return math.ceil(value) + + # The remaining two are 'nearest' variants. + floor_val = math.floor(value) + ceil_val = math.ceil(value) + dist_down = value - floor_val # always ≥ 0 + dist_up = ceil_val - value # always ≥ 0 + + if dist_down < dist_up: + return floor_val + if dist_up < dist_down: + return ceil_val + + # At a tie - exactly midway between. + if mode == RoundingMode.RNE: # tie to even + return floor_val if floor_val % 2 == 0 else ceil_val + else: # RNA - tie away from zero + return ceil_val if value >= 0 else floor_val + + +def needs_overflow_unsigned(val: int, int_bits: int) -> bool: + """Return True if *val* cannot be represented in *int_bits* unsigned bits.""" + return not (0 <= val < (1 << int_bits)) + + +def needs_overflow_signed(val: int, int_bits: int) -> bool: + """Return True if *val* cannot be represented in *int_bits* two's-complement. + + The integer part of our fixed-point numbers spans `int_bits` bits, which + includes the sign bit for two's-complement values. A value is + representable iff it lies within the conventional two's-complement range + + [ -2^(int_bits-1) , 2^(int_bits-1) - 1 ]. + + Special-case `int_bits == 0` (all bits are fractional): in that scenario + *no* non-zero integer can be represented once the value has been rounded + (because the subsequent left-shift by `nfrac` would shift the sign bit out + of the word). Hence every value except 0 overflows. + """ + if int_bits == 0: + return val != 0 + + min_val = -(1 << (int_bits - 1)) + max_val = (1 << (int_bits - 1)) - 1 + return not (min_val <= val <= max_val) + + +def bits_literal(bits: int, nfrac: int, width: int) -> str: + """Return a DSLX binary literal for the given *width*-bit value.""" + mask = (1 << width) - 1 + bin_str = format(bits & mask, f"0{width}b") + int_bits = max(width - nfrac, 0) + frac_bits = width - int_bits + if int_bits == 0 or frac_bits == 0: + return f"0b{bin_str}" + return f"0b{bin_str[:int_bits]}_{bin_str[int_bits:]}" + + +def fmt_real(frac: Fraction) -> str: + """Nicely format *frac* for human-readable comments.""" + numerator, denominator = frac.numerator, frac.denominator + if denominator == 1: + return str(numerator) + # Use finite decimal if possible (denominator is a power of two ≤ 32). + return str(float(frac)) + + +# --------------------------------------------------------------------------- + + +def num_bits_literal(width: int, nfrac: int) -> str: + """Return the literal string for num_bits_rounded with enough width.""" + default_width = max(1, width.bit_length()) + required_width = max(1, nfrac.bit_length()) + literal_width = max(default_width, required_width) + return f"u{literal_width}:{nfrac}" + + +def generate_test_function(width: int, bits: int, nfrac: int) -> str: + """Return the DSLX source for one test function covering all rounding modes + under the three interpretations. + """ + func_lines: list[str] = [] + int_bits = max(width - nfrac, 0) + func_name = f"test_w{width}_p{bits:02d}_n{nfrac}" + + unrounded_lit = bits_literal(bits, nfrac, width) + nbr_literal = num_bits_literal(width, nfrac) + mask = (1 << width) - 1 + func_lines.append(f"#[test]") + func_lines.append(f"fn {func_name}() {{") + func_lines.append(f" let num_bits_rounded = {nbr_literal};") + func_lines.append(f" let unrounded = u{width}:{unrounded_lit};\n") + + # --- unsigned interpretation ----------------------------------------- + real_unsigned = Fraction(bits, 1 << nfrac) + func_lines.append(f" // unsigned, Real value is {fmt_real(real_unsigned)}") + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = round_fraction(real_unsigned, mode) + overflow = needs_overflow_unsigned(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else ((rounded << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + func_lines.append(f" // {mode_name}({fmt_real(real_unsigned)}) = {rounded}{ov_comment}") + func_lines.append(f" assert_eq((u1:{carry}, u{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " + f"round::Sign::NonNegative, unrounded));") + func_lines.append("") + + # --- sign & magnitude, negative -------------------------------------- + real_sm = -real_unsigned + func_lines.append(f" // sign & magnitude, Real value is {fmt_real(real_sm)}") + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = abs(round_fraction(real_sm, mode)) # magnitude only + overflow = needs_overflow_unsigned(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else ((rounded << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + rounded_display = -rounded if not overflow else f"-{rounded}" + func_lines.append(f" // {mode_name}({fmt_real(real_sm)}) = {rounded_display}{ov_comment}") + func_lines.append(f" assert_eq((u1:{carry}, u{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " + f"round::Sign::Negative, unrounded));") + func_lines.append("") + + # --- signed two's-complement ---------------------------------------- + real_signed = fraction_from_bits(bits, nfrac, signed=True, width=width) + func_lines.append(f" // signed, Real value is {fmt_real(real_signed)}") + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = round_fraction(real_signed, mode) + overflow = needs_overflow_signed(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else (((rounded & mask) << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + func_lines.append(f" // {mode_name}({fmt_real(real_signed)}) = {rounded}{ov_comment}") + func_lines.append(f" assert_eq((u1:{carry}, s{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " + f"round::Sign::NonNegative, unrounded as s{width}));") + + func_lines.append("}") + return "\n".join(func_lines) + + +# --------------------------------------------------------------------------- + + +def build_generated_section() -> tuple[str, int]: + lines: list[str] = [HEADER_TEXT, ""] + total_funcs = 0 + for width in all_widths(): + lines.append(f"// --- Width {width} bits --------------------------------------------------------") + for bits in value_space(width): + for nfrac in nbits_space(width): + lines.append(generate_test_function(width, bits, nfrac)) + lines.append("") + total_funcs += 1 + section = "\n".join(lines).rstrip() + "\n" + return section, total_funcs + + +def parse_args(argv: list[str] | None = None) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Generate DSLX round() tests.") + parser.add_argument( + "--round-tests", + type=Path, + default=Path(__file__).with_name("round_tests.x"), + help="Path to the round_tests.x file to update (default: sibling round_tests.x)", + ) + parser.add_argument( + "--dslx-fmt", + type=Path, + help="Optional path to dslx_fmt; if provided, formatted output replaces round_tests.x", + ) + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> None: + args = parse_args(argv) + out_path = args.round_tests + existing = out_path.read_text() + section, total_funcs = build_generated_section() + + marker_index = existing.find(HEADER_TEXT) + if marker_index == -1: + raise RuntimeError("Generated section header not found in round_tests.x") + + updated = existing[:marker_index] + section + out_path.write_text(updated) + + if args.dslx_fmt is not None: + result = subprocess.run( + [str(args.dslx_fmt), str(out_path)], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=False, + ) + if result.returncode != 0: + raise RuntimeError( + "dslx_fmt failed with exit code " + f"{result.returncode}: {result.stderr.strip()}" + ) + if result.stdout: + out_path.write_text(result.stdout) + else: + raise RuntimeError("dslx_fmt produced no output; refusing to overwrite round_tests.x") + + print(f"Updated {out_path} with {total_funcs} test functions.") + + +if __name__ == "__main__": + main() diff --git a/xls/dslx/stdlib/tests/round_tests.x b/xls/dslx/stdlib/tests/round_tests.x new file mode 100644 index 0000000000..9caee00d96 --- /dev/null +++ b/xls/dslx/stdlib/tests/round_tests.x @@ -0,0 +1,30771 @@ +#![feature(type_inference_v2)] + +import std; +import round; + +#[test] +fn test_wrappers_well_formed() { + // ensures the "wrappers" are well-formed. + let num_bits_rounded = u3:1; + let unrounded = u5:0b0001_0; + + // unsigned + assert_eq( + (u1:0, u5:0b0001_0), round::round_u(round::RoundingMode::RNE, num_bits_rounded, unrounded)); + assert_eq((u1:0, u2:0b00), round::round_trunc_u(round::RoundingMode::RNE, unrounded)); + assert_eq((u1:0, u2:0b00), round::round_trunc_to_u(round::RoundingMode::RNE, unrounded)); + + // sign & magnitude + assert_eq( + (u1:0, u5:0b0001_0), + round::round_sm( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + assert_eq( + (u1:0, u2:0b00), + round::round_trunc_sm(round::RoundingMode::RNE, round::Sign::Negative, unrounded)); + assert_eq( + (u1:0, u2:0b00), + round::round_trunc_to_sm(round::RoundingMode::RNE, round::Sign::Negative, unrounded)); + + // signed + assert_eq( + (u1:0, s5:0b0001_0), + round::round_s(round::RoundingMode::RNE, num_bits_rounded, unrounded as s5)); + assert_eq( + (u1:0, s2:0b00), round::round_trunc_s(round::RoundingMode::RNE, unrounded as s5)); + assert_eq( + (u1:0, s2:0b00), round::round_trunc_to_s(round::RoundingMode::RNE, unrounded as s5)); +} + +#[test] +fn test_can_round_all_bits_pow2() { + // We may want to round away all N bits when N is a power of 2. In such a case, clog2(N+1) + // is needed. + let num_bits_rounded = u3:4; + let unrounded = u4:0b1000; + assert_eq( + (u1:0, u4:0b0000), round::round_u(round::RoundingMode::RNE, num_bits_rounded, unrounded)); +} + +// ** Test N = 0 doesn't cause a compiler error ** +#[test] +fn round_zero_width_unsigned_rne() { + let (_, rounded) = round::round( + round::RoundingMode::RNE, uN[0]:0, round::Sign::NonNegative, uN[0]:0); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_zero_width_dynamic_rtz() { + let (overflow, rounded) = round::round( + round::RoundingMode::RTZ, uN[0]:0, round::Sign::NonNegative, uN[0]:0); + assert_eq(u1:0, overflow); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_u_zero_width_rtz() { + let (overflow, rounded) = round::round_u(round::RoundingMode::RTZ, uN[0]:0, uN[0]:0); + assert_eq(u1:0, overflow); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_trunc_s_all_bits_rtz() { + // Forces round_trunc_s to compute R = N - num_bits_rounded = 0 + let (_, rounded) = round::round_trunc_s(round::RoundingMode::RTZ, sN[4]:0); + assert_eq(sN[0]:0, rounded); +} + +#[test] +fn round_trunc_u_all_bits_rtz() { + // Forces round_trunc_u to compute R = 0. + let (_, rounded) = round::round_trunc_u(round::RoundingMode::RTZ, uN[4]:0); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_trunc_to_u_zero_width_rtz() { + let (overflow, rounded) = + round::round_trunc_to_u(round::RoundingMode::RTZ, uN[4]:0); + assert_eq(u1:0, overflow); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_trunc_sm_all_bits_rtz() { + // Forces round_trunc_sm to compute R = 0. + let (_, rounded) = round::round_trunc_sm( + round::RoundingMode::RTZ, round::Sign::NonNegative, uN[4]:0); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_s_zero_width_rtz() { + let (overflow, rounded) = round::round_s(round::RoundingMode::RTZ, uN[0]:0, sN[0]:0); + assert_eq(u1:0, overflow); + assert_eq(sN[0]:0, rounded); +} + +#[test] +fn round_trunc_to_s_zero_width_rtz() { + let (overflow, rounded) = + round::round_trunc_to_s(round::RoundingMode::RTZ, sN[4]:0); + assert_eq(u1:0, overflow); + assert_eq(sN[0]:0, rounded); +} + +#[test] +fn round_sm_zero_width_rtz() { + let (overflow, rounded) = round::round_sm( + round::RoundingMode::RTZ, uN[0]:0, round::Sign::NonNegative, uN[0]:0); + assert_eq(u1:0, overflow); + assert_eq(uN[0]:0, rounded); +} + +#[test] +fn round_trunc_to_sm_zero_width_rtz() { + let (overflow, rounded) = round::round_trunc_to_sm( + round::RoundingMode::RTZ, round::Sign::NonNegative, uN[4]:0); + assert_eq(u1:0, overflow); + assert_eq(uN[0]:0, rounded); +} + +// ** Test num_bits_rounded > N ** + +fn exercise_round_u_more_fractional_bits(num_bits_rounded: uN[3]) { + let zero = u5:0; + let half = u5:0b1_0000; + let all_ones = u5:0b1_1111; + + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNE, num_bits_rounded, zero)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNE, num_bits_rounded, half)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNE, num_bits_rounded, all_ones)); + + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNA, num_bits_rounded, zero)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNA, num_bits_rounded, half)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RNA, num_bits_rounded, all_ones)); + + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTZ, num_bits_rounded, zero)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTZ, num_bits_rounded, half)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTZ, num_bits_rounded, all_ones)); + + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTN, num_bits_rounded, zero)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTN, num_bits_rounded, half)); + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTN, num_bits_rounded, all_ones)); + + assert_eq((u1:0, u5:0), round::round_u(round::RoundingMode::RTP, num_bits_rounded, zero)); + assert_eq((u1:1, u5:0), round::round_u(round::RoundingMode::RTP, num_bits_rounded, half)); + assert_eq((u1:1, u5:0), round::round_u(round::RoundingMode::RTP, num_bits_rounded, all_ones)); +} + +fn exercise_round_s_more_fractional_bits(num_bits_rounded: uN[3]) { + let zero = s5:0; + let little_positive = s5:8; + let little_negative = s5:-8; + + assert_eq((u1:0, s5:0), round::round_s(round::RoundingMode::RNE, num_bits_rounded, zero)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RNE, num_bits_rounded, little_positive)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RNE, num_bits_rounded, little_negative)); + + assert_eq((u1:0, s5:0), round::round_s(round::RoundingMode::RNA, num_bits_rounded, zero)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RNA, num_bits_rounded, little_positive)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RNA, num_bits_rounded, little_negative)); + + assert_eq((u1:0, s5:0), round::round_s(round::RoundingMode::RTZ, num_bits_rounded, zero)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RTZ, num_bits_rounded, little_positive)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RTZ, num_bits_rounded, little_negative)); + + assert_eq((u1:0, s5:0), round::round_s(round::RoundingMode::RTN, num_bits_rounded, zero)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RTN, num_bits_rounded, little_positive)); + assert_eq( + (u1:1, s5:0), round::round_s(round::RoundingMode::RTN, num_bits_rounded, little_negative)); + + assert_eq((u1:0, s5:0), round::round_s(round::RoundingMode::RTP, num_bits_rounded, zero)); + assert_eq( + (u1:1, s5:0), round::round_s(round::RoundingMode::RTP, num_bits_rounded, little_positive)); + assert_eq( + (u1:0, s5:0), round::round_s(round::RoundingMode::RTP, num_bits_rounded, little_negative)); +} + +fn exercise_round_sm_more_fractional_bits(num_bits_rounded: uN[3], sign: round::Sign) { + let zero = u5:0; + let half = u5:0b1_0000; + let all_ones = u5:0b1_1111; + + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RNE, num_bits_rounded, sign, zero)); + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RNE, num_bits_rounded, sign, half)); + assert_eq( + (u1:0, u5:0), round::round_sm(round::RoundingMode::RNE, num_bits_rounded, sign, all_ones)); + + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RNA, num_bits_rounded, sign, zero)); + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RNA, num_bits_rounded, sign, half)); + assert_eq( + (u1:0, u5:0), round::round_sm(round::RoundingMode::RNA, num_bits_rounded, sign, all_ones)); + + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RTZ, num_bits_rounded, sign, zero)); + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RTZ, num_bits_rounded, sign, half)); + assert_eq( + (u1:0, u5:0), round::round_sm(round::RoundingMode::RTZ, num_bits_rounded, sign, all_ones)); + + let rtn_expected_overflow = if sign == round::Sign::Negative { u1:1 } else { u1:0 }; + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RTN, num_bits_rounded, sign, zero)); + assert_eq( + (rtn_expected_overflow, u5:0), + round::round_sm(round::RoundingMode::RTN, num_bits_rounded, sign, half)); + assert_eq( + (rtn_expected_overflow, u5:0), + round::round_sm(round::RoundingMode::RTN, num_bits_rounded, sign, all_ones)); + + let rtp_expected_overflow = if sign == round::Sign::NonNegative { u1:1 } else { u1:0 }; + assert_eq((u1:0, u5:0), round::round_sm(round::RoundingMode::RTP, num_bits_rounded, sign, zero)); + assert_eq( + (rtp_expected_overflow, u5:0), + round::round_sm(round::RoundingMode::RTP, num_bits_rounded, sign, half)); + assert_eq( + (rtp_expected_overflow, u5:0), + round::round_sm(round::RoundingMode::RTP, num_bits_rounded, sign, all_ones)); +} + +#[test] +fn test_round_more_fractional_bits_unsigned() { + exercise_round_u_more_fractional_bits(u3:6); + exercise_round_u_more_fractional_bits(u3:7); +} + +#[test] +fn test_round_more_fractional_bits_signed() { + exercise_round_s_more_fractional_bits(u3:6); + exercise_round_s_more_fractional_bits(u3:7); +} + +#[test] +fn test_round_more_fractional_bits_sign_magnitude() { + exercise_round_sm_more_fractional_bits(u3:6, round::Sign::NonNegative); + exercise_round_sm_more_fractional_bits(u3:7, round::Sign::NonNegative); + exercise_round_sm_more_fractional_bits(u3:6, round::Sign::Negative); + exercise_round_sm_more_fractional_bits(u3:7, round::Sign::Negative); +} + +// Test round exhaustively for widths 1 through 5, all rounding modes, and num bits rounded. + +// --------------------------------------------------------------------------- +// These tests are AUTO-GENERATED by gen_round_tests.py - do not edit manually. +// Everything below this comment will be overwritten. +// --------------------------------------------------------------------------- + +// --- Width 1 bits -------------------------------------------------------- +#[test] +fn test_w1_p00_n0() { + let num_bits_rounded = u1:0; + let unrounded = u1:0b0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RNA(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTN(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTP(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); +} + +#[test] +fn test_w1_p00_n1() { + let num_bits_rounded = u1:1; + let unrounded = u1:0b0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RNA(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTN(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTP(0) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); +} + +#[test] +fn test_w1_p01_n0() { + let num_bits_rounded = u1:0; + let unrounded = u1:0b1; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u1:0b1), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u1:0b1), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u1:0b1), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u1:0b1), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u1:0b1), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u1:0b1), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u1:0b1), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u1:0b1), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u1:0b1), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u1:0b1), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s1:0b1), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s1:0b1), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s1:0b1), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s1:0b1), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s1:0b1), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); +} + +#[test] +fn test_w1_p01_n1() { + let num_bits_rounded = u1:1; + let unrounded = u1:0b1; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, u1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, u1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u1:0b0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u1:0b0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u1:0b0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s1:0b0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s1:0b0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s1:0b0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s1)); +} + +// --- Width 2 bits -------------------------------------------------------- +#[test] +fn test_w2_p00_n0() { + let num_bits_rounded = u2:0; + let unrounded = u2:0b00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p00_n1() { + let num_bits_rounded = u2:1; + let unrounded = u2:0b0_0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p00_n2() { + let num_bits_rounded = u2:2; + let unrounded = u2:0b00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p00_n3() { + let num_bits_rounded = u2:3; + let unrounded = u2:0b00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p01_n0() { + let num_bits_rounded = u2:0; + let unrounded = u2:0b01; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u2:0b01), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u2:0b01), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u2:0b01), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u2:0b01), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u2:0b01), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u2:0b01), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u2:0b01), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u2:0b01), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u2:0b01), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u2:0b01), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s2:0b01), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(1) = 1 + assert_eq( + (u1:0, s2:0b01), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s2:0b01), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(1) = 1 + assert_eq( + (u1:0, s2:0b01), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(1) = 1 + assert_eq( + (u1:0, s2:0b01), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p01_n1() { + let num_bits_rounded = u2:1; + let unrounded = u2:0b0_1; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u2:0b0_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, s2:0b0_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, s2:0b0_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p01_n2() { + let num_bits_rounded = u2:2; + let unrounded = u2:0b01; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p01_n3() { + let num_bits_rounded = u2:3; + let unrounded = u2:0b01; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p02_n0() { + let num_bits_rounded = u2:0; + let unrounded = u2:0b10; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u2:0b10), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u2:0b10), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u2:0b10), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u2:0b10), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u2:0b10), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u2:0b10), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u2:0b10), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u2:0b10), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u2:0b10), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u2:0b10), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s2:0b10), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s2:0b10), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s2:0b10), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s2:0b10), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s2:0b10), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p02_n1() { + let num_bits_rounded = u2:1; + let unrounded = u2:0b1_0; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p02_n2() { + let num_bits_rounded = u2:2; + let unrounded = u2:0b10; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p02_n3() { + let num_bits_rounded = u2:3; + let unrounded = u2:0b10; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p03_n0() { + let num_bits_rounded = u2:0; + let unrounded = u2:0b11; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u2:0b11), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u2:0b11), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u2:0b11), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u2:0b11), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u2:0b11), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u2:0b11), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u2:0b11), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u2:0b11), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u2:0b11), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u2:0b11), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s2:0b11), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s2:0b11), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s2:0b11), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s2:0b11), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s2:0b11), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p03_n1() { + let num_bits_rounded = u2:1; + let unrounded = u2:0b1_1; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u2:0b1_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u2:0b0_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u2:0b1_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s2:0b1_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s2:0b0_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p03_n2() { + let num_bits_rounded = u2:2; + let unrounded = u2:0b11; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +#[test] +fn test_w2_p03_n3() { + let num_bits_rounded = u2:3; + let unrounded = u2:0b11; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u2:0b00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u2:0b00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s2:0b00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s2:0b00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s2)); +} + +// --- Width 3 bits -------------------------------------------------------- +#[test] +fn test_w3_p00_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p00_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b00_0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p00_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b0_00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p00_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p01_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b001; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u3:0b001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u3:0b001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u3:0b001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u3:0b001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u3:0b001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u3:0b001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u3:0b001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u3:0b001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u3:0b001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u3:0b001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s3:0b001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(1) = 1 + assert_eq( + (u1:0, s3:0b001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s3:0b001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(1) = 1 + assert_eq( + (u1:0, s3:0b001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(1) = 1 + assert_eq( + (u1:0, s3:0b001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p01_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b00_1; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u3:0b00_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p01_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b0_01; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p01_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b001; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p02_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b010; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u3:0b010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u3:0b010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u3:0b010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u3:0b010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u3:0b010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u3:0b010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u3:0b010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u3:0b010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u3:0b010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u3:0b010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s3:0b010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(2) = 2 + assert_eq( + (u1:0, s3:0b010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s3:0b010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(2) = 2 + assert_eq( + (u1:0, s3:0b010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(2) = 2 + assert_eq( + (u1:0, s3:0b010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p02_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b01_0; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(1) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(1) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(1) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p02_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b0_10; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p02_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b010; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p03_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b011; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u3:0b011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u3:0b011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u3:0b011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u3:0b011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u3:0b011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u3:0b011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u3:0b011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u3:0b011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u3:0b011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u3:0b011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s3:0b011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(3) = 3 + assert_eq( + (u1:0, s3:0b011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s3:0b011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(3) = 3 + assert_eq( + (u1:0, s3:0b011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(3) = 3 + assert_eq( + (u1:0, s3:0b011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p03_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b01_1; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u3:0b01_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u3:0b01_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, s3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, s3:0b00_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s3:0b01_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, s3:0b00_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p03_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b0_11; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u3:0b0_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p03_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b011; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p04_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b100; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u3:0b100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u3:0b100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u3:0b100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u3:0b100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u3:0b100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u3:0b100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u3:0b100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u3:0b100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u3:0b100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u3:0b100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s3:0b100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s3:0b100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s3:0b100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s3:0b100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s3:0b100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p04_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b10_0; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p04_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b1_00; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p04_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b100; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p05_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b101; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u3:0b101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u3:0b101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u3:0b101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u3:0b101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u3:0b101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u3:0b101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u3:0b101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u3:0b101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u3:0b101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u3:0b101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s3:0b101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s3:0b101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s3:0b101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s3:0b101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s3:0b101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p05_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b10_1; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u3:0b10_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u3:0b10_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s3:0b10_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p05_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b1_01; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p05_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b101; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p06_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b110; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u3:0b110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u3:0b110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u3:0b110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u3:0b110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u3:0b110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u3:0b110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u3:0b110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u3:0b110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u3:0b110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u3:0b110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s3:0b110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s3:0b110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s3:0b110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s3:0b110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s3:0b110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p06_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b11_0; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p06_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b1_10; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p06_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b110; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p07_n0() { + let num_bits_rounded = u2:0; + let unrounded = u3:0b111; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u3:0b111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u3:0b111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u3:0b111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u3:0b111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u3:0b111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u3:0b111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u3:0b111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u3:0b111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u3:0b111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u3:0b111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s3:0b111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s3:0b111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s3:0b111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s3:0b111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s3:0b111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p07_n1() { + let num_bits_rounded = u2:1; + let unrounded = u3:0b11_1; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u3:0b11_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u3:0b00_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u3:0b11_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s3:0b11_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s3:0b00_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p07_n2() { + let num_bits_rounded = u2:2; + let unrounded = u3:0b1_11; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u3:0b0_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u3:0b1_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s3:0b1_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s3:0b0_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +#[test] +fn test_w3_p07_n3() { + let num_bits_rounded = u2:3; + let unrounded = u3:0b111; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u3:0b000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u3:0b000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s3:0b000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s3:0b000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s3)); +} + +// --- Width 4 bits -------------------------------------------------------- +#[test] +fn test_w4_p00_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p00_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b000_0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p00_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b00_00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p00_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p00_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p00_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0001; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u4:0b0001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u4:0b0001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u4:0b0001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u4:0b0001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u4:0b0001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u4:0b0001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u4:0b0001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u4:0b0001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u4:0b0001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u4:0b0001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s4:0b0001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1) = 1 + assert_eq( + (u1:0, s4:0b0001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s4:0b0001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1) = 1 + assert_eq( + (u1:0, s4:0b0001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1) = 1 + assert_eq( + (u1:0, s4:0b0001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b000_1; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u4:0b000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b00_01; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_001; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0001; + + // unsigned, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p01_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0001; + + // unsigned, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0010; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u4:0b0010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u4:0b0010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u4:0b0010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u4:0b0010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u4:0b0010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u4:0b0010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u4:0b0010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u4:0b0010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u4:0b0010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u4:0b0010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s4:0b0010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(2) = 2 + assert_eq( + (u1:0, s4:0b0010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s4:0b0010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(2) = 2 + assert_eq( + (u1:0, s4:0b0010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(2) = 2 + assert_eq( + (u1:0, s4:0b0010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b001_0; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b00_10; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_010; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0010; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p02_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0010; + + // unsigned, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0011; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u4:0b0011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u4:0b0011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u4:0b0011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u4:0b0011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u4:0b0011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u4:0b0011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u4:0b0011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u4:0b0011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u4:0b0011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u4:0b0011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s4:0b0011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(3) = 3 + assert_eq( + (u1:0, s4:0b0011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s4:0b0011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(3) = 3 + assert_eq( + (u1:0, s4:0b0011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(3) = 3 + assert_eq( + (u1:0, s4:0b0011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b001_1; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u4:0b001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u4:0b001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s4:0b001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b00_11; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u4:0b00_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_011; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0011; + + // unsigned, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p03_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0011; + + // unsigned, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0100; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u4:0b0100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u4:0b0100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u4:0b0100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u4:0b0100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u4:0b0100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u4:0b0100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u4:0b0100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u4:0b0100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u4:0b0100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u4:0b0100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, s4:0b0100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(4) = 4 + assert_eq( + (u1:0, s4:0b0100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(4) = 4 + assert_eq( + (u1:0, s4:0b0100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(4) = 4 + assert_eq( + (u1:0, s4:0b0100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(4) = 4 + assert_eq( + (u1:0, s4:0b0100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b010_0; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(2) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(2) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(2) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b01_00; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_100; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0100; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p04_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0100; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0101; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u4:0b0101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u4:0b0101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u4:0b0101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u4:0b0101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u4:0b0101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u4:0b0101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u4:0b0101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u4:0b0101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u4:0b0101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u4:0b0101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, s4:0b0101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(5) = 5 + assert_eq( + (u1:0, s4:0b0101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(5) = 5 + assert_eq( + (u1:0, s4:0b0101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(5) = 5 + assert_eq( + (u1:0, s4:0b0101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(5) = 5 + assert_eq( + (u1:0, s4:0b0101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b010_1; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u4:0b010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u4:0b010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, s4:0b010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b01_01; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1.25) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_101; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.625 + // RNE(0.625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0101; + + // unsigned, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p05_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0101; + + // unsigned, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0110; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u4:0b0110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u4:0b0110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u4:0b0110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u4:0b0110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u4:0b0110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u4:0b0110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u4:0b0110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u4:0b0110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u4:0b0110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u4:0b0110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, s4:0b0110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(6) = 6 + assert_eq( + (u1:0, s4:0b0110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(6) = 6 + assert_eq( + (u1:0, s4:0b0110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(6) = 6 + assert_eq( + (u1:0, s4:0b0110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(6) = 6 + assert_eq( + (u1:0, s4:0b0110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b011_0; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(3) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(3) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(3) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b01_10; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_110; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0110; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p06_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0110; + + // unsigned, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b0111; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u4:0b0111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u4:0b0111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u4:0b0111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u4:0b0111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u4:0b0111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u4:0b0111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u4:0b0111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u4:0b0111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u4:0b0111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u4:0b0111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, s4:0b0111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(7) = 7 + assert_eq( + (u1:0, s4:0b0111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(7) = 7 + assert_eq( + (u1:0, s4:0b0111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(7) = 7 + assert_eq( + (u1:0, s4:0b0111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(7) = 7 + assert_eq( + (u1:0, s4:0b0111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b011_1; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u4:0b011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u4:0b011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3.5 + // RNE(3.5) = 4 -> overflow + assert_eq( + (u1:1, s4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(3.5) = 4 -> overflow + assert_eq( + (u1:1, s4:0b000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, s4:0b011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(3.5) = 4 -> overflow + assert_eq( + (u1:1, s4:0b000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b01_11; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u4:0b01_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.75 + // RNE(1.75) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(1.75) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, s4:0b01_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(1.75) = 2 -> overflow + assert_eq( + (u1:1, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b0_111; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u4:0b0_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.875 + // RNE(0.875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b0111; + + // unsigned, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p07_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b0111; + + // unsigned, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1000; + + // unsigned, Real value is 8 + // RNE(8) = 8 + assert_eq( + (u1:0, u4:0b1000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(8) = 8 + assert_eq( + (u1:0, u4:0b1000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(8) = 8 + assert_eq( + (u1:0, u4:0b1000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(8) = 8 + assert_eq( + (u1:0, u4:0b1000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(8) = 8 + assert_eq( + (u1:0, u4:0b1000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, u4:0b1000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-8) = -8 + assert_eq( + (u1:0, u4:0b1000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, u4:0b1000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-8) = -8 + assert_eq( + (u1:0, u4:0b1000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-8) = -8 + assert_eq( + (u1:0, u4:0b1000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, s4:0b1000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-8) = -8 + assert_eq( + (u1:0, s4:0b1000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, s4:0b1000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-8) = -8 + assert_eq( + (u1:0, s4:0b1000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-8) = -8 + assert_eq( + (u1:0, s4:0b1000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b100_0; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b10_00; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_000; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1000; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p08_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1000; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1001; + + // unsigned, Real value is 9 + // RNE(9) = 9 + assert_eq( + (u1:0, u4:0b1001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(9) = 9 + assert_eq( + (u1:0, u4:0b1001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(9) = 9 + assert_eq( + (u1:0, u4:0b1001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(9) = 9 + assert_eq( + (u1:0, u4:0b1001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(9) = 9 + assert_eq( + (u1:0, u4:0b1001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -9 + // RNE(-9) = -9 + assert_eq( + (u1:0, u4:0b1001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-9) = -9 + assert_eq( + (u1:0, u4:0b1001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-9) = -9 + assert_eq( + (u1:0, u4:0b1001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-9) = -9 + assert_eq( + (u1:0, u4:0b1001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-9) = -9 + assert_eq( + (u1:0, u4:0b1001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, s4:0b1001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-7) = -7 + assert_eq( + (u1:0, s4:0b1001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, s4:0b1001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-7) = -7 + assert_eq( + (u1:0, s4:0b1001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-7) = -7 + assert_eq( + (u1:0, s4:0b1001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b100_1; + + // unsigned, Real value is 4.5 + // RNE(4.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4.5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4.5) = 4 + assert_eq( + (u1:0, u4:0b100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4.5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4.5 + // RNE(-4.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4.5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4.5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4.5) = -4 + assert_eq( + (u1:0, u4:0b100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, s4:0b100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b10_01; + + // unsigned, Real value is 2.25 + // RNE(2.25) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.25) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.25) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.25) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.25) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.25 + // RNE(-2.25) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.25) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.25) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.25) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.25) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_001; + + // unsigned, Real value is 1.125 + // RNE(1.125) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.125) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.125) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.125) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.125) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.125 + // RNE(-1.125) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.125) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.125) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.125) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.125) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1001; + + // unsigned, Real value is 0.5625 + // RNE(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5625 + // RNE(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p09_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1001; + + // unsigned, Real value is 0.28125 + // RNE(0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.28125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.28125 + // RNE(-0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.28125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.28125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1010; + + // unsigned, Real value is 10 + // RNE(10) = 10 + assert_eq( + (u1:0, u4:0b1010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(10) = 10 + assert_eq( + (u1:0, u4:0b1010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(10) = 10 + assert_eq( + (u1:0, u4:0b1010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(10) = 10 + assert_eq( + (u1:0, u4:0b1010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(10) = 10 + assert_eq( + (u1:0, u4:0b1010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -10 + // RNE(-10) = -10 + assert_eq( + (u1:0, u4:0b1010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-10) = -10 + assert_eq( + (u1:0, u4:0b1010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-10) = -10 + assert_eq( + (u1:0, u4:0b1010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-10) = -10 + assert_eq( + (u1:0, u4:0b1010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-10) = -10 + assert_eq( + (u1:0, u4:0b1010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, s4:0b1010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-6) = -6 + assert_eq( + (u1:0, s4:0b1010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, s4:0b1010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-6) = -6 + assert_eq( + (u1:0, s4:0b1010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-6) = -6 + assert_eq( + (u1:0, s4:0b1010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b101_0; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b10_10; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_010; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1010; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p10_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1010; + + // unsigned, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1011; + + // unsigned, Real value is 11 + // RNE(11) = 11 + assert_eq( + (u1:0, u4:0b1011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(11) = 11 + assert_eq( + (u1:0, u4:0b1011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(11) = 11 + assert_eq( + (u1:0, u4:0b1011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(11) = 11 + assert_eq( + (u1:0, u4:0b1011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(11) = 11 + assert_eq( + (u1:0, u4:0b1011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -11 + // RNE(-11) = -11 + assert_eq( + (u1:0, u4:0b1011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-11) = -11 + assert_eq( + (u1:0, u4:0b1011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-11) = -11 + assert_eq( + (u1:0, u4:0b1011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-11) = -11 + assert_eq( + (u1:0, u4:0b1011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-11) = -11 + assert_eq( + (u1:0, u4:0b1011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, s4:0b1011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-5) = -5 + assert_eq( + (u1:0, s4:0b1011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, s4:0b1011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-5) = -5 + assert_eq( + (u1:0, s4:0b1011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-5) = -5 + assert_eq( + (u1:0, s4:0b1011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b101_1; + + // unsigned, Real value is 5.5 + // RNE(5.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5.5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5.5) = 5 + assert_eq( + (u1:0, u4:0b101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5.5 + // RNE(-5.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5.5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5.5) = -5 + assert_eq( + (u1:0, u4:0b101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, s4:0b101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b10_11; + + // unsigned, Real value is 2.75 + // RNE(2.75) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.75) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.75) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.75) = 2 + assert_eq( + (u1:0, u4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.75) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.75 + // RNE(-2.75) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.75) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.75) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.75) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.75) = -2 + assert_eq( + (u1:0, u4:0b10_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, s4:0b10_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_011; + + // unsigned, Real value is 1.375 + // RNE(1.375) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.375) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.375) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.375) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.375) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.375 + // RNE(-1.375) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.375) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.375) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.375) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.375) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1011; + + // unsigned, Real value is 0.6875 + // RNE(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.6875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.6875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.6875 + // RNE(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.6875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.6875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p11_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1011; + + // unsigned, Real value is 0.34375 + // RNE(0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.34375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.34375 + // RNE(-0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.34375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.34375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1100; + + // unsigned, Real value is 12 + // RNE(12) = 12 + assert_eq( + (u1:0, u4:0b1100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(12) = 12 + assert_eq( + (u1:0, u4:0b1100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(12) = 12 + assert_eq( + (u1:0, u4:0b1100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(12) = 12 + assert_eq( + (u1:0, u4:0b1100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(12) = 12 + assert_eq( + (u1:0, u4:0b1100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -12 + // RNE(-12) = -12 + assert_eq( + (u1:0, u4:0b1100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-12) = -12 + assert_eq( + (u1:0, u4:0b1100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-12) = -12 + assert_eq( + (u1:0, u4:0b1100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-12) = -12 + assert_eq( + (u1:0, u4:0b1100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-12) = -12 + assert_eq( + (u1:0, u4:0b1100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s4:0b1100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s4:0b1100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s4:0b1100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s4:0b1100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s4:0b1100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b110_0; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b11_00; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_100; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1100; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p12_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1100; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1101; + + // unsigned, Real value is 13 + // RNE(13) = 13 + assert_eq( + (u1:0, u4:0b1101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(13) = 13 + assert_eq( + (u1:0, u4:0b1101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(13) = 13 + assert_eq( + (u1:0, u4:0b1101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(13) = 13 + assert_eq( + (u1:0, u4:0b1101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(13) = 13 + assert_eq( + (u1:0, u4:0b1101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -13 + // RNE(-13) = -13 + assert_eq( + (u1:0, u4:0b1101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-13) = -13 + assert_eq( + (u1:0, u4:0b1101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-13) = -13 + assert_eq( + (u1:0, u4:0b1101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-13) = -13 + assert_eq( + (u1:0, u4:0b1101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-13) = -13 + assert_eq( + (u1:0, u4:0b1101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s4:0b1101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s4:0b1101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s4:0b1101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s4:0b1101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s4:0b1101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b110_1; + + // unsigned, Real value is 6.5 + // RNE(6.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6.5) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6.5) = 6 + assert_eq( + (u1:0, u4:0b110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6.5) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6.5 + // RNE(-6.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6.5) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6.5) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6.5) = -6 + assert_eq( + (u1:0, u4:0b110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s4:0b110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b11_01; + + // unsigned, Real value is 3.25 + // RNE(3.25) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.25) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.25) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.25) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.25) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.25 + // RNE(-3.25) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.25) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.25) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.25) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.25) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_101; + + // unsigned, Real value is 1.625 + // RNE(1.625) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.625) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.625) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.625) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.625) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.625 + // RNE(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.625) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.625) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1101; + + // unsigned, Real value is 0.8125 + // RNE(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.8125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.8125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.8125 + // RNE(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.8125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.8125) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p13_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1101; + + // unsigned, Real value is 0.40625 + // RNE(0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.40625) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.40625 + // RNE(-0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.40625) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.40625) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1110; + + // unsigned, Real value is 14 + // RNE(14) = 14 + assert_eq( + (u1:0, u4:0b1110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(14) = 14 + assert_eq( + (u1:0, u4:0b1110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(14) = 14 + assert_eq( + (u1:0, u4:0b1110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(14) = 14 + assert_eq( + (u1:0, u4:0b1110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(14) = 14 + assert_eq( + (u1:0, u4:0b1110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -14 + // RNE(-14) = -14 + assert_eq( + (u1:0, u4:0b1110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-14) = -14 + assert_eq( + (u1:0, u4:0b1110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-14) = -14 + assert_eq( + (u1:0, u4:0b1110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-14) = -14 + assert_eq( + (u1:0, u4:0b1110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-14) = -14 + assert_eq( + (u1:0, u4:0b1110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s4:0b1110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s4:0b1110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s4:0b1110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s4:0b1110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s4:0b1110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b111_0; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b11_10; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_110; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1110; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p14_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1110; + + // unsigned, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n0() { + let num_bits_rounded = u3:0; + let unrounded = u4:0b1111; + + // unsigned, Real value is 15 + // RNE(15) = 15 + assert_eq( + (u1:0, u4:0b1111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(15) = 15 + assert_eq( + (u1:0, u4:0b1111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(15) = 15 + assert_eq( + (u1:0, u4:0b1111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(15) = 15 + assert_eq( + (u1:0, u4:0b1111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(15) = 15 + assert_eq( + (u1:0, u4:0b1111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -15 + // RNE(-15) = -15 + assert_eq( + (u1:0, u4:0b1111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-15) = -15 + assert_eq( + (u1:0, u4:0b1111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-15) = -15 + assert_eq( + (u1:0, u4:0b1111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-15) = -15 + assert_eq( + (u1:0, u4:0b1111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-15) = -15 + assert_eq( + (u1:0, u4:0b1111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s4:0b1111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s4:0b1111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s4:0b1111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s4:0b1111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s4:0b1111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n1() { + let num_bits_rounded = u3:1; + let unrounded = u4:0b111_1; + + // unsigned, Real value is 7.5 + // RNE(7.5) = 8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7.5) = 8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7.5) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7.5) = 7 + assert_eq( + (u1:0, u4:0b111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7.5) = 8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7.5 + // RNE(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7.5) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u4:0b000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7.5) = -7 + assert_eq( + (u1:0, u4:0b111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s4:0b111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s4:0b000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n2() { + let num_bits_rounded = u3:2; + let unrounded = u4:0b11_11; + + // unsigned, Real value is 3.75 + // RNE(3.75) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.75) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.75) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.75) = 3 + assert_eq( + (u1:0, u4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.75) = 4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.75 + // RNE(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.75) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u4:0b00_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.75) = -3 + assert_eq( + (u1:0, u4:0b11_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s4:0b11_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s4:0b00_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n3() { + let num_bits_rounded = u3:3; + let unrounded = u4:0b1_111; + + // unsigned, Real value is 1.875 + // RNE(1.875) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.875) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.875) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.875) = 1 + assert_eq( + (u1:0, u4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.875) = 2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.875 + // RNE(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.875) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u4:0b0_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.875) = -1 + assert_eq( + (u1:0, u4:0b1_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, s4:0b1_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s4:0b0_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n4() { + let num_bits_rounded = u3:4; + let unrounded = u4:0b1111; + + // unsigned, Real value is 0.9375 + // RNE(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.9375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.9375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.9375 + // RNE(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.9375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.9375) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +#[test] +fn test_w4_p15_n5() { + let num_bits_rounded = u3:5; + let unrounded = u4:0b1111; + + // unsigned, Real value is 0.46875 + // RNE(0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.46875) = 1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.46875 + // RNE(-0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.46875) = -1 -> overflow + assert_eq( + (u1:1, u4:0b0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.46875) = 0 + assert_eq( + (u1:0, u4:0b0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, s4:0b0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, s4:0b0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s4)); +} + +// --- Width 5 bits -------------------------------------------------------- +#[test] +fn test_w5_p00_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0000_0; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b000_00; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p00_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00000; + + // unsigned, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(0) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0 + // RNE(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00001; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u5:0b00001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u5:0b00001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u5:0b00001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u5:0b00001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u5:0b00001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u5:0b00001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u5:0b00001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u5:0b00001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u5:0b00001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u5:0b00001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s5:0b00001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1) = 1 + assert_eq( + (u1:0, s5:0b00001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s5:0b00001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1) = 1 + assert_eq( + (u1:0, s5:0b00001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1) = 1 + assert_eq( + (u1:0, s5:0b00001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0000_1; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b000_01; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_001; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.125) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0001; + + // unsigned, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.0625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.0625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00001; + + // unsigned, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p01_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00001; + + // unsigned, Real value is 0.015625 + // RNE(0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.015625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.015625 + // RNE(-0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.015625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.015625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.015625 + // RNE(0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.015625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00010; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u5:0b00010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u5:0b00010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u5:0b00010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u5:0b00010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u5:0b00010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u5:0b00010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u5:0b00010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u5:0b00010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u5:0b00010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u5:0b00010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s5:0b00010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2) = 2 + assert_eq( + (u1:0, s5:0b00010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s5:0b00010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2) = 2 + assert_eq( + (u1:0, s5:0b00010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2) = 2 + assert_eq( + (u1:0, s5:0b00010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0001_0; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b000_10; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_010; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0010; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00010; + + // unsigned, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p02_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00010; + + // unsigned, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.03125 + // RNE(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.03125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00011; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u5:0b00011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u5:0b00011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u5:0b00011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u5:0b00011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u5:0b00011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u5:0b00011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u5:0b00011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u5:0b00011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u5:0b00011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u5:0b00011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s5:0b00011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3) = 3 + assert_eq( + (u1:0, s5:0b00011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s5:0b00011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3) = 3 + assert_eq( + (u1:0, s5:0b00011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3) = 3 + assert_eq( + (u1:0, s5:0b00011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0001_1; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u5:0b0001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s5:0b0001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b000_11; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u5:0b000_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_011; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.375) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0011; + + // unsigned, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.1875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.1875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00011; + + // unsigned, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p03_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00011; + + // unsigned, Real value is 0.046875 + // RNE(0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.046875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.046875 + // RNE(-0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.046875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.046875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.046875 + // RNE(0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.046875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00100; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u5:0b00100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u5:0b00100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u5:0b00100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u5:0b00100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u5:0b00100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u5:0b00100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u5:0b00100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u5:0b00100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u5:0b00100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u5:0b00100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, s5:0b00100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(4) = 4 + assert_eq( + (u1:0, s5:0b00100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(4) = 4 + assert_eq( + (u1:0, s5:0b00100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(4) = 4 + assert_eq( + (u1:0, s5:0b00100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(4) = 4 + assert_eq( + (u1:0, s5:0b00100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0010_0; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b001_00; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_100; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0100; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00100; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p04_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00100; + + // unsigned, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.0625 + // RNE(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.0625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00101; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u5:0b00101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u5:0b00101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u5:0b00101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u5:0b00101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u5:0b00101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u5:0b00101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u5:0b00101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u5:0b00101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u5:0b00101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u5:0b00101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, s5:0b00101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(5) = 5 + assert_eq( + (u1:0, s5:0b00101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(5) = 5 + assert_eq( + (u1:0, s5:0b00101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(5) = 5 + assert_eq( + (u1:0, s5:0b00101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(5) = 5 + assert_eq( + (u1:0, s5:0b00101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0010_1; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u5:0b0010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, s5:0b0010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b001_01; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.25) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_101; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.625 + // RNE(0.625) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.625) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.625) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0101; + + // unsigned, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.3125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.3125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00101; + + // unsigned, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p05_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00101; + + // unsigned, Real value is 0.078125 + // RNE(0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.078125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.078125 + // RNE(-0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.078125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.078125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.078125 + // RNE(0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.078125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00110; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u5:0b00110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u5:0b00110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u5:0b00110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u5:0b00110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u5:0b00110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u5:0b00110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u5:0b00110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u5:0b00110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u5:0b00110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u5:0b00110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, s5:0b00110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(6) = 6 + assert_eq( + (u1:0, s5:0b00110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(6) = 6 + assert_eq( + (u1:0, s5:0b00110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(6) = 6 + assert_eq( + (u1:0, s5:0b00110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(6) = 6 + assert_eq( + (u1:0, s5:0b00110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0011_0; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b001_10; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_110; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0110; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00110; + + // unsigned, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p06_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00110; + + // unsigned, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.09375 + // RNE(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.09375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b00111; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u5:0b00111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u5:0b00111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u5:0b00111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u5:0b00111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u5:0b00111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u5:0b00111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u5:0b00111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u5:0b00111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u5:0b00111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u5:0b00111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, s5:0b00111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(7) = 7 + assert_eq( + (u1:0, s5:0b00111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(7) = 7 + assert_eq( + (u1:0, s5:0b00111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(7) = 7 + assert_eq( + (u1:0, s5:0b00111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(7) = 7 + assert_eq( + (u1:0, s5:0b00111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0011_1; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u5:0b0011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3.5 + // RNE(3.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, s5:0b0011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b001_11; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u5:0b001_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.75 + // RNE(1.75) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.75) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, s5:0b001_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.75) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b00_111; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u5:0b00_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.875 + // RNE(0.875) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.875) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.875) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_0111; + + // unsigned, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.4375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.4375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b00111; + + // unsigned, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p07_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b00111; + + // unsigned, Real value is 0.109375 + // RNE(0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.109375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.109375 + // RNE(-0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.109375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.109375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.109375 + // RNE(0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.109375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01000; + + // unsigned, Real value is 8 + // RNE(8) = 8 + assert_eq( + (u1:0, u5:0b01000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(8) = 8 + assert_eq( + (u1:0, u5:0b01000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(8) = 8 + assert_eq( + (u1:0, u5:0b01000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(8) = 8 + assert_eq( + (u1:0, u5:0b01000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(8) = 8 + assert_eq( + (u1:0, u5:0b01000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, u5:0b01000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-8) = -8 + assert_eq( + (u1:0, u5:0b01000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, u5:0b01000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-8) = -8 + assert_eq( + (u1:0, u5:0b01000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-8) = -8 + assert_eq( + (u1:0, u5:0b01000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 8 + // RNE(8) = 8 + assert_eq( + (u1:0, s5:0b01000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(8) = 8 + assert_eq( + (u1:0, s5:0b01000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(8) = 8 + assert_eq( + (u1:0, s5:0b01000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(8) = 8 + assert_eq( + (u1:0, s5:0b01000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(8) = 8 + assert_eq( + (u1:0, s5:0b01000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0100_0; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(4) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(4) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(4) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(4) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b010_00; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_000; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1000; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01000; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p08_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01000; + + // unsigned, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.125 + // RNE(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01001; + + // unsigned, Real value is 9 + // RNE(9) = 9 + assert_eq( + (u1:0, u5:0b01001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(9) = 9 + assert_eq( + (u1:0, u5:0b01001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(9) = 9 + assert_eq( + (u1:0, u5:0b01001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(9) = 9 + assert_eq( + (u1:0, u5:0b01001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(9) = 9 + assert_eq( + (u1:0, u5:0b01001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -9 + // RNE(-9) = -9 + assert_eq( + (u1:0, u5:0b01001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-9) = -9 + assert_eq( + (u1:0, u5:0b01001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-9) = -9 + assert_eq( + (u1:0, u5:0b01001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-9) = -9 + assert_eq( + (u1:0, u5:0b01001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-9) = -9 + assert_eq( + (u1:0, u5:0b01001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 9 + // RNE(9) = 9 + assert_eq( + (u1:0, s5:0b01001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(9) = 9 + assert_eq( + (u1:0, s5:0b01001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(9) = 9 + assert_eq( + (u1:0, s5:0b01001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(9) = 9 + assert_eq( + (u1:0, s5:0b01001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(9) = 9 + assert_eq( + (u1:0, s5:0b01001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0100_1; + + // unsigned, Real value is 4.5 + // RNE(4.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4.5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4.5) = 4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4.5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4.5 + // RNE(-4.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4.5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4.5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4.5) = -4 + assert_eq( + (u1:0, u5:0b0100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 4.5 + // RNE(4.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(4.5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(4.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(4.5) = 4 + assert_eq( + (u1:0, s5:0b0100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(4.5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b010_01; + + // unsigned, Real value is 2.25 + // RNE(2.25) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.25) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.25) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.25) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.25) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.25 + // RNE(-2.25) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.25) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.25) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.25) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.25) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2.25 + // RNE(2.25) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2.25) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2.25) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2.25) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2.25) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_001; + + // unsigned, Real value is 1.125 + // RNE(1.125) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.125) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.125) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.125) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.125) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.125 + // RNE(-1.125) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.125) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.125) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.125) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.125) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.125 + // RNE(1.125) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.125) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.125) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.125) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.125) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1001; + + // unsigned, Real value is 0.5625 + // RNE(0.5625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5625 + // RNE(-0.5625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.5625 + // RNE(0.5625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.5625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.5625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.5625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.5625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01001; + + // unsigned, Real value is 0.28125 + // RNE(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.28125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.28125 + // RNE(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.28125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.28125 + // RNE(0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.28125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p09_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01001; + + // unsigned, Real value is 0.140625 + // RNE(0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.140625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.140625 + // RNE(-0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.140625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.140625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.140625 + // RNE(0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.140625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01010; + + // unsigned, Real value is 10 + // RNE(10) = 10 + assert_eq( + (u1:0, u5:0b01010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(10) = 10 + assert_eq( + (u1:0, u5:0b01010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(10) = 10 + assert_eq( + (u1:0, u5:0b01010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(10) = 10 + assert_eq( + (u1:0, u5:0b01010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(10) = 10 + assert_eq( + (u1:0, u5:0b01010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -10 + // RNE(-10) = -10 + assert_eq( + (u1:0, u5:0b01010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-10) = -10 + assert_eq( + (u1:0, u5:0b01010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-10) = -10 + assert_eq( + (u1:0, u5:0b01010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-10) = -10 + assert_eq( + (u1:0, u5:0b01010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-10) = -10 + assert_eq( + (u1:0, u5:0b01010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 10 + // RNE(10) = 10 + assert_eq( + (u1:0, s5:0b01010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(10) = 10 + assert_eq( + (u1:0, s5:0b01010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(10) = 10 + assert_eq( + (u1:0, s5:0b01010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(10) = 10 + assert_eq( + (u1:0, s5:0b01010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(10) = 10 + assert_eq( + (u1:0, s5:0b01010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0101_0; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b010_10; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_010; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.25) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1010; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.625 + // RNE(0.625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01010; + + // unsigned, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p10_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01010; + + // unsigned, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.15625 + // RNE(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.15625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01011; + + // unsigned, Real value is 11 + // RNE(11) = 11 + assert_eq( + (u1:0, u5:0b01011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(11) = 11 + assert_eq( + (u1:0, u5:0b01011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(11) = 11 + assert_eq( + (u1:0, u5:0b01011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(11) = 11 + assert_eq( + (u1:0, u5:0b01011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(11) = 11 + assert_eq( + (u1:0, u5:0b01011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -11 + // RNE(-11) = -11 + assert_eq( + (u1:0, u5:0b01011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-11) = -11 + assert_eq( + (u1:0, u5:0b01011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-11) = -11 + assert_eq( + (u1:0, u5:0b01011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-11) = -11 + assert_eq( + (u1:0, u5:0b01011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-11) = -11 + assert_eq( + (u1:0, u5:0b01011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 11 + // RNE(11) = 11 + assert_eq( + (u1:0, s5:0b01011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(11) = 11 + assert_eq( + (u1:0, s5:0b01011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(11) = 11 + assert_eq( + (u1:0, s5:0b01011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(11) = 11 + assert_eq( + (u1:0, s5:0b01011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(11) = 11 + assert_eq( + (u1:0, s5:0b01011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0101_1; + + // unsigned, Real value is 5.5 + // RNE(5.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5.5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5.5) = 5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5.5 + // RNE(-5.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5.5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5.5) = -5 + assert_eq( + (u1:0, u5:0b0101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 5.5 + // RNE(5.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(5.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(5.5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(5.5) = 5 + assert_eq( + (u1:0, s5:0b0101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(5.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b010_11; + + // unsigned, Real value is 2.75 + // RNE(2.75) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.75) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.75) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.75) = 2 + assert_eq( + (u1:0, u5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.75) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.75 + // RNE(-2.75) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.75) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.75) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.75) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.75) = -2 + assert_eq( + (u1:0, u5:0b010_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 2.75 + // RNE(2.75) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(2.75) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(2.75) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(2.75) = 2 + assert_eq( + (u1:0, s5:0b010_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(2.75) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_011; + + // unsigned, Real value is 1.375 + // RNE(1.375) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.375) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.375) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.375) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.375) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.375 + // RNE(-1.375) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.375) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.375) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.375) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.375) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.375 + // RNE(1.375) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.375) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.375) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.375) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.375) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1011; + + // unsigned, Real value is 0.6875 + // RNE(0.6875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.6875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.6875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.6875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.6875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.6875 + // RNE(-0.6875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.6875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.6875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.6875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.6875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.6875 + // RNE(0.6875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.6875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.6875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.6875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.6875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01011; + + // unsigned, Real value is 0.34375 + // RNE(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.34375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.34375 + // RNE(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.34375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.34375 + // RNE(0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.34375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p11_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01011; + + // unsigned, Real value is 0.171875 + // RNE(0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.171875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.171875 + // RNE(-0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.171875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.171875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.171875 + // RNE(0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.171875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01100; + + // unsigned, Real value is 12 + // RNE(12) = 12 + assert_eq( + (u1:0, u5:0b01100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(12) = 12 + assert_eq( + (u1:0, u5:0b01100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(12) = 12 + assert_eq( + (u1:0, u5:0b01100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(12) = 12 + assert_eq( + (u1:0, u5:0b01100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(12) = 12 + assert_eq( + (u1:0, u5:0b01100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -12 + // RNE(-12) = -12 + assert_eq( + (u1:0, u5:0b01100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-12) = -12 + assert_eq( + (u1:0, u5:0b01100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-12) = -12 + assert_eq( + (u1:0, u5:0b01100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-12) = -12 + assert_eq( + (u1:0, u5:0b01100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-12) = -12 + assert_eq( + (u1:0, u5:0b01100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 12 + // RNE(12) = 12 + assert_eq( + (u1:0, s5:0b01100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(12) = 12 + assert_eq( + (u1:0, s5:0b01100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(12) = 12 + assert_eq( + (u1:0, s5:0b01100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(12) = 12 + assert_eq( + (u1:0, s5:0b01100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(12) = 12 + assert_eq( + (u1:0, s5:0b01100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0110_0; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(6) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(6) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(6) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(6) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b011_00; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_100; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1100; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01100; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p12_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01100; + + // unsigned, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.1875 + // RNE(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.1875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01101; + + // unsigned, Real value is 13 + // RNE(13) = 13 + assert_eq( + (u1:0, u5:0b01101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(13) = 13 + assert_eq( + (u1:0, u5:0b01101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(13) = 13 + assert_eq( + (u1:0, u5:0b01101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(13) = 13 + assert_eq( + (u1:0, u5:0b01101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(13) = 13 + assert_eq( + (u1:0, u5:0b01101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -13 + // RNE(-13) = -13 + assert_eq( + (u1:0, u5:0b01101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-13) = -13 + assert_eq( + (u1:0, u5:0b01101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-13) = -13 + assert_eq( + (u1:0, u5:0b01101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-13) = -13 + assert_eq( + (u1:0, u5:0b01101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-13) = -13 + assert_eq( + (u1:0, u5:0b01101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 13 + // RNE(13) = 13 + assert_eq( + (u1:0, s5:0b01101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(13) = 13 + assert_eq( + (u1:0, s5:0b01101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(13) = 13 + assert_eq( + (u1:0, s5:0b01101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(13) = 13 + assert_eq( + (u1:0, s5:0b01101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(13) = 13 + assert_eq( + (u1:0, s5:0b01101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0110_1; + + // unsigned, Real value is 6.5 + // RNE(6.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6.5) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6.5) = 6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6.5) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6.5 + // RNE(-6.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6.5) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6.5) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6.5) = -6 + assert_eq( + (u1:0, u5:0b0110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 6.5 + // RNE(6.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(6.5) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(6.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(6.5) = 6 + assert_eq( + (u1:0, s5:0b0110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(6.5) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b011_01; + + // unsigned, Real value is 3.25 + // RNE(3.25) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.25) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.25) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.25) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.25) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.25 + // RNE(-3.25) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.25) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.25) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.25) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.25) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3.25 + // RNE(3.25) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3.25) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3.25) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3.25) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3.25) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_101; + + // unsigned, Real value is 1.625 + // RNE(1.625) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.625) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.625) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.625) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.625) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.625 + // RNE(-1.625) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.625) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.625) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.625) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.625) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.625 + // RNE(1.625) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.625) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.625) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.625) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.625) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1101; + + // unsigned, Real value is 0.8125 + // RNE(0.8125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.8125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.8125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.8125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.8125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.8125 + // RNE(-0.8125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.8125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.8125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.8125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.8125) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.8125 + // RNE(0.8125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.8125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.8125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.8125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.8125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01101; + + // unsigned, Real value is 0.40625 + // RNE(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.40625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.40625 + // RNE(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.40625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.40625 + // RNE(0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.40625) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p13_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01101; + + // unsigned, Real value is 0.203125 + // RNE(0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.203125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.203125 + // RNE(-0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.203125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.203125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.203125 + // RNE(0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.203125) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01110; + + // unsigned, Real value is 14 + // RNE(14) = 14 + assert_eq( + (u1:0, u5:0b01110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(14) = 14 + assert_eq( + (u1:0, u5:0b01110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(14) = 14 + assert_eq( + (u1:0, u5:0b01110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(14) = 14 + assert_eq( + (u1:0, u5:0b01110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(14) = 14 + assert_eq( + (u1:0, u5:0b01110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -14 + // RNE(-14) = -14 + assert_eq( + (u1:0, u5:0b01110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-14) = -14 + assert_eq( + (u1:0, u5:0b01110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-14) = -14 + assert_eq( + (u1:0, u5:0b01110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-14) = -14 + assert_eq( + (u1:0, u5:0b01110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-14) = -14 + assert_eq( + (u1:0, u5:0b01110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 14 + // RNE(14) = 14 + assert_eq( + (u1:0, s5:0b01110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(14) = 14 + assert_eq( + (u1:0, s5:0b01110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(14) = 14 + assert_eq( + (u1:0, s5:0b01110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(14) = 14 + assert_eq( + (u1:0, s5:0b01110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(14) = 14 + assert_eq( + (u1:0, s5:0b01110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0111_0; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(7) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(7) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(7) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(7) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b011_10; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3.5 + // RNE(3.5) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3.5) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3.5) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_110; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.75 + // RNE(1.75) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.75) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.75) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1110; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.875 + // RNE(0.875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01110; + + // unsigned, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p14_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01110; + + // unsigned, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.21875 + // RNE(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.21875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b01111; + + // unsigned, Real value is 15 + // RNE(15) = 15 + assert_eq( + (u1:0, u5:0b01111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(15) = 15 + assert_eq( + (u1:0, u5:0b01111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(15) = 15 + assert_eq( + (u1:0, u5:0b01111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(15) = 15 + assert_eq( + (u1:0, u5:0b01111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(15) = 15 + assert_eq( + (u1:0, u5:0b01111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -15 + // RNE(-15) = -15 + assert_eq( + (u1:0, u5:0b01111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-15) = -15 + assert_eq( + (u1:0, u5:0b01111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-15) = -15 + assert_eq( + (u1:0, u5:0b01111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-15) = -15 + assert_eq( + (u1:0, u5:0b01111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-15) = -15 + assert_eq( + (u1:0, u5:0b01111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 15 + // RNE(15) = 15 + assert_eq( + (u1:0, s5:0b01111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(15) = 15 + assert_eq( + (u1:0, s5:0b01111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(15) = 15 + assert_eq( + (u1:0, s5:0b01111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(15) = 15 + assert_eq( + (u1:0, s5:0b01111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(15) = 15 + assert_eq( + (u1:0, s5:0b01111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b0111_1; + + // unsigned, Real value is 7.5 + // RNE(7.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7.5) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7.5) = 7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7.5 + // RNE(-7.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7.5) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7.5) = -7 + assert_eq( + (u1:0, u5:0b0111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 7.5 + // RNE(7.5) = 8 -> overflow + assert_eq( + (u1:1, s5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(7.5) = 8 -> overflow + assert_eq( + (u1:1, s5:0b0000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(7.5) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(7.5) = 7 + assert_eq( + (u1:0, s5:0b0111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(7.5) = 8 -> overflow + assert_eq( + (u1:1, s5:0b0000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b011_11; + + // unsigned, Real value is 3.75 + // RNE(3.75) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.75) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.75) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.75) = 3 + assert_eq( + (u1:0, u5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.75) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.75 + // RNE(-3.75) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.75) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.75) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.75) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.75) = -3 + assert_eq( + (u1:0, u5:0b011_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 3.75 + // RNE(3.75) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(3.75) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(3.75) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(3.75) = 3 + assert_eq( + (u1:0, s5:0b011_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(3.75) = 4 -> overflow + assert_eq( + (u1:1, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b01_111; + + // unsigned, Real value is 1.875 + // RNE(1.875) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.875) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.875) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.875) = 1 + assert_eq( + (u1:0, u5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.875) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.875 + // RNE(-1.875) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.875) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.875) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.875) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.875) = -1 + assert_eq( + (u1:0, u5:0b01_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 1.875 + // RNE(1.875) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(1.875) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(1.875) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(1.875) = 1 + assert_eq( + (u1:0, s5:0b01_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(1.875) = 2 -> overflow + assert_eq( + (u1:1, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b0_1111; + + // unsigned, Real value is 0.9375 + // RNE(0.9375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.9375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.9375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.9375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.9375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.9375 + // RNE(-0.9375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.9375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.9375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.9375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.9375) = 0 + assert_eq( + (u1:0, u5:0b0_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.9375 + // RNE(0.9375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.9375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.9375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.9375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.9375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b01111; + + // unsigned, Real value is 0.46875 + // RNE(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.46875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.46875 + // RNE(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.46875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.46875 + // RNE(0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.46875) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p15_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b01111; + + // unsigned, Real value is 0.234375 + // RNE(0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.234375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.234375 + // RNE(-0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.234375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.234375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is 0.234375 + // RNE(0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(0.234375) = 1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10000; + + // unsigned, Real value is 16 + // RNE(16) = 16 + assert_eq( + (u1:0, u5:0b10000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(16) = 16 + assert_eq( + (u1:0, u5:0b10000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(16) = 16 + assert_eq( + (u1:0, u5:0b10000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(16) = 16 + assert_eq( + (u1:0, u5:0b10000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(16) = 16 + assert_eq( + (u1:0, u5:0b10000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -16 + // RNE(-16) = -16 + assert_eq( + (u1:0, u5:0b10000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-16) = -16 + assert_eq( + (u1:0, u5:0b10000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-16) = -16 + assert_eq( + (u1:0, u5:0b10000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-16) = -16 + assert_eq( + (u1:0, u5:0b10000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-16) = -16 + assert_eq( + (u1:0, u5:0b10000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -16 + // RNE(-16) = -16 + assert_eq( + (u1:0, s5:0b10000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-16) = -16 + assert_eq( + (u1:0, s5:0b10000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-16) = -16 + assert_eq( + (u1:0, s5:0b10000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-16) = -16 + assert_eq( + (u1:0, s5:0b10000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-16) = -16 + assert_eq( + (u1:0, s5:0b10000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1000_0; + + // unsigned, Real value is 8 + // RNE(8) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(8) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(8) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(8) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(8) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-8) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-8) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-8) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-8) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-8) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-8) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b100_00; + + // unsigned, Real value is 4 + // RNE(4) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_000; + + // unsigned, Real value is 2 + // RNE(2) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0000; + + // unsigned, Real value is 1 + // RNE(1) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10000; + + // unsigned, Real value is 0.5 + // RNE(0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p16_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10000; + + // unsigned, Real value is 0.25 + // RNE(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.25) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10001; + + // unsigned, Real value is 17 + // RNE(17) = 17 + assert_eq( + (u1:0, u5:0b10001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(17) = 17 + assert_eq( + (u1:0, u5:0b10001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(17) = 17 + assert_eq( + (u1:0, u5:0b10001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(17) = 17 + assert_eq( + (u1:0, u5:0b10001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(17) = 17 + assert_eq( + (u1:0, u5:0b10001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -17 + // RNE(-17) = -17 + assert_eq( + (u1:0, u5:0b10001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-17) = -17 + assert_eq( + (u1:0, u5:0b10001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-17) = -17 + assert_eq( + (u1:0, u5:0b10001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-17) = -17 + assert_eq( + (u1:0, u5:0b10001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-17) = -17 + assert_eq( + (u1:0, u5:0b10001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -15 + // RNE(-15) = -15 + assert_eq( + (u1:0, s5:0b10001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-15) = -15 + assert_eq( + (u1:0, s5:0b10001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-15) = -15 + assert_eq( + (u1:0, s5:0b10001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-15) = -15 + assert_eq( + (u1:0, s5:0b10001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-15) = -15 + assert_eq( + (u1:0, s5:0b10001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1000_1; + + // unsigned, Real value is 8.5 + // RNE(8.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(8.5) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(8.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(8.5) = 8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(8.5) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -8.5 + // RNE(-8.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-8.5) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-8.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-8.5) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-8.5) = -8 + assert_eq( + (u1:0, u5:0b1000_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -7.5 + // RNE(-7.5) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-7.5) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-7.5) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-7.5) = -8 + assert_eq( + (u1:0, s5:0b1000_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-7.5) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b100_01; + + // unsigned, Real value is 4.25 + // RNE(4.25) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4.25) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4.25) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4.25) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4.25) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4.25 + // RNE(-4.25) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4.25) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4.25) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4.25) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4.25) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3.75 + // RNE(-3.75) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3.75) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3.75) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3.75) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3.75) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_001; + + // unsigned, Real value is 2.125 + // RNE(2.125) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.125) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.125) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.125) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.125) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.125 + // RNE(-2.125) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.125) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.125) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.125) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.125) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.875 + // RNE(-1.875) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.875) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.875) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.875) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.875) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0001; + + // unsigned, Real value is 1.0625 + // RNE(1.0625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.0625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.0625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.0625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.0625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.0625 + // RNE(-1.0625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.0625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.0625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.0625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.0625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.9375 + // RNE(-0.9375) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.9375) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.9375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.9375) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.9375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10001; + + // unsigned, Real value is 0.53125 + // RNE(0.53125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.53125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.53125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.53125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.53125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.53125 + // RNE(-0.53125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.53125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.53125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.53125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.53125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.46875 + // RNE(-0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.46875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.46875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p17_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10001; + + // unsigned, Real value is 0.265625 + // RNE(0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.265625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.265625 + // RNE(-0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.265625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.265625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.234375 + // RNE(-0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.234375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.234375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10010; + + // unsigned, Real value is 18 + // RNE(18) = 18 + assert_eq( + (u1:0, u5:0b10010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(18) = 18 + assert_eq( + (u1:0, u5:0b10010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(18) = 18 + assert_eq( + (u1:0, u5:0b10010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(18) = 18 + assert_eq( + (u1:0, u5:0b10010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(18) = 18 + assert_eq( + (u1:0, u5:0b10010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -18 + // RNE(-18) = -18 + assert_eq( + (u1:0, u5:0b10010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-18) = -18 + assert_eq( + (u1:0, u5:0b10010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-18) = -18 + assert_eq( + (u1:0, u5:0b10010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-18) = -18 + assert_eq( + (u1:0, u5:0b10010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-18) = -18 + assert_eq( + (u1:0, u5:0b10010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -14 + // RNE(-14) = -14 + assert_eq( + (u1:0, s5:0b10010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-14) = -14 + assert_eq( + (u1:0, s5:0b10010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-14) = -14 + assert_eq( + (u1:0, s5:0b10010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-14) = -14 + assert_eq( + (u1:0, s5:0b10010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-14) = -14 + assert_eq( + (u1:0, s5:0b10010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1001_0; + + // unsigned, Real value is 9 + // RNE(9) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(9) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(9) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(9) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(9) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -9 + // RNE(-9) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-9) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-9) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-9) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-9) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-7) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-7) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-7) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b100_10; + + // unsigned, Real value is 4.5 + // RNE(4.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4.5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4.5) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4.5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4.5 + // RNE(-4.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4.5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4.5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4.5) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_010; + + // unsigned, Real value is 2.25 + // RNE(2.25) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.25) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.25) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.25) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.25) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.25 + // RNE(-2.25) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.25) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.25) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.25) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.25) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0010; + + // unsigned, Real value is 1.125 + // RNE(1.125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.125) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.125 + // RNE(-1.125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.125) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10010; + + // unsigned, Real value is 0.5625 + // RNE(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.5625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.5625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.5625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.5625 + // RNE(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.5625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.5625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.5625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p18_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10010; + + // unsigned, Real value is 0.28125 + // RNE(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.28125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.28125 + // RNE(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.28125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.28125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10011; + + // unsigned, Real value is 19 + // RNE(19) = 19 + assert_eq( + (u1:0, u5:0b10011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(19) = 19 + assert_eq( + (u1:0, u5:0b10011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(19) = 19 + assert_eq( + (u1:0, u5:0b10011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(19) = 19 + assert_eq( + (u1:0, u5:0b10011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(19) = 19 + assert_eq( + (u1:0, u5:0b10011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -19 + // RNE(-19) = -19 + assert_eq( + (u1:0, u5:0b10011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-19) = -19 + assert_eq( + (u1:0, u5:0b10011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-19) = -19 + assert_eq( + (u1:0, u5:0b10011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-19) = -19 + assert_eq( + (u1:0, u5:0b10011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-19) = -19 + assert_eq( + (u1:0, u5:0b10011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -13 + // RNE(-13) = -13 + assert_eq( + (u1:0, s5:0b10011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-13) = -13 + assert_eq( + (u1:0, s5:0b10011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-13) = -13 + assert_eq( + (u1:0, s5:0b10011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-13) = -13 + assert_eq( + (u1:0, s5:0b10011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-13) = -13 + assert_eq( + (u1:0, s5:0b10011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1001_1; + + // unsigned, Real value is 9.5 + // RNE(9.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(9.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(9.5) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(9.5) = 9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(9.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -9.5 + // RNE(-9.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-9.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-9.5) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-9.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-9.5) = -9 + assert_eq( + (u1:0, u5:0b1001_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -6.5 + // RNE(-6.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-6.5) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-6.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-6.5) = -7 + assert_eq( + (u1:0, s5:0b1001_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-6.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b100_11; + + // unsigned, Real value is 4.75 + // RNE(4.75) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(4.75) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(4.75) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(4.75) = 4 + assert_eq( + (u1:0, u5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(4.75) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -4.75 + // RNE(-4.75) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-4.75) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-4.75) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-4.75) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-4.75) = -4 + assert_eq( + (u1:0, u5:0b100_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3.25 + // RNE(-3.25) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3.25) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3.25) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3.25) = -4 + assert_eq( + (u1:0, s5:0b100_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3.25) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_011; + + // unsigned, Real value is 2.375 + // RNE(2.375) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.375) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.375) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.375) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.375) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.375 + // RNE(-2.375) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.375) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.375) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.375) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.375) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.625 + // RNE(-1.625) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.625) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.625) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.625) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.625) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0011; + + // unsigned, Real value is 1.1875 + // RNE(1.1875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.1875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.1875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.1875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.1875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.1875 + // RNE(-1.1875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.1875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.1875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.1875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.1875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.8125 + // RNE(-0.8125) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.8125) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.8125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.8125) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.8125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10011; + + // unsigned, Real value is 0.59375 + // RNE(0.59375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.59375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.59375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.59375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.59375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.59375 + // RNE(-0.59375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.59375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.59375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.59375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.59375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.40625 + // RNE(-0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.40625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.40625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p19_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10011; + + // unsigned, Real value is 0.296875 + // RNE(0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.296875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.296875 + // RNE(-0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.296875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.296875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.203125 + // RNE(-0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.203125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.203125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10100; + + // unsigned, Real value is 20 + // RNE(20) = 20 + assert_eq( + (u1:0, u5:0b10100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(20) = 20 + assert_eq( + (u1:0, u5:0b10100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(20) = 20 + assert_eq( + (u1:0, u5:0b10100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(20) = 20 + assert_eq( + (u1:0, u5:0b10100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(20) = 20 + assert_eq( + (u1:0, u5:0b10100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -20 + // RNE(-20) = -20 + assert_eq( + (u1:0, u5:0b10100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-20) = -20 + assert_eq( + (u1:0, u5:0b10100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-20) = -20 + assert_eq( + (u1:0, u5:0b10100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-20) = -20 + assert_eq( + (u1:0, u5:0b10100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-20) = -20 + assert_eq( + (u1:0, u5:0b10100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -12 + // RNE(-12) = -12 + assert_eq( + (u1:0, s5:0b10100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-12) = -12 + assert_eq( + (u1:0, s5:0b10100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-12) = -12 + assert_eq( + (u1:0, s5:0b10100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-12) = -12 + assert_eq( + (u1:0, s5:0b10100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-12) = -12 + assert_eq( + (u1:0, s5:0b10100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1010_0; + + // unsigned, Real value is 10 + // RNE(10) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(10) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(10) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(10) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(10) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -10 + // RNE(-10) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-10) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-10) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-10) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-10) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-6) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-6) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-6) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b101_00; + + // unsigned, Real value is 5 + // RNE(5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_100; + + // unsigned, Real value is 2.5 + // RNE(2.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.5) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.5) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.5) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0100; + + // unsigned, Real value is 1.25 + // RNE(1.25) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.25) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.25) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.25) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.25) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.25) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10100; + + // unsigned, Real value is 0.625 + // RNE(0.625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.625 + // RNE(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p20_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10100; + + // unsigned, Real value is 0.3125 + // RNE(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.3125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10101; + + // unsigned, Real value is 21 + // RNE(21) = 21 + assert_eq( + (u1:0, u5:0b10101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(21) = 21 + assert_eq( + (u1:0, u5:0b10101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(21) = 21 + assert_eq( + (u1:0, u5:0b10101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(21) = 21 + assert_eq( + (u1:0, u5:0b10101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(21) = 21 + assert_eq( + (u1:0, u5:0b10101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -21 + // RNE(-21) = -21 + assert_eq( + (u1:0, u5:0b10101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-21) = -21 + assert_eq( + (u1:0, u5:0b10101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-21) = -21 + assert_eq( + (u1:0, u5:0b10101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-21) = -21 + assert_eq( + (u1:0, u5:0b10101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-21) = -21 + assert_eq( + (u1:0, u5:0b10101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -11 + // RNE(-11) = -11 + assert_eq( + (u1:0, s5:0b10101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-11) = -11 + assert_eq( + (u1:0, s5:0b10101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-11) = -11 + assert_eq( + (u1:0, s5:0b10101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-11) = -11 + assert_eq( + (u1:0, s5:0b10101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-11) = -11 + assert_eq( + (u1:0, s5:0b10101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1010_1; + + // unsigned, Real value is 10.5 + // RNE(10.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(10.5) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(10.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(10.5) = 10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(10.5) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -10.5 + // RNE(-10.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-10.5) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-10.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-10.5) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-10.5) = -10 + assert_eq( + (u1:0, u5:0b1010_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -5.5 + // RNE(-5.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-5.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-5.5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-5.5) = -6 + assert_eq( + (u1:0, s5:0b1010_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-5.5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b101_01; + + // unsigned, Real value is 5.25 + // RNE(5.25) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5.25) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5.25) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5.25) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5.25) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5.25 + // RNE(-5.25) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5.25) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5.25) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5.25) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5.25) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2.75 + // RNE(-2.75) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2.75) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2.75) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2.75) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2.75) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_101; + + // unsigned, Real value is 2.625 + // RNE(2.625) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.625) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.625) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.625) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.625) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.625 + // RNE(-2.625) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.625) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.625) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.625) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.625) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.375 + // RNE(-1.375) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.375) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.375) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.375) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.375) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0101; + + // unsigned, Real value is 1.3125 + // RNE(1.3125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.3125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.3125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.3125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.3125) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.3125 + // RNE(-1.3125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.3125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.3125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.3125) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.3125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.6875 + // RNE(-0.6875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.6875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.6875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.6875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.6875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10101; + + // unsigned, Real value is 0.65625 + // RNE(0.65625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.65625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.65625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.65625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.65625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.65625 + // RNE(-0.65625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.65625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.65625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.65625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.65625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.34375 + // RNE(-0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.34375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.34375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p21_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10101; + + // unsigned, Real value is 0.328125 + // RNE(0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.328125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.328125 + // RNE(-0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.328125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.328125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.171875 + // RNE(-0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.171875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.171875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10110; + + // unsigned, Real value is 22 + // RNE(22) = 22 + assert_eq( + (u1:0, u5:0b10110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(22) = 22 + assert_eq( + (u1:0, u5:0b10110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(22) = 22 + assert_eq( + (u1:0, u5:0b10110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(22) = 22 + assert_eq( + (u1:0, u5:0b10110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(22) = 22 + assert_eq( + (u1:0, u5:0b10110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -22 + // RNE(-22) = -22 + assert_eq( + (u1:0, u5:0b10110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-22) = -22 + assert_eq( + (u1:0, u5:0b10110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-22) = -22 + assert_eq( + (u1:0, u5:0b10110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-22) = -22 + assert_eq( + (u1:0, u5:0b10110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-22) = -22 + assert_eq( + (u1:0, u5:0b10110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -10 + // RNE(-10) = -10 + assert_eq( + (u1:0, s5:0b10110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-10) = -10 + assert_eq( + (u1:0, s5:0b10110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-10) = -10 + assert_eq( + (u1:0, s5:0b10110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-10) = -10 + assert_eq( + (u1:0, s5:0b10110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-10) = -10 + assert_eq( + (u1:0, s5:0b10110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1011_0; + + // unsigned, Real value is 11 + // RNE(11) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(11) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(11) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(11) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(11) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -11 + // RNE(-11) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-11) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-11) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-11) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-11) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b101_10; + + // unsigned, Real value is 5.5 + // RNE(5.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5.5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5.5) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5.5 + // RNE(-5.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5.5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5.5) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_110; + + // unsigned, Real value is 2.75 + // RNE(2.75) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.75) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.75) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.75) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.75) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.75 + // RNE(-2.75) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.75) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.75) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.75) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.75) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0110; + + // unsigned, Real value is 1.375 + // RNE(1.375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.375) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.375 + // RNE(-1.375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.375) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10110; + + // unsigned, Real value is 0.6875 + // RNE(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.6875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.6875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.6875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.6875 + // RNE(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.6875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.6875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.6875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.3125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p22_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10110; + + // unsigned, Real value is 0.34375 + // RNE(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.34375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.34375 + // RNE(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.34375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.34375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b10111; + + // unsigned, Real value is 23 + // RNE(23) = 23 + assert_eq( + (u1:0, u5:0b10111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(23) = 23 + assert_eq( + (u1:0, u5:0b10111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(23) = 23 + assert_eq( + (u1:0, u5:0b10111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(23) = 23 + assert_eq( + (u1:0, u5:0b10111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(23) = 23 + assert_eq( + (u1:0, u5:0b10111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -23 + // RNE(-23) = -23 + assert_eq( + (u1:0, u5:0b10111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-23) = -23 + assert_eq( + (u1:0, u5:0b10111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-23) = -23 + assert_eq( + (u1:0, u5:0b10111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-23) = -23 + assert_eq( + (u1:0, u5:0b10111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-23) = -23 + assert_eq( + (u1:0, u5:0b10111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -9 + // RNE(-9) = -9 + assert_eq( + (u1:0, s5:0b10111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-9) = -9 + assert_eq( + (u1:0, s5:0b10111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-9) = -9 + assert_eq( + (u1:0, s5:0b10111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-9) = -9 + assert_eq( + (u1:0, s5:0b10111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-9) = -9 + assert_eq( + (u1:0, s5:0b10111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1011_1; + + // unsigned, Real value is 11.5 + // RNE(11.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(11.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(11.5) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(11.5) = 11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(11.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -11.5 + // RNE(-11.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-11.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-11.5) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-11.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-11.5) = -11 + assert_eq( + (u1:0, u5:0b1011_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4.5 + // RNE(-4.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-4.5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-4.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-4.5) = -5 + assert_eq( + (u1:0, s5:0b1011_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-4.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b101_11; + + // unsigned, Real value is 5.75 + // RNE(5.75) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(5.75) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(5.75) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(5.75) = 5 + assert_eq( + (u1:0, u5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(5.75) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -5.75 + // RNE(-5.75) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-5.75) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-5.75) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-5.75) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-5.75) = -5 + assert_eq( + (u1:0, u5:0b101_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2.25 + // RNE(-2.25) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2.25) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2.25) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2.25) = -3 + assert_eq( + (u1:0, s5:0b101_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2.25) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b10_111; + + // unsigned, Real value is 2.875 + // RNE(2.875) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(2.875) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(2.875) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(2.875) = 2 + assert_eq( + (u1:0, u5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(2.875) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -2.875 + // RNE(-2.875) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-2.875) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-2.875) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-2.875) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-2.875) = -2 + assert_eq( + (u1:0, u5:0b10_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.125 + // RNE(-1.125) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.125) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.125) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.125) = -2 + assert_eq( + (u1:0, s5:0b10_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.125) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_0111; + + // unsigned, Real value is 1.4375 + // RNE(1.4375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.4375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.4375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.4375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.4375) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.4375 + // RNE(-1.4375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.4375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.4375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.4375) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.4375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5625 + // RNE(-0.5625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b10111; + + // unsigned, Real value is 0.71875 + // RNE(0.71875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.71875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.71875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.71875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.71875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.71875 + // RNE(-0.71875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.71875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.71875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.71875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.71875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.28125 + // RNE(-0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.28125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.28125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p23_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b10111; + + // unsigned, Real value is 0.359375 + // RNE(0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.359375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.359375 + // RNE(-0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.359375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.359375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.140625 + // RNE(-0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.140625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.140625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11000; + + // unsigned, Real value is 24 + // RNE(24) = 24 + assert_eq( + (u1:0, u5:0b11000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(24) = 24 + assert_eq( + (u1:0, u5:0b11000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(24) = 24 + assert_eq( + (u1:0, u5:0b11000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(24) = 24 + assert_eq( + (u1:0, u5:0b11000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(24) = 24 + assert_eq( + (u1:0, u5:0b11000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -24 + // RNE(-24) = -24 + assert_eq( + (u1:0, u5:0b11000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-24) = -24 + assert_eq( + (u1:0, u5:0b11000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-24) = -24 + assert_eq( + (u1:0, u5:0b11000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-24) = -24 + assert_eq( + (u1:0, u5:0b11000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-24) = -24 + assert_eq( + (u1:0, u5:0b11000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -8 + // RNE(-8) = -8 + assert_eq( + (u1:0, s5:0b11000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-8) = -8 + assert_eq( + (u1:0, s5:0b11000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-8) = -8 + assert_eq( + (u1:0, s5:0b11000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-8) = -8 + assert_eq( + (u1:0, s5:0b11000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-8) = -8 + assert_eq( + (u1:0, s5:0b11000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1100_0; + + // unsigned, Real value is 12 + // RNE(12) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(12) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(12) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(12) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(12) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -12 + // RNE(-12) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-12) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-12) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-12) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-12) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b110_00; + + // unsigned, Real value is 6 + // RNE(6) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_000; + + // unsigned, Real value is 3 + // RNE(3) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1000; + + // unsigned, Real value is 1.5 + // RNE(1.5) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5 + // RNE(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11000; + + // unsigned, Real value is 0.75 + // RNE(0.75) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.75) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.75) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.75) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.75) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.75 + // RNE(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.75) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.25) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p24_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11000; + + // unsigned, Real value is 0.375 + // RNE(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11001; + + // unsigned, Real value is 25 + // RNE(25) = 25 + assert_eq( + (u1:0, u5:0b11001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(25) = 25 + assert_eq( + (u1:0, u5:0b11001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(25) = 25 + assert_eq( + (u1:0, u5:0b11001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(25) = 25 + assert_eq( + (u1:0, u5:0b11001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(25) = 25 + assert_eq( + (u1:0, u5:0b11001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -25 + // RNE(-25) = -25 + assert_eq( + (u1:0, u5:0b11001), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-25) = -25 + assert_eq( + (u1:0, u5:0b11001), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-25) = -25 + assert_eq( + (u1:0, u5:0b11001), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-25) = -25 + assert_eq( + (u1:0, u5:0b11001), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-25) = -25 + assert_eq( + (u1:0, u5:0b11001), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, s5:0b11001), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-7) = -7 + assert_eq( + (u1:0, s5:0b11001), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, s5:0b11001), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-7) = -7 + assert_eq( + (u1:0, s5:0b11001), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-7) = -7 + assert_eq( + (u1:0, s5:0b11001), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1100_1; + + // unsigned, Real value is 12.5 + // RNE(12.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(12.5) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(12.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(12.5) = 12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(12.5) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -12.5 + // RNE(-12.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-12.5) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-12.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-12.5) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-12.5) = -12 + assert_eq( + (u1:0, u5:0b1100_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3.5 + // RNE(-3.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3.5) = -4 + assert_eq( + (u1:0, s5:0b1100_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b110_01; + + // unsigned, Real value is 6.25 + // RNE(6.25) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6.25) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6.25) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6.25) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6.25) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6.25 + // RNE(-6.25) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6.25) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6.25) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6.25) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6.25) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.75 + // RNE(-1.75) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.75) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.75) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_001; + + // unsigned, Real value is 3.125 + // RNE(3.125) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.125) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.125) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.125) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.125) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.125 + // RNE(-3.125) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.125) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.125) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.125) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.125) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.875 + // RNE(-0.875) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.875) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.875) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1001; + + // unsigned, Real value is 1.5625 + // RNE(1.5625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.5625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.5625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.5625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.5625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.5625 + // RNE(-1.5625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.5625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.5625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.5625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.5625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.4375) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11001; + + // unsigned, Real value is 0.78125 + // RNE(0.78125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.78125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.78125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.78125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.78125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.78125 + // RNE(-0.78125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.78125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.78125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.78125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.78125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.21875 + // RNE(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.21875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.21875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p25_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11001; + + // unsigned, Real value is 0.390625 + // RNE(0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.390625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.390625 + // RNE(-0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.390625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.390625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.109375 + // RNE(-0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.109375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.109375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11010; + + // unsigned, Real value is 26 + // RNE(26) = 26 + assert_eq( + (u1:0, u5:0b11010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(26) = 26 + assert_eq( + (u1:0, u5:0b11010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(26) = 26 + assert_eq( + (u1:0, u5:0b11010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(26) = 26 + assert_eq( + (u1:0, u5:0b11010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(26) = 26 + assert_eq( + (u1:0, u5:0b11010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -26 + // RNE(-26) = -26 + assert_eq( + (u1:0, u5:0b11010), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-26) = -26 + assert_eq( + (u1:0, u5:0b11010), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-26) = -26 + assert_eq( + (u1:0, u5:0b11010), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-26) = -26 + assert_eq( + (u1:0, u5:0b11010), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-26) = -26 + assert_eq( + (u1:0, u5:0b11010), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -6 + // RNE(-6) = -6 + assert_eq( + (u1:0, s5:0b11010), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-6) = -6 + assert_eq( + (u1:0, s5:0b11010), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-6) = -6 + assert_eq( + (u1:0, s5:0b11010), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-6) = -6 + assert_eq( + (u1:0, s5:0b11010), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-6) = -6 + assert_eq( + (u1:0, s5:0b11010), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1101_0; + + // unsigned, Real value is 13 + // RNE(13) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(13) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(13) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(13) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(13) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -13 + // RNE(-13) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-13) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-13) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-13) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-13) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b110_10; + + // unsigned, Real value is 6.5 + // RNE(6.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6.5) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6.5) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6.5) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6.5 + // RNE(-6.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6.5) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6.5) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6.5) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_010; + + // unsigned, Real value is 3.25 + // RNE(3.25) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.25) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.25) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.25) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.25) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.25 + // RNE(-3.25) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.25) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.25) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.25) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.25) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1010; + + // unsigned, Real value is 1.625 + // RNE(1.625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.625) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.625) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.625 + // RNE(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.625) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.625) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11010; + + // unsigned, Real value is 0.8125 + // RNE(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.8125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.8125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.8125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.8125 + // RNE(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.8125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.8125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.8125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.1875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p26_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11010; + + // unsigned, Real value is 0.40625 + // RNE(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.40625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.40625 + // RNE(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.40625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.40625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11011; + + // unsigned, Real value is 27 + // RNE(27) = 27 + assert_eq( + (u1:0, u5:0b11011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(27) = 27 + assert_eq( + (u1:0, u5:0b11011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(27) = 27 + assert_eq( + (u1:0, u5:0b11011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(27) = 27 + assert_eq( + (u1:0, u5:0b11011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(27) = 27 + assert_eq( + (u1:0, u5:0b11011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -27 + // RNE(-27) = -27 + assert_eq( + (u1:0, u5:0b11011), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-27) = -27 + assert_eq( + (u1:0, u5:0b11011), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-27) = -27 + assert_eq( + (u1:0, u5:0b11011), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-27) = -27 + assert_eq( + (u1:0, u5:0b11011), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-27) = -27 + assert_eq( + (u1:0, u5:0b11011), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -5 + // RNE(-5) = -5 + assert_eq( + (u1:0, s5:0b11011), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-5) = -5 + assert_eq( + (u1:0, s5:0b11011), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-5) = -5 + assert_eq( + (u1:0, s5:0b11011), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-5) = -5 + assert_eq( + (u1:0, s5:0b11011), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-5) = -5 + assert_eq( + (u1:0, s5:0b11011), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1101_1; + + // unsigned, Real value is 13.5 + // RNE(13.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(13.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(13.5) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(13.5) = 13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(13.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -13.5 + // RNE(-13.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-13.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-13.5) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-13.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-13.5) = -13 + assert_eq( + (u1:0, u5:0b1101_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2.5 + // RNE(-2.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2.5) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2.5) = -3 + assert_eq( + (u1:0, s5:0b1101_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b110_11; + + // unsigned, Real value is 6.75 + // RNE(6.75) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(6.75) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(6.75) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(6.75) = 6 + assert_eq( + (u1:0, u5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(6.75) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -6.75 + // RNE(-6.75) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-6.75) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-6.75) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-6.75) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-6.75) = -6 + assert_eq( + (u1:0, u5:0b110_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.25 + // RNE(-1.25) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.25) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.25) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.25) = -2 + assert_eq( + (u1:0, s5:0b110_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.25) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_011; + + // unsigned, Real value is 3.375 + // RNE(3.375) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.375) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.375) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.375) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.375) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.375 + // RNE(-3.375) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.375) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.375) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.375) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.375) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.625 + // RNE(-0.625) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.625) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.625) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.625) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.625) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1011; + + // unsigned, Real value is 1.6875 + // RNE(1.6875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.6875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.6875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.6875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.6875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.6875 + // RNE(-1.6875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.6875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.6875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.6875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.6875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.3125 + // RNE(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.3125) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.3125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11011; + + // unsigned, Real value is 0.84375 + // RNE(0.84375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.84375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.84375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.84375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.84375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.84375 + // RNE(-0.84375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.84375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.84375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.84375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.84375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.15625 + // RNE(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.15625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.15625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p27_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11011; + + // unsigned, Real value is 0.421875 + // RNE(0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.421875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.421875 + // RNE(-0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.421875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.421875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.078125 + // RNE(-0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.078125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.078125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11100; + + // unsigned, Real value is 28 + // RNE(28) = 28 + assert_eq( + (u1:0, u5:0b11100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(28) = 28 + assert_eq( + (u1:0, u5:0b11100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(28) = 28 + assert_eq( + (u1:0, u5:0b11100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(28) = 28 + assert_eq( + (u1:0, u5:0b11100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(28) = 28 + assert_eq( + (u1:0, u5:0b11100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -28 + // RNE(-28) = -28 + assert_eq( + (u1:0, u5:0b11100), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-28) = -28 + assert_eq( + (u1:0, u5:0b11100), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-28) = -28 + assert_eq( + (u1:0, u5:0b11100), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-28) = -28 + assert_eq( + (u1:0, u5:0b11100), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-28) = -28 + assert_eq( + (u1:0, u5:0b11100), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -4 + // RNE(-4) = -4 + assert_eq( + (u1:0, s5:0b11100), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-4) = -4 + assert_eq( + (u1:0, s5:0b11100), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-4) = -4 + assert_eq( + (u1:0, s5:0b11100), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-4) = -4 + assert_eq( + (u1:0, s5:0b11100), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-4) = -4 + assert_eq( + (u1:0, s5:0b11100), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1110_0; + + // unsigned, Real value is 14 + // RNE(14) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(14) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(14) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(14) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(14) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -14 + // RNE(-14) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-14) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-14) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-14) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-14) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b111_00; + + // unsigned, Real value is 7 + // RNE(7) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7 + // RNE(-7) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_100; + + // unsigned, Real value is 3.5 + // RNE(3.5) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.5) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.5) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.5) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.5) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.5 + // RNE(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.5) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.5) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.5) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1100; + + // unsigned, Real value is 1.75 + // RNE(1.75) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.75) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.75) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.75) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.75) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.75 + // RNE(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.75) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.75) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.75) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11100; + + // unsigned, Real value is 0.875 + // RNE(0.875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.875 + // RNE(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p28_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11100; + + // unsigned, Real value is 0.4375 + // RNE(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.4375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.4375 + // RNE(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.4375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.4375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11101; + + // unsigned, Real value is 29 + // RNE(29) = 29 + assert_eq( + (u1:0, u5:0b11101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(29) = 29 + assert_eq( + (u1:0, u5:0b11101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(29) = 29 + assert_eq( + (u1:0, u5:0b11101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(29) = 29 + assert_eq( + (u1:0, u5:0b11101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(29) = 29 + assert_eq( + (u1:0, u5:0b11101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -29 + // RNE(-29) = -29 + assert_eq( + (u1:0, u5:0b11101), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-29) = -29 + assert_eq( + (u1:0, u5:0b11101), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-29) = -29 + assert_eq( + (u1:0, u5:0b11101), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-29) = -29 + assert_eq( + (u1:0, u5:0b11101), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-29) = -29 + assert_eq( + (u1:0, u5:0b11101), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -3 + // RNE(-3) = -3 + assert_eq( + (u1:0, s5:0b11101), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-3) = -3 + assert_eq( + (u1:0, s5:0b11101), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-3) = -3 + assert_eq( + (u1:0, s5:0b11101), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-3) = -3 + assert_eq( + (u1:0, s5:0b11101), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-3) = -3 + assert_eq( + (u1:0, s5:0b11101), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1110_1; + + // unsigned, Real value is 14.5 + // RNE(14.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(14.5) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(14.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(14.5) = 14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(14.5) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -14.5 + // RNE(-14.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-14.5) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-14.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-14.5) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-14.5) = -14 + assert_eq( + (u1:0, u5:0b1110_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1.5 + // RNE(-1.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1.5) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1.5) = -2 + assert_eq( + (u1:0, s5:0b1110_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1.5) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b111_01; + + // unsigned, Real value is 7.25 + // RNE(7.25) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7.25) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7.25) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7.25) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7.25) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7.25 + // RNE(-7.25) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7.25) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7.25) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7.25) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7.25) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.75 + // RNE(-0.75) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.75) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.75) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.75) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.75) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_101; + + // unsigned, Real value is 3.625 + // RNE(3.625) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.625) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.625) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.625) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.625) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.625 + // RNE(-3.625) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.625) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.625) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.625) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.625) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.375 + // RNE(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.375) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.375) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1101; + + // unsigned, Real value is 1.8125 + // RNE(1.8125) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.8125) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.8125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.8125) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.8125) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.8125 + // RNE(-1.8125) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.8125) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.8125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.8125) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.8125) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.1875 + // RNE(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.1875) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.1875) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11101; + + // unsigned, Real value is 0.90625 + // RNE(0.90625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.90625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.90625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.90625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.90625) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.90625 + // RNE(-0.90625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.90625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.90625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.90625) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.90625) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.09375 + // RNE(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.09375) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.09375) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p29_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11101; + + // unsigned, Real value is 0.453125 + // RNE(0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.453125) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.453125 + // RNE(-0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.453125) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.453125) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.046875 + // RNE(-0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.046875) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.046875) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11110; + + // unsigned, Real value is 30 + // RNE(30) = 30 + assert_eq( + (u1:0, u5:0b11110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(30) = 30 + assert_eq( + (u1:0, u5:0b11110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(30) = 30 + assert_eq( + (u1:0, u5:0b11110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(30) = 30 + assert_eq( + (u1:0, u5:0b11110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(30) = 30 + assert_eq( + (u1:0, u5:0b11110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -30 + // RNE(-30) = -30 + assert_eq( + (u1:0, u5:0b11110), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-30) = -30 + assert_eq( + (u1:0, u5:0b11110), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-30) = -30 + assert_eq( + (u1:0, u5:0b11110), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-30) = -30 + assert_eq( + (u1:0, u5:0b11110), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-30) = -30 + assert_eq( + (u1:0, u5:0b11110), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -2 + // RNE(-2) = -2 + assert_eq( + (u1:0, s5:0b11110), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-2) = -2 + assert_eq( + (u1:0, s5:0b11110), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-2) = -2 + assert_eq( + (u1:0, s5:0b11110), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-2) = -2 + assert_eq( + (u1:0, s5:0b11110), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-2) = -2 + assert_eq( + (u1:0, s5:0b11110), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1111_0; + + // unsigned, Real value is 15 + // RNE(15) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(15) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(15) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(15) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(15) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -15 + // RNE(-15) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-15) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-15) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-15) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-15) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b111_10; + + // unsigned, Real value is 7.5 + // RNE(7.5) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7.5) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7.5) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7.5) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7.5) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7.5 + // RNE(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7.5) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7.5) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7.5) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_110; + + // unsigned, Real value is 3.75 + // RNE(3.75) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.75) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.75) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.75) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.75) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.75 + // RNE(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.75) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.75) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.75) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1110; + + // unsigned, Real value is 1.875 + // RNE(1.875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.875) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.875) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.875 + // RNE(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.875) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.875) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11110; + + // unsigned, Real value is 0.9375 + // RNE(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.9375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.9375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.9375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.9375 + // RNE(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.9375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.9375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.9375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.0625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p30_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11110; + + // unsigned, Real value is 0.46875 + // RNE(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.46875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.46875 + // RNE(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.46875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.46875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n0() { + let num_bits_rounded = u3:0; + let unrounded = u5:0b11111; + + // unsigned, Real value is 31 + // RNE(31) = 31 + assert_eq( + (u1:0, u5:0b11111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(31) = 31 + assert_eq( + (u1:0, u5:0b11111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(31) = 31 + assert_eq( + (u1:0, u5:0b11111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(31) = 31 + assert_eq( + (u1:0, u5:0b11111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(31) = 31 + assert_eq( + (u1:0, u5:0b11111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -31 + // RNE(-31) = -31 + assert_eq( + (u1:0, u5:0b11111), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-31) = -31 + assert_eq( + (u1:0, u5:0b11111), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-31) = -31 + assert_eq( + (u1:0, u5:0b11111), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-31) = -31 + assert_eq( + (u1:0, u5:0b11111), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-31) = -31 + assert_eq( + (u1:0, u5:0b11111), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -1 + // RNE(-1) = -1 + assert_eq( + (u1:0, s5:0b11111), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-1) = -1 + assert_eq( + (u1:0, s5:0b11111), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-1) = -1 + assert_eq( + (u1:0, s5:0b11111), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-1) = -1 + assert_eq( + (u1:0, s5:0b11111), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-1) = -1 + assert_eq( + (u1:0, s5:0b11111), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n1() { + let num_bits_rounded = u3:1; + let unrounded = u5:0b1111_1; + + // unsigned, Real value is 15.5 + // RNE(15.5) = 16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(15.5) = 16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(15.5) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(15.5) = 15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(15.5) = 16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -15.5 + // RNE(-15.5) = -16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-15.5) = -16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-15.5) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-15.5) = -16 -> overflow + assert_eq( + (u1:1, u5:0b0000_0), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-15.5) = -15 + assert_eq( + (u1:0, u5:0b1111_0), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.5 + // RNE(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.5) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.5) = -1 + assert_eq( + (u1:0, s5:0b1111_0), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.5) = 0 + assert_eq( + (u1:0, s5:0b0000_0), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n2() { + let num_bits_rounded = u3:2; + let unrounded = u5:0b111_11; + + // unsigned, Real value is 7.75 + // RNE(7.75) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(7.75) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(7.75) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(7.75) = 7 + assert_eq( + (u1:0, u5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(7.75) = 8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -7.75 + // RNE(-7.75) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-7.75) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-7.75) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-7.75) = -8 -> overflow + assert_eq( + (u1:1, u5:0b000_00), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-7.75) = -7 + assert_eq( + (u1:0, u5:0b111_00), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.25 + // RNE(-0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.25) = -1 + assert_eq( + (u1:0, s5:0b111_00), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.25) = 0 + assert_eq( + (u1:0, s5:0b000_00), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n3() { + let num_bits_rounded = u3:3; + let unrounded = u5:0b11_111; + + // unsigned, Real value is 3.875 + // RNE(3.875) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(3.875) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(3.875) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(3.875) = 3 + assert_eq( + (u1:0, u5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(3.875) = 4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -3.875 + // RNE(-3.875) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-3.875) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-3.875) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-3.875) = -4 -> overflow + assert_eq( + (u1:1, u5:0b00_000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-3.875) = -3 + assert_eq( + (u1:0, u5:0b11_000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.125 + // RNE(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.125) = -1 + assert_eq( + (u1:0, s5:0b11_000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.125) = 0 + assert_eq( + (u1:0, s5:0b00_000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n4() { + let num_bits_rounded = u3:4; + let unrounded = u5:0b1_1111; + + // unsigned, Real value is 1.9375 + // RNE(1.9375) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(1.9375) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(1.9375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(1.9375) = 1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(1.9375) = 2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -1.9375 + // RNE(-1.9375) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-1.9375) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-1.9375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-1.9375) = -2 -> overflow + assert_eq( + (u1:1, u5:0b0_0000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-1.9375) = -1 + assert_eq( + (u1:0, u5:0b1_0000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.0625 + // RNE(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.0625) = -1 + assert_eq( + (u1:0, s5:0b1_0000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.0625) = 0 + assert_eq( + (u1:0, s5:0b0_0000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n5() { + let num_bits_rounded = u3:5; + let unrounded = u5:0b11111; + + // unsigned, Real value is 0.96875 + // RNE(0.96875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.96875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.96875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.96875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.96875) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.96875 + // RNE(-0.96875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.96875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.96875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.96875) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.96875) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.03125 + // RNE(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.03125) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.03125) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} + +#[test] +fn test_w5_p31_n6() { + let num_bits_rounded = u3:6; + let unrounded = u5:0b11111; + + // unsigned, Real value is 0.484375 + // RNE(0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RNA(0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTZ(0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTN(0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded)); + // RTP(0.484375) = 1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded)); + + // sign & magnitude, Real value is -0.484375 + // RNE(-0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNE, num_bits_rounded, round::Sign::Negative, unrounded)); + // RNA(-0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RNA, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTZ(-0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTZ, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTN(-0.484375) = -1 -> overflow + assert_eq( + (u1:1, u5:0b00000), + round::round(round::RoundingMode::RTN, num_bits_rounded, round::Sign::Negative, unrounded)); + // RTP(-0.484375) = 0 + assert_eq( + (u1:0, u5:0b00000), + round::round(round::RoundingMode::RTP, num_bits_rounded, round::Sign::Negative, unrounded)); + + // signed, Real value is -0.015625 + // RNE(-0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNE, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RNA(-0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RNA, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTZ(-0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTZ, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTN(-0.015625) = -1 -> overflow + assert_eq( + (u1:1, s5:0b00000), + round::round( + round::RoundingMode::RTN, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); + // RTP(-0.015625) = 0 + assert_eq( + (u1:0, s5:0b00000), + round::round( + round::RoundingMode::RTP, num_bits_rounded, round::Sign::NonNegative, unrounded as s5)); +} From 2e322eab17c297c2aadb7586508784b64f92332f Mon Sep 17 00:00:00 2001 From: Daniel Killebrew Date: Fri, 19 Sep 2025 18:04:04 -0400 Subject: [PATCH 2/4] make pylint happy --- xls/dslx/stdlib/tests/gen_round_tests.py | 512 +++++++++++++---------- 1 file changed, 283 insertions(+), 229 deletions(-) diff --git a/xls/dslx/stdlib/tests/gen_round_tests.py b/xls/dslx/stdlib/tests/gen_round_tests.py index 76edcceaa6..d26546fc07 100644 --- a/xls/dslx/stdlib/tests/gen_round_tests.py +++ b/xls/dslx/stdlib/tests/gen_round_tests.py @@ -11,8 +11,8 @@ * sign-and-magnitude with Sign::Negative, * signed two's-complement (sN). -Each test function bundles the five rounding-mode checks for one -(width, value, num_bits_rounded) combination - totalling 372 functions. +Each test function bundles the five rounding-mode checks for a single +(width, value, num_bits_rounded) combination, totalling 372 functions. The generated DSL lives inside `round_tests.x`; everything between the "AUTO-GENERATED" markers is replaced when this script runs. @@ -31,30 +31,34 @@ class RoundingMode(Enum): - RNE = auto() # convergent / bankers-rounding (nearest, ties-to-even) - RNA = auto() # away from zero - RTZ = auto() # towards zero - RTN = auto() # towards -∞ - RTP = auto() # towards +∞ + RNE = auto() # convergent / bankers-rounding (nearest, ties-to-even) + RNA = auto() # away from zero + RTZ = auto() # towards zero + RTN = auto() # towards -∞ + RTP = auto() # towards +∞ - def __str__(self): - # For codegen purposes (DSLX output) - return self.name + def __str__(self) -> str: + """Return the enum name for DSLX code generation.""" + return self.name ROUNDING_MODES = [ - RoundingMode.RNE, - RoundingMode.RNA, - RoundingMode.RTZ, - RoundingMode.RTN, - RoundingMode.RTP, + RoundingMode.RNE, + RoundingMode.RNA, + RoundingMode.RTZ, + RoundingMode.RTN, + RoundingMode.RTP, ] +HEADER_BAR = "-" * 75 GENERATED_HEADER = [ - "// ---------------------------------------------------------------------------", - "// These tests are AUTO-GENERATED by gen_round_tests.py - do not edit manually.", - "// Everything below this comment will be overwritten.", - "// ---------------------------------------------------------------------------", + f"// {HEADER_BAR}", + ( + "// These tests are AUTO-GENERATED by gen_round_tests.py - do not edit " + "manually." + ), + "// Everything below this comment will be overwritten.", + f"// {HEADER_BAR}", ] HEADER_TEXT = "\n".join(GENERATED_HEADER) @@ -63,270 +67,320 @@ def __str__(self): def all_widths() -> range: - return range(MIN_WIDTH, MAX_WIDTH + 1) + return range(MIN_WIDTH, MAX_WIDTH + 1) def value_space(width: int) -> range: - return range(1 << width) + return range(1 << width) def num_bits_field_width(width: int) -> int: - # Mirrors DSLX's std::clog2(N + 1) used in round()'s type signature. - # Ensure at least one bit so we can represent zero. - return max(1, math.ceil(math.log2(width + 1))) + # Mirrors DSLX's std::clog2(N + 1) used in round()'s type signature. + # Ensure at least one bit so we can represent zero. + return max(1, math.ceil(math.log2(width + 1))) def nbits_space(width: int) -> list[int]: - # Include 0, the in-range values, and one value beyond the width. - in_range = list(range(0, width + 1)) - beyond = width + 1 - max_representable = (1 << num_bits_field_width(width)) - 1 - if beyond <= max_representable: - in_range.append(beyond) - return in_range + # Include 0, the in-range values, and one value beyond the width. + in_range = list(range(0, width + 1)) + beyond = width + 1 + max_representable = (1 << num_bits_field_width(width)) - 1 + if beyond <= max_representable: + in_range.append(beyond) + return in_range # --------------------------------------------------------------------------- -def fraction_from_bits(bits: int, nfrac: int, *, signed: bool, width: int) -> Fraction: - """Return the exact real value represented by *bits* interpreted as a - fixed-point number with *nfrac* fractional bits. - If *signed* is False, bits are treated as unsigned. - Otherwise two's-complement is assumed. - """ - if signed and bits & (1 << (width - 1)): - bits -= 1 << width # sign-extend negative value - return Fraction(bits, 1 << nfrac) +def fraction_from_bits( + bits: int, + nfrac: int, + *, + signed: bool, + width: int, +) -> Fraction: + """Return the real value encoded by *bits*. + + Interpret the bits as a fixed-point number with *nfrac* fractional bits. + Unsigned representation is used unless *signed* is True, in which case + two's-complement is assumed. + """ + if signed and bits & (1 << (width - 1)): + bits -= 1 << width # sign-extend negative value + return Fraction(bits, 1 << nfrac) def round_fraction(value: Fraction, mode: RoundingMode) -> int: - """Round *value* to the nearest integer according to *mode*. - Returns the rounded integer (unbounded - overflow handled separately). - """ - assert isinstance(mode, RoundingMode) - - # Directed rounding modes. - if mode == RoundingMode.RTZ: # truncate towards zero - return math.trunc(value) - if mode == RoundingMode.RTN: # towards -∞ - return math.floor(value) - if mode == RoundingMode.RTP: # towards +∞ - return math.ceil(value) - - # The remaining two are 'nearest' variants. - floor_val = math.floor(value) - ceil_val = math.ceil(value) - dist_down = value - floor_val # always ≥ 0 - dist_up = ceil_val - value # always ≥ 0 - - if dist_down < dist_up: - return floor_val - if dist_up < dist_down: - return ceil_val - - # At a tie - exactly midway between. - if mode == RoundingMode.RNE: # tie to even - return floor_val if floor_val % 2 == 0 else ceil_val - else: # RNA - tie away from zero - return ceil_val if value >= 0 else floor_val + """Round *value* to the nearest integer according to *mode*. + + Returns the rounded integer (unbounded; overflow is handled separately). + """ + assert isinstance(mode, RoundingMode) + + # Directed rounding modes. + if mode == RoundingMode.RTZ: # truncate towards zero + return math.trunc(value) + if mode == RoundingMode.RTN: # towards -∞ + return math.floor(value) + if mode == RoundingMode.RTP: # towards +∞ + return math.ceil(value) + + # The remaining two are 'nearest' variants. + floor_val = math.floor(value) + ceil_val = math.ceil(value) + dist_down = value - floor_val # always ≥ 0 + dist_up = ceil_val - value # always ≥ 0 + + if dist_down < dist_up: + return floor_val + if dist_up < dist_down: + return ceil_val + + # At a tie - exactly midway between. + if mode == RoundingMode.RNE: # tie to even + return floor_val if floor_val % 2 == 0 else ceil_val + # RNA - tie away from zero + return ceil_val if value >= 0 else floor_val def needs_overflow_unsigned(val: int, int_bits: int) -> bool: - """Return True if *val* cannot be represented in *int_bits* unsigned bits.""" - return not (0 <= val < (1 << int_bits)) + """Return True if *val* cannot be represented in *int_bits* unsigned bits.""" + return val < 0 or val >= (1 << int_bits) def needs_overflow_signed(val: int, int_bits: int) -> bool: - """Return True if *val* cannot be represented in *int_bits* two's-complement. + """Return True if *val* cannot be represented in *int_bits* two's-complement. - The integer part of our fixed-point numbers spans `int_bits` bits, which - includes the sign bit for two's-complement values. A value is - representable iff it lies within the conventional two's-complement range + The integer part of our fixed-point numbers spans `int_bits` bits, which + includes the sign bit for two's-complement values. A value is representable + iff it lies within the conventional two's-complement range - [ -2^(int_bits-1) , 2^(int_bits-1) - 1 ]. + [ -2^(int_bits-1) , 2^(int_bits-1) - 1 ]. - Special-case `int_bits == 0` (all bits are fractional): in that scenario - *no* non-zero integer can be represented once the value has been rounded - (because the subsequent left-shift by `nfrac` would shift the sign bit out - of the word). Hence every value except 0 overflows. - """ - if int_bits == 0: - return val != 0 + Special-case `int_bits == 0` (all bits are fractional): in that scenario + *no* non-zero integer can be represented once the value has been rounded + (because the subsequent left-shift by `nfrac` would shift the sign bit out of + the word). Hence every value except 0 overflows. + """ + if int_bits == 0: + return val != 0 - min_val = -(1 << (int_bits - 1)) - max_val = (1 << (int_bits - 1)) - 1 - return not (min_val <= val <= max_val) + min_val = -(1 << (int_bits - 1)) + max_val = (1 << (int_bits - 1)) - 1 + return val < min_val or val > max_val def bits_literal(bits: int, nfrac: int, width: int) -> str: - """Return a DSLX binary literal for the given *width*-bit value.""" - mask = (1 << width) - 1 - bin_str = format(bits & mask, f"0{width}b") - int_bits = max(width - nfrac, 0) - frac_bits = width - int_bits - if int_bits == 0 or frac_bits == 0: - return f"0b{bin_str}" - return f"0b{bin_str[:int_bits]}_{bin_str[int_bits:]}" + """Return a DSLX binary literal for the given *width*-bit value.""" + mask = (1 << width) - 1 + bin_str = format(bits & mask, f"0{width}b") + int_bits = max(width - nfrac, 0) + frac_bits = width - int_bits + if int_bits == 0 or frac_bits == 0: + return f"0b{bin_str}" + return f"0b{bin_str[:int_bits]}_{bin_str[int_bits:]}" def fmt_real(frac: Fraction) -> str: - """Nicely format *frac* for human-readable comments.""" - numerator, denominator = frac.numerator, frac.denominator - if denominator == 1: - return str(numerator) - # Use finite decimal if possible (denominator is a power of two ≤ 32). - return str(float(frac)) + """Nicely format *frac* for human-readable comments.""" + numerator, denominator = frac.numerator, frac.denominator + if denominator == 1: + return str(numerator) + # Use finite decimal if possible (denominator is a power of two ≤ 32). + return str(float(frac)) # --------------------------------------------------------------------------- def num_bits_literal(width: int, nfrac: int) -> str: - """Return the literal string for num_bits_rounded with enough width.""" - default_width = max(1, width.bit_length()) - required_width = max(1, nfrac.bit_length()) - literal_width = max(default_width, required_width) - return f"u{literal_width}:{nfrac}" + """Return the literal string for num_bits_rounded with enough width.""" + default_width = max(1, width.bit_length()) + required_width = max(1, nfrac.bit_length()) + literal_width = max(default_width, required_width) + return f"u{literal_width}:{nfrac}" def generate_test_function(width: int, bits: int, nfrac: int) -> str: - """Return the DSLX source for one test function covering all rounding modes - under the three interpretations. - """ - func_lines: list[str] = [] - int_bits = max(width - nfrac, 0) - func_name = f"test_w{width}_p{bits:02d}_n{nfrac}" - - unrounded_lit = bits_literal(bits, nfrac, width) - nbr_literal = num_bits_literal(width, nfrac) - mask = (1 << width) - 1 - func_lines.append(f"#[test]") - func_lines.append(f"fn {func_name}() {{") - func_lines.append(f" let num_bits_rounded = {nbr_literal};") - func_lines.append(f" let unrounded = u{width}:{unrounded_lit};\n") - - # --- unsigned interpretation ----------------------------------------- - real_unsigned = Fraction(bits, 1 << nfrac) - func_lines.append(f" // unsigned, Real value is {fmt_real(real_unsigned)}") - for mode in ROUNDING_MODES: - mode_name = mode.name - rounded = round_fraction(real_unsigned, mode) - overflow = needs_overflow_unsigned(rounded, int_bits) - carry = 1 if overflow else 0 - val_bits = 0 if overflow else ((rounded << nfrac) & mask) - val_lit = bits_literal(val_bits, nfrac, width) - ov_comment = " -> overflow" if overflow else "" - func_lines.append(f" // {mode_name}({fmt_real(real_unsigned)}) = {rounded}{ov_comment}") - func_lines.append(f" assert_eq((u1:{carry}, u{width}:{val_lit}), " - f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " - f"round::Sign::NonNegative, unrounded));") - func_lines.append("") - - # --- sign & magnitude, negative -------------------------------------- - real_sm = -real_unsigned - func_lines.append(f" // sign & magnitude, Real value is {fmt_real(real_sm)}") - for mode in ROUNDING_MODES: - mode_name = mode.name - rounded = abs(round_fraction(real_sm, mode)) # magnitude only - overflow = needs_overflow_unsigned(rounded, int_bits) - carry = 1 if overflow else 0 - val_bits = 0 if overflow else ((rounded << nfrac) & mask) - val_lit = bits_literal(val_bits, nfrac, width) - ov_comment = " -> overflow" if overflow else "" - rounded_display = -rounded if not overflow else f"-{rounded}" - func_lines.append(f" // {mode_name}({fmt_real(real_sm)}) = {rounded_display}{ov_comment}") - func_lines.append(f" assert_eq((u1:{carry}, u{width}:{val_lit}), " - f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " - f"round::Sign::Negative, unrounded));") - func_lines.append("") - - # --- signed two's-complement ---------------------------------------- - real_signed = fraction_from_bits(bits, nfrac, signed=True, width=width) - func_lines.append(f" // signed, Real value is {fmt_real(real_signed)}") - for mode in ROUNDING_MODES: - mode_name = mode.name - rounded = round_fraction(real_signed, mode) - overflow = needs_overflow_signed(rounded, int_bits) - carry = 1 if overflow else 0 - val_bits = 0 if overflow else (((rounded & mask) << nfrac) & mask) - val_lit = bits_literal(val_bits, nfrac, width) - ov_comment = " -> overflow" if overflow else "" - func_lines.append(f" // {mode_name}({fmt_real(real_signed)}) = {rounded}{ov_comment}") - func_lines.append(f" assert_eq((u1:{carry}, s{width}:{val_lit}), " - f"round::round(round::RoundingMode::{mode_name}, num_bits_rounded, " - f"round::Sign::NonNegative, unrounded as s{width}));") - - func_lines.append("}") - return "\n".join(func_lines) + """Return the DSLX source for one test function covering all rounding modes + under the three interpretations. + """ + func_lines: list[str] = [] + int_bits = max(width - nfrac, 0) + func_name = f"test_w{width}_p{bits:02d}_n{nfrac}" + + unrounded_lit = bits_literal(bits, nfrac, width) + nbr_literal = num_bits_literal(width, nfrac) + mask = (1 << width) - 1 + func_lines.append("#[test]") + func_lines.append(f"fn {func_name}() {{") + func_lines.append(f" let num_bits_rounded = {nbr_literal};") + func_lines.append(f" let unrounded = u{width}:{unrounded_lit};\n") + + # --- unsigned interpretation ----------------------------------------- + real_unsigned = Fraction(bits, 1 << nfrac) + func_lines.append( + f" // unsigned, Real value is {fmt_real(real_unsigned)}" + ) + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = round_fraction(real_unsigned, mode) + overflow = needs_overflow_unsigned(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else ((rounded << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + func_lines.append( + f" // {mode_name}({fmt_real(real_unsigned)}) = " + f"{rounded}{ov_comment}" + ) + func_lines.append( + f" assert_eq((u1:{carry}, u{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, " + "num_bits_rounded, " + "round::Sign::NonNegative, " + "unrounded));" + ) + func_lines.append("") + + # --- sign & magnitude, negative -------------------------------------- + real_sm = -real_unsigned + func_lines.append( + f" // sign & magnitude, Real value is {fmt_real(real_sm)}" + ) + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = abs(round_fraction(real_sm, mode)) # magnitude only + overflow = needs_overflow_unsigned(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else ((rounded << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + rounded_display = -rounded if not overflow else f"-{rounded}" + func_lines.append( + f" // {mode_name}({fmt_real(real_sm)}) = " + f"{rounded_display}{ov_comment}" + ) + func_lines.append( + f" assert_eq((u1:{carry}, u{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, " + "num_bits_rounded, " + "round::Sign::Negative, " + "unrounded));" + ) + func_lines.append("") + + # --- signed two's-complement ---------------------------------------- + real_signed = fraction_from_bits(bits, nfrac, signed=True, width=width) + func_lines.append( + f" // signed, Real value is {fmt_real(real_signed)}" + ) + for mode in ROUNDING_MODES: + mode_name = mode.name + rounded = round_fraction(real_signed, mode) + overflow = needs_overflow_signed(rounded, int_bits) + carry = 1 if overflow else 0 + val_bits = 0 if overflow else (((rounded & mask) << nfrac) & mask) + val_lit = bits_literal(val_bits, nfrac, width) + ov_comment = " -> overflow" if overflow else "" + func_lines.append( + f" // {mode_name}({fmt_real(real_signed)}) = " + f"{rounded}{ov_comment}" + ) + func_lines.append( + f" assert_eq((u1:{carry}, s{width}:{val_lit}), " + f"round::round(round::RoundingMode::{mode_name}, " + "num_bits_rounded, " + "round::Sign::NonNegative, " + f"unrounded as s{width}));" + ) + + func_lines.append("}") + return "\n".join(func_lines) # --------------------------------------------------------------------------- def build_generated_section() -> tuple[str, int]: - lines: list[str] = [HEADER_TEXT, ""] - total_funcs = 0 - for width in all_widths(): - lines.append(f"// --- Width {width} bits --------------------------------------------------------") - for bits in value_space(width): - for nfrac in nbits_space(width): - lines.append(generate_test_function(width, bits, nfrac)) - lines.append("") - total_funcs += 1 - section = "\n".join(lines).rstrip() + "\n" - return section, total_funcs + lines: list[str] = [HEADER_TEXT, ""] + total_funcs = 0 + for width in all_widths(): + lines.append( + f"// --- Width {width} bits " + "--------------------------------------------------------" + ) + for bits in value_space(width): + for nfrac in nbits_space(width): + lines.append(generate_test_function(width, bits, nfrac)) + lines.append("") + total_funcs += 1 + section = "\n".join(lines).rstrip() + "\n" + return section, total_funcs def parse_args(argv: list[str] | None = None) -> argparse.Namespace: - parser = argparse.ArgumentParser(description="Generate DSLX round() tests.") - parser.add_argument( - "--round-tests", - type=Path, - default=Path(__file__).with_name("round_tests.x"), - help="Path to the round_tests.x file to update (default: sibling round_tests.x)", - ) - parser.add_argument( - "--dslx-fmt", - type=Path, - help="Optional path to dslx_fmt; if provided, formatted output replaces round_tests.x", - ) - return parser.parse_args(argv) + parser = argparse.ArgumentParser( + description="Generate DSLX round() tests." + ) + parser.add_argument( + "--round-tests", + type=Path, + default=Path(__file__).with_name("round_tests.x"), + help=( + "Path to the round_tests.x file to update " + "(default: sibling round_tests.x)" + ), + ) + parser.add_argument( + "--dslx-fmt", + type=Path, + help=( + "Optional path to dslx_fmt; if provided, formatted output replaces " + "round_tests.x" + ), + ) + return parser.parse_args(argv) def main(argv: list[str] | None = None) -> None: - args = parse_args(argv) - out_path = args.round_tests - existing = out_path.read_text() - section, total_funcs = build_generated_section() - - marker_index = existing.find(HEADER_TEXT) - if marker_index == -1: - raise RuntimeError("Generated section header not found in round_tests.x") - - updated = existing[:marker_index] + section - out_path.write_text(updated) - - if args.dslx_fmt is not None: - result = subprocess.run( - [str(args.dslx_fmt), str(out_path)], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - text=True, - check=False, - ) - if result.returncode != 0: - raise RuntimeError( - "dslx_fmt failed with exit code " - f"{result.returncode}: {result.stderr.strip()}" - ) - if result.stdout: - out_path.write_text(result.stdout) - else: - raise RuntimeError("dslx_fmt produced no output; refusing to overwrite round_tests.x") - - print(f"Updated {out_path} with {total_funcs} test functions.") + args = parse_args(argv) + out_path = args.round_tests + existing = out_path.read_text() + section, total_funcs = build_generated_section() + + marker_index = existing.find(HEADER_TEXT) + if marker_index == -1: + raise RuntimeError( + "Generated section header not found in round_tests.x" + ) + + updated = existing[:marker_index] + section + out_path.write_text(updated) + + if args.dslx_fmt is not None: + result = subprocess.run( + [str(args.dslx_fmt), str(out_path)], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=False, + ) + if result.returncode != 0: + raise RuntimeError( + "dslx_fmt failed with exit code " + f"{result.returncode}: {result.stderr.strip()}" + ) + if result.stdout: + out_path.write_text(result.stdout) + else: + raise RuntimeError( + "dslx_fmt produced no output; refusing to overwrite round_tests.x" + ) + + print(f"Updated {out_path} with {total_funcs} test functions.") if __name__ == "__main__": - main() + main() From e4421564e160c615a049b2c1281843bf500aaaa1 Mon Sep 17 00:00:00 2001 From: Daniel Killebrew Date: Mon, 29 Sep 2025 19:09:37 -0400 Subject: [PATCH 3/4] fix doc snippet --- docs_src/dslx_std.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs_src/dslx_std.md b/docs_src/dslx_std.md index 83f850e7b1..7ce9cfff85 100644 --- a/docs_src/dslx_std.md +++ b/docs_src/dslx_std.md @@ -1654,7 +1654,7 @@ Rounds an unsigned value. - Returns `(overflow, rounded)` - Rounded unsigned value; `overflow` signals that rounding would exceed the original range. -```dslx +```dslx-snippet let (overflow, rounded) = round_u(RoundingMode::RNE, u32:3, u8:0b0001_1100); assert_eq(u1:0, overflow); From 84e3a470bef7698fd71c8334fc25adc28e338787 Mon Sep 17 00:00:00 2001 From: Daniel Killebrew Date: Wed, 1 Oct 2025 13:07:37 -0400 Subject: [PATCH 4/4] Move type arguments into function body as constants, where possible --- xls/dslx/stdlib/round.x | 71 ++++++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 33 deletions(-) diff --git a/xls/dslx/stdlib/round.x b/xls/dslx/stdlib/round.x index 09bee9e1b6..966581e703 100644 --- a/xls/dslx/stdlib/round.x +++ b/xls/dslx/stdlib/round.x @@ -105,15 +105,20 @@ pub enum Sign : u1 { // round down is chosen. E.g. // round(RNE, 4 bits, unsigned, u5:0b1_1000) -> rounds up (retained msb is 1) // round(RNE, 4 bits, unsigned, u4:0b1000) -> rounds down (no retained bits) -pub fn round - +pub fn round (rounding_mode: RoundingMode, num_bits_rounded: uN[W_NBR], sign: Sign, unrounded: xN[S][N]) -> (u1, xN[S][N]) { + type NumBitsRoundedT = uN[W_NBR]; + + // Works even when N is zero. + type SafeWord = uN[std::max(N, u32:1)]; + + // Wide enough to represent overflow. + type ExtendedWord = uN[N + u32:1]; + // Compute sign bit while avoiding issues when N is zero. let unrounded_u = unrounded as uN[N]; - let sign_shift = std::usub_or_zero(N, u32:1) as uN[W_NBR]; - type SafeWord = uN[W_SAFE]; + let sign_shift = std::usub_or_zero(N, u32:1) as NumBitsRoundedT; let unrounded_sign_bit = std::lsb((unrounded_u as SafeWord) >> sign_shift); // determine sign when unrounded is two's complement @@ -125,7 +130,7 @@ pub fn round if N == u32:0 { (u1:0, xN[S][N]:0) - } else if num_bits_rounded == uN[W_NBR]:0 { + } else if num_bits_rounded == NumBitsRoundedT:0 { (u1:0, unrounded) } else if num_bits_rounded as u32 > N { let is_zero = unrounded_u == uN[N]:0; @@ -159,8 +164,8 @@ pub fn round let half_value = (SafeWord:1) << (num_bits_rounded as SafeWord - SafeWord:1); // as we defined half above, we use a similar definition of one - let one = (uN[NP1]:1) << num_bits_rounded; - let zero = uN[NP1]:0; + let one = (ExtendedWord:1) << num_bits_rounded; + let zero = ExtendedWord:0; // Beware rounded_gt_half when unrounded is two's complement and negative; it's // misleading. @@ -272,7 +277,7 @@ pub fn round }, }; - let sum = retained_bits as uN[NP1] + adjustment; + let sum = retained_bits as ExtendedWord + adjustment; let (carry, rounded_u) = std::split_msbs(sum); let rounded_sign_bit = std::lsb((rounded_u as SafeWord) >> sign_shift); @@ -338,11 +343,11 @@ pub fn round_u // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_u - +pub fn round_trunc_u (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) { const_assert!(NumBitsRounded <= N); + const W_NBR: u32 = std::clog2(N + u32:1); + let (overflow, rounded) = round_u(rounding_mode, NumBitsRounded as uN[W_NBR], unrounded); let (rounded_msbs, _) = std::split_msbs(rounded); (overflow, rounded_msbs) @@ -353,17 +358,17 @@ pub fn round_trunc_u // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_to_u - +pub fn round_trunc_to_u (rounding_mode: RoundingMode, unrounded: uN[N]) -> (u1, uN[R]) { - if NumBitsRounded == u32:0 { + const NUM_BITS_ROUNDED: u32 = std::usub_or_zero(N, R); + + if NUM_BITS_ROUNDED == u32:0 { // This no-op cast is required by the type checker. When this branch is not taken, this // cast op unifies the types of the branches. let unrounded = unrounded as uN[R]; (u1:0, unrounded) } else { - round_trunc_u(rounding_mode, unrounded) + round_trunc_u(rounding_mode, unrounded) } } @@ -382,11 +387,11 @@ pub fn round_s // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_s - +pub fn round_trunc_s (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) { const_assert!(num_bits_rounded <= N); + const W_NBR: u32 = std::clog2(N + u32:1); + if R == u32:0 { let (overflow, _) = round_s(rounding_mode, num_bits_rounded as uN[W_NBR], unrounded); (overflow, zero!()) @@ -402,15 +407,15 @@ pub fn round_trunc_s // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_to_s - +pub fn round_trunc_to_s (rounding_mode: RoundingMode, unrounded: sN[N]) -> (u1, sN[R]) { - if NumBitsRounded == u32:0 { + const NUM_BITS_ROUNDED: u32 = std::usub_or_zero(N, R); + + if NUM_BITS_ROUNDED == u32:0 { let unrounded = unrounded as sN[R]; (u1:0, unrounded) } else { - round_trunc_s(rounding_mode, unrounded) + round_trunc_s(rounding_mode, unrounded) } } @@ -430,11 +435,11 @@ pub fn round_sm // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_sm - +pub fn round_trunc_sm (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) { const_assert!(num_bits_rounded <= N); + const W_NBR: u32 = std::clog2(N + u32:1); + let (overflow, rounded) = round_sm(rounding_mode, num_bits_rounded as uN[W_NBR], sign, magnitude); let (rounded_msbs, _) = std::split_msbs(rounded); @@ -446,14 +451,14 @@ pub fn round_trunc_sm // - returns only the most significant bits (i.e., the rounded result), discarding the rounded-off // bits. // Returns (overflow, rounded result). -pub fn round_trunc_to_sm - +pub fn round_trunc_to_sm (rounding_mode: RoundingMode, sign: Sign, magnitude: uN[N]) -> (u1, uN[R]) { - if NumBitsRounded == u32:0 { + const NUM_BITS_ROUNDED: u32 = std::usub_or_zero(N, R); + + if NUM_BITS_ROUNDED == u32:0 { let magnitude = magnitude as uN[R]; (u1:0, magnitude) } else { - round_trunc_sm(rounding_mode, sign, magnitude) + round_trunc_sm(rounding_mode, sign, magnitude) } }