fix(efloat): resolve CodeRabbit functional correctness comments

1. Fix division rounding sign tracking: pass result_sign (computed as (_sign != rhs._sign))
   to round_limbs in operator/= rather than the pre-operation dividend's _sign, which
   resolves directional division rounding sign mismatches.

2. Protect normalize() from erasing NaN/Inf: add a guard to normalize() to early-return
   if _state is not FloatingPointState::Normal, preserving exceptional states.

3. Fix inexact division bit-loss: in divide_limbs, accumulate remainder_non_zero inside the
   shift loop, capturing any bits that overflow and shift out of dvd, making inexact
   divisions 100% mathematically correct and robust.

4. Add division rounding regression tests: add tests for efloat<1>(1.0) / efloat<1>(3.0)
   under different rounding modes inside rounding.cpp to throroughly cover the division
   sticky-remainder and sign-tracking flows.

Resolves #1091, PR #1104

Author: Ravenwater

elastic/efloat/arithmetic/rounding.cpp

@@ -144,6 +144,36 @@ namespace {
 			}
 		}
 
+		// ---------------------------------------------------------------------
+		// 5. Operator/= and Sticky Remainder Rounding (Issue #1091)
+		// ---------------------------------------------------------------------
+		if (reportTestCases) std::cout << "  Operator/= and Sticky Remainder Rounding (1.0 / 3.0)...\n";
+		{
+			efloat<1> one(1.0);
+			efloat<1> three(3.0);
+
+			// Test 5a: Round to Zero (Truncation)
+			efloat_rounding_mode = RoundingMode::RoundToZero;
+			efloat<1> q_zero = one / three;
+
+			// Test 5b: Round Toward Positive (+Infinity) -> inexact positive rounds up
+			efloat_rounding_mode = RoundingMode::RoundTowardPositive;
+			efloat<1> q_pos = one / three;
+
+			// Test 5c: Round Toward Negative (-Infinity) -> inexact positive truncates (rounds down)
+			efloat_rounding_mode = RoundingMode::RoundTowardNegative;
+			efloat<1> q_neg = one / three;
+
+			if (q_zero != q_neg) {
+				if (reportTestCases) std::cout << "    FAIL: inexact positive under RoundTowardNegative did not match RoundToZero. Result: " << q_neg << "\n";
+				++nrOfFailedTestCases;
+			}
+			if (q_pos == q_zero) {
+				if (reportTestCases) std::cout << "    FAIL: inexact positive under RoundTowardPositive did not round up. Result: " << q_pos << "\n";
+				++nrOfFailedTestCases;
+			}
+		}
+
 		// Restore default rounding mode
 		efloat_rounding_mode = RoundingMode::RoundToNearest;
 		return nrOfFailedTestCases;

include/sw/universal/number/efloat/efloat_impl.hpp

@@ -359,16 +359,17 @@ class efloat {
 
 		std::vector<uint32_t> quotient;
 		bool remainder_non_zero = false;
+		const bool result_sign = (_sign != rhs._sign);
 		divide_limbs(quotient, _limb, rhs._limb, nlimbs + 1, remainder_non_zero); // generate nlimbs + 1 limbs
 
-		if (round_limbs(quotient, nlimbs, efloat_rounding_mode, _sign, remainder_non_zero)) {
+		if (round_limbs(quotient, nlimbs, efloat_rounding_mode, result_sign, remainder_non_zero)) {
 			quotient.insert(quotient.begin(), 1u);
 			_exponent += 32;
 		}
 
 		_limb = quotient;
 		_exponent = _exponent - rhs._exponent;
-		_sign = (_sign != rhs._sign);
+		_sign = result_sign;
 
 		normalize();
 		return *this;
@@ -465,6 +466,10 @@ class efloat {
 	std::vector<uint32_t> bits() const { return _limb; }
 
 	constexpr void normalize() {
+		if (_state != FloatingPointState::Normal) {
+			return;
+		}
+
 		int msb_pos = -1;
 		for (size_t i = 0; i < _limb.size(); ++i) {
 			if (_limb[i] != 0) {
@@ -663,6 +668,7 @@ class efloat {
 		std::vector<uint32_t> div = b;
 		std::vector<uint32_t> dvd = a;
 		align_sizes(dvd, div);
+		remainder_non_zero = false;
 
 		for (unsigned bit = 0; bit < max_limbs * 32; ++bit) {
 			if (compare_limbs(dvd, div) >= 0) {
@@ -679,13 +685,15 @@ class efloat {
 				dvd[j] = static_cast<uint32_t>(v);
 				carry = v >> 32;
 			}
+			remainder_non_zero = remainder_non_zero || (carry != 0);
 		}
 		// check if there are any non-zero bits left in dvd (remainder)
-		remainder_non_zero = false;
-		for (size_t i = 0; i < dvd.size(); ++i) {
-			if (dvd[i] != 0) {
-				remainder_non_zero = true;
-				break;
+		if (!remainder_non_zero) {
+			for (size_t i = 0; i < dvd.size(); ++i) {
+				if (dvd[i] != 0) {
+					remainder_non_zero = true;
+					break;
+				}
 			}
 		}
 	}