Optimized Rounding

Author: satcfdi

satcfdi/create/compute.py

@@ -87,11 +87,6 @@ def __init__(self, decimals):
         self.exp = Decimal('0.' + '0' * decimals)
         self.offset_margin = Decimal('0.' + '0' * decimals + '5')
 
-    def round(self, value):
-        rounded = self.peak(value)
-        self.offset += value - rounded
-        return rounded
-
     def peak(self, value):
         if self.offset >= self.offset_margin:
             return value.quantize(self.exp, rounding=ROUND_CEILING)
@@ -100,7 +95,9 @@ def peak(self, value):
         return round(value, self.decimals)
 
     def __call__(self, value):
-        return self.round(value)
+        rounded = self.peak(value)
+        self.offset += value - rounded
+        return rounded
 
 
 def group_impuestos(elements, pfx="", ofx=""):

tests/test_compute.py

@@ -29,63 +29,63 @@ def test_initialization_with_negative_decimals_raises_error(self):
     def test_basic_round_half_up(self):
         """Test basic rounding behavior (ROUND_HALF_UP)"""
         rt = RoundTracker(2)
-        assert rt.round(Decimal('1.234')) == Decimal('1.23')
-        assert rt.round(Decimal('1.235')) == Decimal('1.24')
-        assert rt.round(Decimal('1.236')) == Decimal('1.24')
-        assert rt.round(Decimal('1.236')) == Decimal('1.23')  # Repeated to check consistency
-        assert rt.round(Decimal('1.236')) == Decimal('1.24')
+        assert rt(Decimal('1.234')) == Decimal('1.23')
+        assert rt(Decimal('1.235')) == Decimal('1.24')
+        assert rt(Decimal('1.236')) == Decimal('1.24')
+        assert rt(Decimal('1.236')) == Decimal('1.23')  # Repeated to check consistency
+        assert rt(Decimal('1.236')) == Decimal('1.24')
 
     def test_round_zero_decimals(self):
         """Test rounding with zero decimal places"""
         rt = RoundTracker(0)
-        assert rt.round(Decimal('1.4')) == Decimal('1')
-        assert rt.round(Decimal('1.5')) == Decimal('2')
-        assert rt.round(Decimal('1.6')) == Decimal('2')
-        assert rt.round(Decimal('1.6')) == Decimal('1') # Repeated to check consistency
-        assert rt.round(Decimal('1.6')) == Decimal('2')
+        assert rt(Decimal('1.4')) == Decimal('1')
+        assert rt(Decimal('1.5')) == Decimal('2')
+        assert rt(Decimal('1.6')) == Decimal('2')
+        assert rt(Decimal('1.6')) == Decimal('1') # Repeated to check consistency
+        assert rt(Decimal('1.6')) == Decimal('2')
 
     def test_round_three_decimals(self):
         """Test rounding with three decimal places"""
         rt = RoundTracker(3)
-        assert rt.round(Decimal('2.3454')) == Decimal('2.345')
-        assert rt.round(Decimal('2.3455')) == Decimal('2.346')
-        assert rt.round(Decimal('2.3456')) == Decimal('2.346')
-        assert rt.round(Decimal('2.3456')) == Decimal('2.345')  # Repeated to check consistency
-        assert rt.round(Decimal('2.3456')) == Decimal('2.346')
+        assert rt(Decimal('2.3454')) == Decimal('2.345')
+        assert rt(Decimal('2.3455')) == Decimal('2.346')
+        assert rt(Decimal('2.3456')) == Decimal('2.346')
+        assert rt(Decimal('2.3456')) == Decimal('2.345')  # Repeated to check consistency
+        assert rt(Decimal('2.3456')) == Decimal('2.346')
 
     def test_offset_accumulation_positive(self):
         """Test that offset accumulates correctly with positive values"""
         rt = RoundTracker(2)
         # First round: 0.005 rounds to 0.00, offset becomes 0.005
-        result1 = rt.round(Decimal('0.005'))
+        result1 = rt(Decimal('0.005'))
         assert result1 == Decimal('0.00')
         assert rt.offset == Decimal('0.005')
 
         # Second round: 0.005 rounds to 0.01, offset becomes 0.00 (0.005 + 0.005 - 0.01)
-        result2 = rt.round(Decimal('0.005'))
+        result2 = rt(Decimal('0.005'))
         assert result2 == Decimal('0.01')
         assert rt.offset == Decimal('0.00')
 
     def test_offset_accumulation_negative(self):
         """Test that offset accumulates correctly with negative rounding errors"""
         rt = RoundTracker(2)
         # 1.994 rounds to 1.99, offset becomes 0.004 (1.994 - 1.99 = 0.004)
-        result1 = rt.round(Decimal('1.994'))
+        result1 = rt(Decimal('1.994'))
         assert result1 == Decimal('1.99')
         assert rt.offset == Decimal('0.004')  # Fixed: offset calculation
 
         # 1.994 rounds to 1.99, offset becomes 0.008
-        result2 = rt.round(Decimal('1.994'))
+        result2 = rt(Decimal('1.994'))
         assert result2 == Decimal('1.99')
         assert rt.offset == Decimal('0.008')  # Fixed: offset accumulates
 
         # 1.994 rounds to 1.99, offset becomes 0.002
-        result2 = rt.round(Decimal('1.994'))
+        result2 = rt(Decimal('1.994'))
         assert result2 == Decimal('2.00')
         assert rt.offset == Decimal('0.002')  # Fixed: offset accumulates
 
         # 1.994 rounds to 1.99, offset becomes 0.002
-        result2 = rt.round(Decimal('1.996'))
+        result2 = rt(Decimal('1.996'))
         assert result2 == Decimal('2.00')
         assert rt.offset == Decimal('-0.002')  # Fixed: offset accumulates
 
@@ -136,24 +136,24 @@ def test_call_method_equivalence(self):
         rt2 = RoundTracker(2)
 
         value = Decimal('1.234')
-        assert rt1(value) == rt2.round(value)
+        assert rt1(value) == rt2(value)
 
         # Test multiple calls
         values = [Decimal('0.005'), Decimal('0.005'), Decimal('1.994')]
         results1 = [rt1(v) for v in values]
-        results2 = [rt2.round(v) for v in values]
+        results2 = [rt2(v) for v in values]
         assert results1 == results2
 
     def test_sequence_of_rounds_with_offset_correction(self):
         """Test a sequence of rounds where offset triggers ceiling/floor rounding"""
         rt = RoundTracker(2)
 
         # Accumulate positive offset
-        rt.round(Decimal('0.004'))  # rounds to 0.00, offset = 0.004
-        rt.round(Decimal('0.004'))  # rounds to 0.00, offset = 0.008
+        rt(Decimal('0.004'))  # rounds to 0.00, offset = 0.004
+        rt(Decimal('0.004'))  # rounds to 0.00, offset = 0.008
 
         # Now offset > margin, next round should use ceiling
-        result = rt.round(Decimal('1.001'))  # Should round to 1.01 due to offset
+        result = rt(Decimal('1.001'))  # Should round to 1.01 due to offset
         assert result == Decimal('1.01')
 
         # Offset should be adjusted
@@ -163,23 +163,23 @@ def test_sequence_of_rounds_with_offset_correction(self):
     def test_round_with_large_values(self):
         """Test rounding with large decimal values"""
         rt = RoundTracker(2)
-        assert rt.round(Decimal('999999.994')) == Decimal('999999.99')
-        assert rt.round(Decimal('999999.995')) == Decimal('1000000.00')
+        assert rt(Decimal('999999.994')) == Decimal('999999.99')
+        assert rt(Decimal('999999.995')) == Decimal('1000000.00')
 
     def test_round_with_negative_values(self):
         """Test rounding with negative values"""
         rt = RoundTracker(2)
-        assert rt.round(Decimal('-1.234')) == Decimal('-1.23')
-        assert rt.round(Decimal('-1.235')) == Decimal('-1.24')
-        assert rt.round(Decimal('-1.236')) == Decimal('-1.24')
+        assert rt(Decimal('-1.234')) == Decimal('-1.23')
+        assert rt(Decimal('-1.235')) == Decimal('-1.24')
+        assert rt(Decimal('-1.236')) == Decimal('-1.24')
 
     def test_offset_correction_over_multiple_rounds(self):
         """Test that offset correction works correctly over many rounds"""
         rt = RoundTracker(2)
 
         # Add values that would accumulate rounding errors
         values = [Decimal('0.333333')] * 3  # 0.333333 * 3 = 0.999999
-        results = [rt.round(v) for v in values]
+        results = [rt(v) for v in values]
 
         # First two should round to 0.33, third might round to 0.34 due to offset
         assert sum(results) in [Decimal('0.99'), Decimal('1.00')]
@@ -192,9 +192,9 @@ def test_realistic_scenario_currency_rounding(self):
         total = Decimal('10.00')
         part = total / 3  # 3.333333...
 
-        p1 = rt.round(part)  # 3.33
-        p2 = rt.round(part)  # 3.33
-        p3 = rt.round(part)  # Should be 3.34 to compensate
+        p1 = rt(part)  # 3.33
+        p2 = rt(part)  # 3.33
+        p3 = rt(part)  # Should be 3.34 to compensate
 
         assert p1 == Decimal('3.33')
         assert p2 == Decimal('3.33')
@@ -204,8 +204,8 @@ def test_realistic_scenario_currency_rounding(self):
     def test_high_precision_decimals(self):
         """Test with high precision decimal places"""
         rt = RoundTracker(6)
-        assert rt.round(Decimal('1.2345674')) == Decimal('1.234567')
-        assert rt.round(Decimal('1.2345675')) == Decimal('1.234568')
+        assert rt(Decimal('1.2345674')) == Decimal('1.234567')
+        assert rt(Decimal('1.2345675')) == Decimal('1.234568')
         assert rt.exp == Decimal('0.000000')  # Fixed: exp is '0.' + '0' * 6
         assert rt.offset_margin == Decimal('0.0000005')
 
@@ -227,6 +227,6 @@ def test_high_precision_decimals(self):
 def test_roundtracker_parametrized(decimals, value, expected):
     """Parametrized test for various decimal places and values"""
     rt = RoundTracker(decimals)
-    result = rt.round(value)
+    result = rt(value)
     assert result == expected