ENH: Update default timing precision to 4 digits and add global precision control for Timer and timeit (#805)

* Initial plan

* Implement global timing precision control with 4-digit default

- Create quantecon.timings module with float_precision() function
- Update Timer class to use global precision as default (was 2, now 4)
- Update timeit function to use global precision as default
- Update tac/toc/loop_timer functions to use global precision as default
- Add comprehensive tests for new global precision functionality
- All 27 timing tests passing (19 existing + 8 new)
- Backward compatibility maintained - explicit precision parameters still work

Co-authored-by: mmcky <8263752+mmcky@users.noreply.github.com>

* Revert tic/tac/toc/loop_timer to original defaults - keep only Timer and timeit using global precision

Co-authored-by: mmcky <8263752+mmcky@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: mmcky <8263752+mmcky@users.noreply.github.com>

Author: Copilot

quantecon/__init__.py

@@ -18,6 +18,7 @@
 from . import quad
 from . import random
 from . import optimize
+from . import timings
 
 #-Objects-#
 from ._compute_fp import compute_fixed_point

quantecon/timings/__init__.py

@@ -0,0 +1,7 @@
+"""
+Timing precision configuration for QuantEcon.py
+"""
+
+from .timings import float_precision, get_default_precision
+
+__all__ = ['float_precision', 'get_default_precision']

quantecon/timings/timings.py

@@ -0,0 +1,61 @@
+"""
+Global timing precision configuration for QuantEcon.py
+
+This module provides global control over the precision used in timing outputs
+across all timing functions in QuantEcon.
+"""
+
+# Global variable to store the current float precision
+_DEFAULT_FLOAT_PRECISION = 4
+
+
+def float_precision(precision=None):
+    """
+    Get or set the global float precision for timing outputs.
+    
+    Parameters
+    ----------
+    precision : int, optional
+        Number of decimal places to display in timing outputs. 
+        If None, returns the current precision setting.
+        
+    Returns
+    -------
+    int
+        Current precision value if precision=None, otherwise None.
+        
+    Examples
+    --------
+    Get current precision:
+    >>> import quantecon as qe
+    >>> current = qe.timings.float_precision()
+    >>> print(f"Current precision: {current}")
+    
+    Set new precision:
+    >>> qe.timings.float_precision(6)
+    >>> # All subsequent timing outputs will use 6 decimal places
+    
+    Reset to default:
+    >>> qe.timings.float_precision(4)
+    """
+    global _DEFAULT_FLOAT_PRECISION
+    
+    if precision is None:
+        return _DEFAULT_FLOAT_PRECISION
+    
+    if not isinstance(precision, int) or precision < 0:
+        raise ValueError("precision must be a non-negative integer")
+    
+    _DEFAULT_FLOAT_PRECISION = precision
+
+
+def get_default_precision():
+    """
+    Get the current default precision setting.
+    
+    Returns
+    -------
+    int
+        Current default precision for timing outputs.
+    """
+    return _DEFAULT_FLOAT_PRECISION

quantecon/util/tests/test_timing.py

@@ -6,6 +6,7 @@
 import time
 from numpy.testing import assert_allclose, assert_
 from quantecon.util import tic, tac, toc, loop_timer, Timer, timeit
+import quantecon as qe
 
 
 class TestTicTacToc:
@@ -291,3 +292,106 @@ def test_func():
         assert 'elapsed' in result2
         assert len(result2['elapsed']) == 2
 
+
+class TestGlobalPrecision:
+    """Test the new global precision control functionality."""
+    
+    def setup_method(self):
+        """Save original precision and restore after each test."""
+        self.original_precision = qe.timings.float_precision()
+        
+    def teardown_method(self):
+        """Restore original precision after each test."""
+        qe.timings.float_precision(self.original_precision)
+        
+    def test_default_precision_is_4(self):
+        """Test that default precision is now 4."""
+        # Reset to ensure we test the true default
+        qe.timings.float_precision(4)
+        assert qe.timings.float_precision() == 4
+        
+    def test_float_precision_get_set(self):
+        """Test getting and setting precision."""
+        # Test setting various precisions
+        for precision in [0, 1, 2, 3, 4, 5, 6, 10]:
+            qe.timings.float_precision(precision)
+            assert qe.timings.float_precision() == precision
+            
+    def test_float_precision_validation(self):
+        """Test that float_precision validates input."""
+        # Test invalid inputs
+        try:
+            qe.timings.float_precision(-1)
+            assert False, "Should raise ValueError for negative precision"
+        except ValueError as e:
+            assert "non-negative integer" in str(e)
+            
+        try:
+            qe.timings.float_precision("4")
+            assert False, "Should raise ValueError for string input"
+        except ValueError as e:
+            assert "non-negative integer" in str(e)
+            
+        try:
+            qe.timings.float_precision(4.5)
+            assert False, "Should raise ValueError for float input"
+        except ValueError as e:
+            assert "non-negative integer" in str(e)
+            
+    def test_timer_uses_global_precision(self):
+        """Test that Timer class uses global precision by default."""
+        # Set global precision
+        qe.timings.float_precision(6)
+        
+        # Create timer without explicit precision
+        timer = Timer(verbose=False)
+        assert timer.precision == 6
+        
+        # Test with different global precision
+        qe.timings.float_precision(2)
+        timer2 = Timer(verbose=False)
+        assert timer2.precision == 2
+        
+    def test_timer_explicit_precision_overrides_global(self):
+        """Test that explicit precision overrides global setting."""
+        qe.timings.float_precision(6)
+        
+        # Explicit precision should override global
+        timer = Timer(precision=3, verbose=False)
+        assert timer.precision == 3
+        
+    def test_tac_toc_keep_original_defaults(self):
+        """Test that tac/toc functions maintain original default (digits=2)."""
+        # These functions are deprecated and should maintain original behavior
+        tic()
+        time.sleep(0.01)
+        
+        # These should use digits=2 by default, not global precision
+        result_tac = tac(verbose=False)  # Uses default digits=2
+        result_toc = toc(verbose=False)  # Uses default digits=2
+        
+        # Just verify they work without error
+        assert result_tac > 0
+        assert result_toc > 0
+        
+    def test_loop_timer_keeps_original_default(self):
+        """Test that loop_timer maintains original default (digits=2)."""
+        def test_func():
+            time.sleep(0.001)
+            
+        # Should use digits=2 by default, not global precision
+        result = loop_timer(2, test_func, verbose=False)
+        assert len(result) == 2  # Returns (average_time, average_of_best)
+        
+    def test_timeit_uses_global_precision(self):
+        """Test that timeit function uses global precision by default."""
+        def test_func():
+            time.sleep(0.001)
+            
+        qe.timings.float_precision(6)
+        
+        # Should use global precision without error
+        result = timeit(test_func, runs=2, verbose=False, results=True)
+        assert 'elapsed' in result
+        assert len(result['elapsed']) == 2
+

quantecon/util/timing.py

@@ -4,6 +4,7 @@
 """
 import time
 import numpy as np
+from ..timings.timings import get_default_precision
 
 
 class __Timer__:
@@ -190,8 +191,9 @@ class Timer:
     ----------
     message : str, optional(default="")
         Custom message to display with timing results.
-    precision : int, optional(default=2)
-        Number of decimal places to display for seconds.
+    precision : int, optional(default=None)
+        Number of decimal places to display for seconds. If None, uses
+        the global default precision from quantecon.timings.
     unit : str, optional(default="seconds") 
         Unit to display timing in. Options: "seconds", "milliseconds", "microseconds"
     verbose : bool, optional(default=True)
@@ -208,13 +210,13 @@ class Timer:
     >>> with Timer():
     ...     # some code
     ...     pass
-    0.00 seconds elapsed
+    0.0000 seconds elapsed
     
     With custom message and precision:
-    >>> with Timer("Computing results", precision=4):
+    >>> with Timer("Computing results", precision=6):
     ...     # some code  
     ...     pass
-    Computing results: 0.0001 seconds elapsed
+    Computing results: 0.000001 seconds elapsed
     
     Store elapsed time for comparison:
     >>> timer = Timer(verbose=False)
@@ -225,9 +227,9 @@ class Timer:
     Method took 0.000123 seconds
     """
 
-    def __init__(self, message="", precision=2, unit="seconds", verbose=True):
+    def __init__(self, message="", precision=None, unit="seconds", verbose=True):
         self.message = message
-        self.precision = precision
+        self.precision = precision if precision is not None else get_default_precision()
         self.unit = unit.lower()
         self.verbose = verbose
         self.elapsed = None
@@ -347,7 +349,7 @@ def timeit(func, runs=1, stats_only=False, verbose=True, results=False, **timer_
     # Extract Timer parameters
     timer_params = {
         'message': timer_kwargs.pop('message', ''),
-        'precision': timer_kwargs.pop('precision', 2),
+        'precision': timer_kwargs.pop('precision', None),  # None will use global default
         'unit': timer_kwargs.pop('unit', 'seconds'),
         'verbose': timer_kwargs.pop('verbose', True)  # Timer verbose parameter
     }
@@ -376,7 +378,7 @@ def timeit(func, runs=1, stats_only=False, verbose=True, results=False, **timer_
         if show_output and not stats_only:
             # Convert to requested unit for display
             unit = timer_params['unit'].lower()
-            precision = timer_params['precision']
+            precision = timer_params['precision'] if timer_params['precision'] is not None else get_default_precision()
 
             if unit == "milliseconds":
                 elapsed_display = timer.elapsed * 1000
@@ -399,7 +401,7 @@ def timeit(func, runs=1, stats_only=False, verbose=True, results=False, **timer_
     if show_output:
         # Convert to requested unit for display
         unit = timer_params['unit'].lower()
-        precision = timer_params['precision']
+        precision = timer_params['precision'] if timer_params['precision'] is not None else get_default_precision()
 
         if unit == "milliseconds":
             avg_display = average * 1000