Merge branch 'main' into copilot/fix-790

Author: mmcky

.github/workflows/ci.yml

@@ -70,7 +70,7 @@ jobs:
       - name: Checkout source
         uses: actions/checkout@v5
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.x"
       - name: Install flit

environment_np2.yml

@@ -9,7 +9,7 @@ dependencies:
   - numpy>=2
   - scipy
   - pandas
-  - numba>=0.61
+  - numba=0.62.0rc2
   - sympy
   - ipython
   - flake8

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/game_theory/game_converters.py

@@ -31,7 +31,7 @@
 from .normal_form_game import Player, NormalFormGame
 
 
-def str2num(s):
+def _str2num(s):
     """
     Convert string to appropriate numeric type.
     
@@ -145,7 +145,7 @@ def _parse(string):
 
         N = int(tokens.pop(0))
         nums_actions = tuple(int(tokens.pop(0)) for _ in range(N))
-        payoffs = np.array([str2num(s) for s in tokens])
+        payoffs = np.array([_str2num(s) for s in tokens])
 
         na = np.prod(nums_actions)
         payoffs2d = payoffs.reshape(N, na)

quantecon/game_theory/support_enumeration.py

@@ -35,6 +35,20 @@ def support_enumeration(g):
     list(tuple(ndarray(float, ndim=1)))
         List containing tuples of Nash equilibrium mixed actions.
 
+    Examples
+    --------
+    >>> from pprint import pprint
+    >>> np.set_printoptions(precision=4)  # Reduce the digits printed
+    >>> bimatrix = [[(3, 3), (3, 2)],
+    ...             [(2, 2), (5, 6)],
+    ...             [(0, 3), (6, 1)]]
+    >>> g = NormalFormGame(bimatrix)
+    >>> NEs = support_enumeration(g)
+    >>> pprint(NEs)
+    [(array([1., 0., 0.]), array([1., 0.])),
+     (array([0.8, 0.2, 0. ]), array([0.6667, 0.3333])),
+     (array([0.    , 0.3333, 0.6667]), array([0.3333, 0.6667]))]
+
     """
     return list(support_enumeration_gen(g))
 
@@ -53,6 +67,21 @@ def support_enumeration_gen(g):
     tuple(ndarray(float, ndim=1))
         Tuple of Nash equilibrium mixed actions.
 
+    Examples
+    --------
+    >>> np.set_printoptions(precision=4)  # Reduce the digits printed
+    >>> bimatrix = [[(3, 3), (3, 2)],
+    ...             [(2, 2), (5, 6)],
+    ...             [(0, 3), (6, 1)]]
+    >>> g = NormalFormGame(bimatrix)
+    >>> gen = support_enumeration_gen(g)
+    >>> for NE in gen:
+    ...     print(NE)
+    ...
+    (array([1., 0., 0.]), array([1., 0.]))
+    (array([0.8, 0.2, 0. ]), array([0.6667, 0.3333]))
+    (array([0.    , 0.3333, 0.6667]), array([0.3333, 0.6667]))
+
     """
     try:
         N = g.N

quantecon/game_theory/vertex_enumeration.py

@@ -42,6 +42,20 @@ def vertex_enumeration(g, qhull_options=None):
     list(tuple(ndarray(float, ndim=1)))
         List containing tuples of Nash equilibrium mixed actions.
 
+    Examples
+    --------
+    >>> from pprint import pprint
+    >>> np.set_printoptions(precision=4)  # Reduce the digits printed
+    >>> bimatrix = [[(3, 3), (3, 2)],
+    ...             [(2, 2), (5, 6)],
+    ...             [(0, 3), (6, 1)]]
+    >>> g = NormalFormGame(bimatrix)
+    >>> NEs = vertex_enumeration(g)
+    >>> pprint(NEs)
+    [(array([1., 0., 0.]), array([1., 0.])),
+     (array([0.    , 0.3333, 0.6667]), array([0.3333, 0.6667])),
+     (array([0.8, 0.2, 0. ]), array([0.6667, 0.3333]))]
+
     """
     return list(vertex_enumeration_gen(g, qhull_options=qhull_options))
 
@@ -64,6 +78,21 @@ def vertex_enumeration_gen(g, qhull_options=None):
     tuple(ndarray(float, ndim=1))
         Tuple of Nash equilibrium mixed actions.
 
+    Examples
+    --------
+    >>> np.set_printoptions(precision=4)  # Reduce the digits printed
+    >>> bimatrix = [[(3, 3), (3, 2)],
+    ...             [(2, 2), (5, 6)],
+    ...             [(0, 3), (6, 1)]]
+    >>> g = NormalFormGame(bimatrix)
+    >>> gen = vertex_enumeration_gen(g)
+    >>> for NE in gen:
+    ...     print(NE)
+    ...
+    (array([1., 0., 0.]), array([1., 0.]))
+    (array([0.    , 0.3333, 0.6667]), array([0.3333, 0.6667]))
+    (array([0.8, 0.2, 0. ]), array([0.6667, 0.3333]))
+
     """
     try:
         N = g.N

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