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 <[email protected]>

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,107 @@ 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_use_global_precision(self):
+        """Test that tac/toc functions use global precision by default."""
+        # This is harder to test automatically since it affects output formatting
+        # But we can verify the functions accept None for digits parameter
+        qe.timings.float_precision(6)
+        
+        tic()
+        time.sleep(0.01)
+        
+        # These should use global precision (no exception means it works)
+        tac(verbose=False, digits=None)
+        toc(verbose=False, digits=None)
+        
+    def test_loop_timer_uses_global_precision(self):
+        """Test that loop_timer uses global precision by default."""
+        def test_func():
+            time.sleep(0.001)
+            
+        qe.timings.float_precision(6)
+        
+        # Should use global precision without error
+        result = loop_timer(2, test_func, digits=None, 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__:
@@ -39,7 +40,7 @@ def tic(self):
         self.start = t
         self.last = t
 
-    def tac(self, verbose=True, digits=2):
+    def tac(self, verbose=True, digits=None):
         """
         Return and print elapsed time since last `tic()`, `tac()`, or
         `toc()`.
@@ -49,8 +50,9 @@ def tac(self, verbose=True, digits=2):
         verbose : bool, optional(default=True)
             If True, then prints time.
 
-        digits : scalar(int), optional(default=2)
-            Number of digits printed for time elapsed.
+        digits : scalar(int), optional(default=None)
+            Number of digits printed for time elapsed. If None, uses
+            the global default precision from quantecon.timings.
 
         Returns
         -------
@@ -61,6 +63,9 @@ def tac(self, verbose=True, digits=2):
         if self.start is None:
             raise Exception("tac() without tic()")
 
+        if digits is None:
+            digits = get_default_precision()
+
         t = time.time()
         elapsed = t-self.last
         self.last = t
@@ -73,7 +78,7 @@ def tac(self, verbose=True, digits=2):
 
         return elapsed
 
-    def toc(self, verbose=True, digits=2):
+    def toc(self, verbose=True, digits=None):
         """
         Return and print time elapsed since last `tic()`.
 
@@ -82,8 +87,9 @@ def toc(self, verbose=True, digits=2):
         verbose : bool, optional(default=True)
             If True, then prints time.
 
-        digits : scalar(int), optional(default=2)
-            Number of digits printed for time elapsed.
+        digits : scalar(int), optional(default=None)
+            Number of digits printed for time elapsed. If None, uses
+            the global default precision from quantecon.timings.
 
         Returns
         -------
@@ -94,6 +100,9 @@ def toc(self, verbose=True, digits=2):
         if self.start is None:
             raise Exception("toc() without tic()")
 
+        if digits is None:
+            digits = get_default_precision()
+
         t = time.time()
         self.last = t
         elapsed = t-self.start
@@ -106,7 +115,7 @@ def toc(self, verbose=True, digits=2):
 
         return elapsed
 
-    def loop_timer(self, n, function, args=None, verbose=True, digits=2,
+    def loop_timer(self, n, function, args=None, verbose=True, digits=None,
                    best_of=3):
         """
         Return and print the total and average time elapsed for n runs
@@ -126,8 +135,9 @@ def loop_timer(self, n, function, args=None, verbose=True, digits=2,
         verbose : bool, optional(default=True)
             If True, then prints average time.
 
-        digits : scalar(int), optional(default=2)
-            Number of digits printed for time elapsed.
+        digits : scalar(int), optional(default=None)
+            Number of digits printed for time elapsed. If None, uses
+            the global default precision from quantecon.timings.
 
         best_of : scalar(int), optional(default=3)
             Average time over best_of runs.
@@ -141,6 +151,9 @@ def loop_timer(self, n, function, args=None, verbose=True, digits=2,
             Average of best_of times for n runs of function.
 
         """
+        if digits is None:
+            digits = get_default_precision()
+
         tic()
         all_times = np.empty(n)
         for run in range(n):
@@ -190,8 +203,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 +222,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 +239,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 +361,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 +390,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 +413,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
@@ -442,15 +456,15 @@ def tic():
     return __timer__.tic()
 
 
-def tac(verbose=True, digits=2):
+def tac(verbose=True, digits=None):
     return __timer__.tac(verbose, digits)
 
 
-def toc(verbose=True, digits=2):
+def toc(verbose=True, digits=None):
     return __timer__.toc(verbose, digits)
 
 
-def loop_timer(n, function, args=None, verbose=True, digits=2, best_of=3):
+def loop_timer(n, function, args=None, verbose=True, digits=None, best_of=3):
     return __timer__.loop_timer(n, function, args, verbose, digits, best_of)