mergeron 2024.739127.1__py3-none-any.whl → 2024.739145.0__py3-none-any.whl

mergeron/core/guidelines_boundary_functions.py

@@ -6,10 +6,11 @@ import numpy as np
 from mpmath import mp, mpf  # type: ignore
 
 from .. import DEFAULT_REC_RATE, VERSION, ArrayBIGINT, ArrayDouble  # noqa: TID252
+from . import MPFloat
 
 __version__ = VERSION
 
-mp.prec = 80
+mp.dps = 32
 mp.trap_complex = True
 
 
@@ -17,7 +18,7 @@ class ShareRatioBoundaryKeywords(TypedDict, total=False):
     """Keyword arguments for functions generating share ratio boundaries."""
 
     recapture_form: Literal["inside-out", "proportional"]
-    prec: int
+    dps: int
     agg_method: Literal["arithmetic mean", "geometric mean", "distance"]
     weighting: Literal["own-share", "cross-product-share", None]
 
@@ -33,7 +34,7 @@ class GuidelinesBoundary:
     """Area under the boundary."""
 
 
-def dh_area(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
+def dh_area(_dh_val: float | MPFloat = 0.01, /, *, dps: int = 9) -> float:
     R"""
     Area under the ΔHHI boundary.
 
@@ -56,7 +57,7 @@ def dh_area(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
     ----------
     _dh_val
         Change in concentration.
-    prec
+    dps
         Specified precision in decimal places.
 
     Returns
@@ -70,13 +71,11 @@ def dh_area(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
 
     return round(
         float(_s_naught + (_dh_val / 2) * (mp.ln(1 - _s_naught) - mp.ln(_s_naught))),
-        prec,
+        dps,
     )
 
 
-def hhi_delta_boundary(
-    _dh_val: float = 0.01, /, *, prec: int = 5
-) -> GuidelinesBoundary:
+def hhi_delta_boundary(_dh_val: float = 0.01, /, *, dps: int = 5) -> GuidelinesBoundary:
     """
     Generate the list of share combination on the ΔHHI boundary.
 
@@ -84,7 +83,7 @@ def hhi_delta_boundary(
     ----------
     _dh_val:
         Merging-firms' ΔHHI bound.
-    prec
+    dps
         Number of decimal places for rounding reported shares.
 
     Returns
@@ -106,20 +105,13 @@ def hhi_delta_boundary(
         np.column_stack((_s_1, _s_2)),
         np.array([(mpf("0.0"), mpf("1.0"))]),
     ))
-    _dh_bdry_pts = np.vstack((np.flip(_dh_half, 0), np.flip(_dh_half[1:], 1)))
+    _dh_bdry_pts = np.vstack((_dh_half[::-1], _dh_half[1:, ::-1]))
 
-    _s_1_pts, _s_2_pts = np.split(_dh_bdry_pts, 2, axis=1)
-    return GuidelinesBoundary(
-        np.column_stack((
-            np.array(_s_1_pts, np.float64),
-            np.array(_s_2_pts, np.float64),
-        )),
-        dh_area(_dh_val, prec=prec),
-    )
+    return GuidelinesBoundary(_dh_bdry_pts, dh_area(_dh_val, dps=dps))
 
 
 def hhi_pre_contrib_boundary(
-    _hhi_contrib: float = 0.03125, /, *, prec: int = 5
+    _hhi_contrib: float = 0.03125, /, *, dps: int = 5
 ) -> GuidelinesBoundary:
     """
     Share combinations on the premerger HHI contribution boundary.
@@ -128,7 +120,7 @@ def hhi_pre_contrib_boundary(
     ----------
     _hhi_contrib:
         Merging-firms' pre-merger HHI contribution bound.
-    prec
+    dps
         Number of decimal places for rounding reported shares.
 
     Returns
@@ -139,19 +131,19 @@ def hhi_pre_contrib_boundary(
     _hhi_contrib = mpf(f"{_hhi_contrib}")
     _s_mid = mp.sqrt(_hhi_contrib / 2)
 
-    _bdry_step_sz = mp.power(10, -prec)
+    _bdry_step_sz = mp.power(10, -dps)
     # Range-limit is 0 less a step, which is -1 * step-size
     _s_1 = np.array(mp.arange(_s_mid, -_bdry_step_sz, -_bdry_step_sz), np.float64)
     _s_2 = np.sqrt(_hhi_contrib - _s_1**2).astype(np.float64)
     _bdry_pts_mid = np.column_stack((_s_1, _s_2))
     return GuidelinesBoundary(
-        np.vstack((np.flip(_bdry_pts_mid, 0), np.flip(_bdry_pts_mid[1:], 1))),
-        round(float(mp.pi * _hhi_contrib / 4), prec),
+        np.vstack((_bdry_pts_mid[::-1], _bdry_pts_mid[1:, ::-1])),
+        round(float(mp.pi * _hhi_contrib / 4), dps),
     )
 
 
 def combined_share_boundary(
-    _s_intcpt: float = 0.0625, /, *, prec: int = 10
+    _s_intcpt: float = 0.0625, /, *, dps: int = 10
 ) -> GuidelinesBoundary:
     """
     Share combinations on the merging-firms' combined share boundary.
@@ -164,7 +156,7 @@ def combined_share_boundary(
     ----------
     _s_intcpt:
         Merging-firms' combined share.
-    prec
+    dps
         Number of decimal places for rounding reported shares.
 
     Returns
@@ -181,12 +173,12 @@ def combined_share_boundary(
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
         )),
-        round(float(_s_intcpt * _s_mid), prec),
+        round(float(_s_intcpt * _s_mid), dps),
     )
 
 
 def hhi_post_contrib_boundary(
-    _hhi_contrib: float = 0.800, /, *, prec: int = 10
+    _hhi_contrib: float = 0.800, /, *, dps: int = 10
 ) -> GuidelinesBoundary:
     """
     Share combinations on the postmerger HHI contribution boundary.
@@ -198,7 +190,7 @@ def hhi_post_contrib_boundary(
     ----------
     _hhi_contrib:
         Merging-firms' pre-merger HHI contribution bound.
-    prec
+    dps
         Number of decimal places for rounding reported shares.
 
     Returns
@@ -206,7 +198,7 @@ def hhi_post_contrib_boundary(
         Array of share-pairs, area under boundary.
 
     """
-    return combined_share_boundary(np.sqrt(_hhi_contrib), prec=prec)
+    return combined_share_boundary(np.sqrt(_hhi_contrib), dps=dps)
 
 
 def shrratio_boundary_wtd_avg(
@@ -219,7 +211,7 @@ def shrratio_boundary_wtd_avg(
     ] = "arithmetic mean",
     weighting: Literal["own-share", "cross-product-share", None] = "own-share",
     recapture_form: Literal["inside-out", "proportional"] = "inside-out",
-    prec: int = 5,
+    dps: int = 5,
 ) -> GuidelinesBoundary:
     """
     Share combinations on the share-weighted average diversion ratio boundary.
@@ -237,7 +229,7 @@ def shrratio_boundary_wtd_avg(
     recapture_form
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
-    prec
+    dps
         Number of decimal places for rounding returned shares and area.
 
     Returns
@@ -309,7 +301,7 @@ def shrratio_boundary_wtd_avg(
     """
 
     _delta_star = mpf(f"{_delta_star}")
-    _s_mid = _delta_star / (1 + _delta_star)
+    _s_mid = mp.fdiv(_delta_star, 1 + _delta_star)
 
     # initial conditions
     _gbdry_points = [(_s_mid, _s_mid)]
@@ -317,7 +309,7 @@ def shrratio_boundary_wtd_avg(
     _s_2_oddval, _s_2_oddsum, _s_2_evnsum = True, 0.0, 0.0
 
     # parameters for iteration
-    _gbd_step_sz = mp.power(10, -prec)
+    _gbd_step_sz = mp.power(10, -dps)
     _theta = _gbd_step_sz * (10 if weighting == "cross-product-share" else 1)
     for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
         # The wtd. avg. GUPPI is not always convex to the origin, so we
@@ -346,7 +338,7 @@ def shrratio_boundary_wtd_avg(
             )
 
             match agg_method:
-                case "geometric":
+                case "geometric mean":
                     _delta_test = mp.expm1(lerp(mp.log1p(_de_1), mp.log1p(_de_2), _r))
                 case "distance":
                     _delta_test = mp.sqrt(lerp(_de_1**2, _de_2**2, _r))
@@ -407,14 +399,13 @@ def shrratio_boundary_wtd_avg(
         # Area under boundary
         _gbdry_area_total = float(2 * _gbd_prtlarea - mp.power(_s_mid, "2"))
 
-    _gbdry_points = np.vstack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
-        np.float64
-    )
+    _gbdry_points.append((mpf("0.0"), _s_intcpt))
+    _gbd_pts_arr = np.array(_gbdry_points).astype(np.float64)
 
     # Points defining boundary to point-of-symmetry
     return GuidelinesBoundary(
-        np.vstack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
-        round(float(_gbdry_area_total), prec),
+        np.vstack((_gbd_pts_arr[::-1], _gbd_pts_arr[1:, ::-1])),
+        round(float(_gbdry_area_total), dps),
     )
 
 
@@ -424,7 +415,7 @@ def shrratio_boundary_xact_avg(
     /,
     *,
     recapture_form: Literal["inside-out", "proportional"] = "inside-out",
-    prec: int = 5,
+    dps: int = 5,
 ) -> GuidelinesBoundary:
     """
     Share combinations for the simple average GUPPI boundary with symmetric
@@ -472,7 +463,7 @@ def shrratio_boundary_xact_avg(
     recapture_form
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
-    prec
+    dps
         Number of decimal places for rounding returned shares.
 
     Returns
@@ -483,7 +474,7 @@ def shrratio_boundary_xact_avg(
 
     _delta_star = mpf(f"{_delta_star}")
     _s_mid = _delta_star / (1 + _delta_star)
-    _gbd_step_sz = mp.power(10, -prec)
+    _gbd_step_sz = mp.power(10, -dps)
 
     _gbdry_points_start = np.array([(_s_mid, _s_mid)])
     _s_1 = np.array(mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz), np.float64)
@@ -523,7 +514,7 @@ def shrratio_boundary_xact_avg(
             np.einsum("i->", _nr_t2_mdr.astype(np.float64)),
             np.einsum("i->", _nr_t2_s1.astype(np.float64)),
             rtol=0,
-            atol=0.5 * prec,
+            atol=0.5 * dps,
         ):
             raise RuntimeError(
                 "Calculation of sq. root term in exact average GUPPI"
@@ -552,7 +543,162 @@ def shrratio_boundary_xact_avg(
 
     _gbdry_points = np.vstack((
         _gbdry_points_end,
-        np.flip(_gbdry_points_inner, 0),
+        _gbdry_points_inner[::-1],
+        _gbdry_points_start,
+        _gbdry_points_inner[:, ::-1],
+        _gbdry_points_end[:, ::-1],
+    )).astype(np.float64)
+    _s_2 = np.concatenate((np.array([_s_mid], np.float64), _s_2))
+
+    _gbdry_ends = [0, -1]
+    _gbdry_odds = np.array(range(1, len(_s_2), 2), np.int64)
+    _gbdry_evns = np.array(range(2, len(_s_2), 2), np.int64)
+
+    # Double the are under the curve, and subtract the double counted bit.
+    _gbdry_area_simpson = 2 * _gbd_step_sz * (
+        (4 / 3) * np.sum(_s_2.take(_gbdry_odds))
+        + (2 / 3) * np.sum(_s_2.take(_gbdry_evns))
+        + (1 / 3) * np.sum(_s_2.take(_gbdry_ends))
+    ) - np.power(_s_mid, 2)
+
+    return GuidelinesBoundary(_gbdry_points, round(float(_gbdry_area_simpson), dps))
+
+
+def shrratio_boundary_xact_avg_mp(
+    _delta_star: float = 0.075,
+    _r_val: float = DEFAULT_REC_RATE,
+    /,
+    *,
+    recapture_form: Literal["inside-out", "proportional"] = "inside-out",
+    dps: int = 5,
+) -> GuidelinesBoundary:
+    """
+    Share combinations for the simple average GUPPI boundary with symmetric
+    merging-firm margins.
+
+    Notes
+    -----
+    An analytical expression for the exact average boundary is derived
+    and plotted from the y-intercept to the ray of symmetry as follows::
+
+        from sympy import latex, plot as symplot, solve, symbols
+
+        s_1, s_2 = symbols("s_1 s_2")
+
+        g_val, r_val, m_val = 0.06, 0.80, 0.30
+        d_hat = g_val / (r_val * m_val)
+
+        # recapture_form = "inside-out"
+        sag = solve(
+            (s_2 / (1 - s_1))
+            + (s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1)))
+            - 2 * d_hat,
+            s_2
+        )[0]
+        symplot(
+            sag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+        # recapture_form = "proportional"
+        sag = solve((s_2/(1 - s_1)) + (s_1/(1 - s_2)) - 2 * d_hat, s_2)[0]
+        symplot(
+            sag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+    Parameters
+    ----------
+    _delta_star
+        Share ratio (:math:`\\overline{d} / \\overline{r}`).
+    _r_val
+        Recapture ratio
+    recapture_form
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+    dps
+        Number of decimal places for rounding returned shares.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary, area under boundary.
+
+    """
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+    _gbd_step_sz = mp.power(10, -dps)
+
+    _gbdry_points_start = np.array([(_s_mid, _s_mid)])
+    _s_1 = np.array(mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz), np.float64)
+    if recapture_form == "inside-out":
+        _s_intcpt = mp.fdiv(
+            mp.fsub(
+                2 * _delta_star * _r_val + 1, mp.fabs(2 * _delta_star * _r_val - 1)
+            ),
+            2 * mpf(f"{_r_val}"),
+        )
+        _nr_t1 = 1 + 2 * _delta_star * _r_val * (1 - _s_1) - _s_1 * (1 - _r_val)
+
+        _nr_sqrt_mdr = 4 * _delta_star * _r_val
+        _nr_sqrt_mdr2 = _nr_sqrt_mdr * _r_val
+        _nr_sqrt_md2r2 = _nr_sqrt_mdr2 * _delta_star
+
+        _nr_sqrt_t1 = _nr_sqrt_md2r2 * (_s_1**2 - 2 * _s_1 + 1)
+        _nr_sqrt_t2 = _nr_sqrt_mdr2 * _s_1 * (_s_1 - 1)
+        _nr_sqrt_t3 = _nr_sqrt_mdr * (2 * _s_1 - _s_1**2 - 1)
+        _nr_sqrt_t4 = (_s_1**2) * (_r_val**2 - 6 * _r_val + 1)
+        _nr_sqrt_t5 = _s_1 * (6 * _r_val - 2) + 1
+
+        _nr_t2_mdr = _nr_sqrt_t1 + _nr_sqrt_t2 + _nr_sqrt_t3 + _nr_sqrt_t4 + _nr_sqrt_t5
+
+        # Alternative grouping of terms in np.sqrt
+        _nr_sqrt_s1sq = (_s_1**2) * (
+            _nr_sqrt_md2r2 + _nr_sqrt_mdr2 - _nr_sqrt_mdr + _r_val**2 - 6 * _r_val + 1
+        )
+        _nr_sqrt_s1 = _s_1 * (
+            -2 * _nr_sqrt_md2r2 - _nr_sqrt_mdr2 + 2 * _nr_sqrt_mdr + 6 * _r_val - 2
+        )
+        _nr_sqrt_nos1 = _nr_sqrt_md2r2 - _nr_sqrt_mdr + 1
+
+        _nr_t2_s1 = _nr_sqrt_s1sq + _nr_sqrt_s1 + _nr_sqrt_nos1
+
+        if not np.isclose(
+            np.einsum("i->", _nr_t2_mdr.astype(np.float64)),
+            np.einsum("i->", _nr_t2_s1.astype(np.float64)),
+            rtol=0,
+            atol=0.5 * dps,
+        ):
+            raise RuntimeError(
+                "Calculation of sq. root term in exact average GUPPI"
+                f"with recapture spec, {f'"{recapture_form}"'} is incorrect."
+            )
+
+        _s_2 = (_nr_t1 - np.sqrt(_nr_t2_s1)) / (2 * _r_val)
+
+    else:
+        _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
+        _s_2 = (
+            (1 / 2)
+            + _delta_star
+            - _delta_star * _s_1
+            - np.sqrt(
+                ((_delta_star**2) - 1) * (_s_1**2)
+                + (-2 * (_delta_star**2) + _delta_star + 1) * _s_1
+                + (_delta_star**2)
+                - _delta_star
+                + (1 / 4)
+            )
+        )
+
+    _gbdry_points_inner = np.column_stack((_s_1, _s_2))
+    _gbdry_points_end = np.array([(mpf("0.0"), _s_intcpt)], np.float64)
+
+    _gbdry_points = np.vstack((
+        _gbdry_points_end,
+        _gbdry_points_inner[::-1],
         _gbdry_points_start,
         np.flip(_gbdry_points_inner, 1),
         np.flip(_gbdry_points_end, 1),
@@ -570,11 +716,7 @@ def shrratio_boundary_xact_avg(
         + (1 / 3) * np.sum(_s_2.take(_gbdry_ends))
     ) - np.power(_s_mid, 2)
 
-    _s_1_pts, _s_2_pts = np.split(_gbdry_points, 2, axis=1)
-    return GuidelinesBoundary(
-        np.column_stack((np.array(_s_1_pts), np.array(_s_2_pts))),
-        round(float(_gbdry_area_simpson), prec),
-    )
+    return GuidelinesBoundary(_gbdry_points, round(float(_gbdry_area_simpson), dps))
 
 
 def shrratio_boundary_min(
@@ -583,7 +725,7 @@ def shrratio_boundary_min(
     /,
     *,
     recapture_form: str = "inside-out",
-    prec: int = 10,
+    dps: int = 10,
 ) -> GuidelinesBoundary:
     """
     Share combinations on the minimum GUPPI boundary, with symmetric
@@ -605,7 +747,7 @@ def shrratio_boundary_min(
     recapture_form
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
-    prec
+    dps
         Number of decimal places for rounding returned shares.
 
     Returns
@@ -640,12 +782,12 @@ def shrratio_boundary_min(
         _s1_pts, _gbd_area = np.array((0, _s_mid, _s_intcpt), np.float64), _s_mid
 
     return GuidelinesBoundary(
-        np.column_stack((_s1_pts, _s1_pts[::-1])), round(float(_gbd_area), prec)
+        np.column_stack((_s1_pts, _s1_pts[::-1])), round(float(_gbd_area), dps)
     )
 
 
 def shrratio_boundary_max(
-    _delta_star: float = 0.075, _r_val: float = DEFAULT_REC_RATE, /, *, prec: int = 10
+    _delta_star: float = 0.075, _r_val: float = DEFAULT_REC_RATE, /, *, dps: int = 10
 ) -> GuidelinesBoundary:
     """
     Share combinations on the minimum GUPPI boundary with symmetric
@@ -657,7 +799,7 @@ def shrratio_boundary_max(
         Share ratio (:math:`\\overline{d} / \\overline{r}`).
     _r_val
         Recapture ratio.
-    prec
+    dps
         Number of decimal places for rounding returned shares.
 
     Returns
@@ -680,14 +822,14 @@ def shrratio_boundary_max(
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
         )),
-        round(float(_s_intcpt * _s_mid), prec),  # simplified calculation
+        round(float(_s_intcpt * _s_mid), dps),  # simplified calculation
     )
 
 
 def _shrratio_boundary_intcpt(
     _s_2_pre: float,
-    _delta_star: mpf,
-    _r_val: mpf,
+    _delta_star: MPFloat,
+    _r_val: MPFloat,
     /,
     *,
     recapture_form: Literal["inside-out", "proportional"],
@@ -717,11 +859,11 @@ def _shrratio_boundary_intcpt(
 
 
 def lerp(
-    _x1: int | float | mpf | ArrayDouble | ArrayBIGINT = 3,
-    _x2: int | float | mpf | ArrayDouble | ArrayBIGINT = 1,
-    _r: float | mpf = 0.25,
+    _x1: int | float | MPFloat | ArrayDouble | ArrayBIGINT = 3,
+    _x2: int | float | MPFloat | ArrayDouble | ArrayBIGINT = 1,
+    _r: float | MPFloat = 0.25,
     /,
-) -> float | mpf | ArrayDouble:
+) -> float | MPFloat | ArrayDouble:
     """
     From the function of the same name in the C++ standard [2]_
 

mergeron/core/guidelines_boundary_functions_extra.py

@@ -17,16 +17,12 @@ from scipy.spatial.distance import minkowski as distance_function  # type: ignor
 from sympy import lambdify, simplify, solve, symbols  # type: ignore
 
 from .. import DEFAULT_REC_RATE, VERSION, ArrayDouble  # noqa: TID252
-from .guidelines_boundary_functions import (
-    GuidelinesBoundary,
-    _shrratio_boundary_intcpt,
-    lerp,
-)
+from . import guidelines_boundary_functions as gbfn
 
 __version__ = VERSION
 
 
-mp.prec = 80
+mp.dps = 32
 mp.trap_complex = True
 
 
@@ -37,7 +33,7 @@ class GuidelinesBoundaryCallable:
     s_naught: float = 0
 
 
-def dh_area_quad(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
+def dh_area_quad(_dh_val: float = 0.01, /, *, dps: int = 9) -> float:
     """
     Area under the ΔHHI boundary.
 
@@ -49,7 +45,7 @@ def dh_area_quad(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
     ----------
     _dh_val
         Merging-firms' ΔHHI bound.
-    prec
+    dps
         Specified precision in decimal places.
 
     Returns
@@ -65,7 +61,7 @@ def dh_area_quad(_dh_val: float = 0.01, /, *, prec: int = 9) -> float:
         float(
             _s_naught + mp.quad(lambda x: _dh_val / (2 * x), [_s_naught, 1 - _s_naught])
         ),
-        prec,
+        dps,
     )
 
 
@@ -95,7 +91,7 @@ def hhi_delta_boundary_qdtr(_dh_val: float = 0.01, /) -> GuidelinesBoundaryCalla
 
     _hhi_bdry_area = 2 * (
         _s_nought
-        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))
+        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))  # pyright: ignore
     )
 
     return GuidelinesBoundaryCallable(
@@ -163,7 +159,7 @@ def shrratio_boundary_qdtr_wtd_avg(
                 2
                 * (
                     _s_naught
-                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))
+                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))  # pyright: ignore
                 )
                 - (_s_mid**2 + _s_naught**2)
             )
@@ -193,7 +189,7 @@ def shrratio_boundary_qdtr_wtd_avg(
                         ),
                         (0, _s_mid),
                     )
-                ).real
+                ).real  # pyright: ignore
                 - _s_mid**2
             )
 
@@ -213,7 +209,7 @@ def shrratio_boundary_qdtr_wtd_avg(
 
             _bdry_func = solve(_bdry_eqn, _s_2)[0]
             _bdry_area = float(
-                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))
+                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))  # pyright: ignore
                 - _s_mid**2
             )
 
@@ -230,8 +226,8 @@ def shrratio_boundary_distance(
     agg_method: Literal["arithmetic mean", "distance"] = "arithmetic mean",
     weighting: Literal["own-share", "cross-product-share"] | None = "own-share",
     recapture_form: Literal["inside-out", "proportional"] = "inside-out",
-    prec: int = 5,
-) -> GuidelinesBoundary:
+    dps: int = 5,
+) -> gbfn.GuidelinesBoundary:
     """
     Share combinations for the GUPPI boundaries using various aggregators with
     symmetric merging-firm margins.
@@ -255,7 +251,7 @@ def shrratio_boundary_distance(
     recapture_form
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
-    prec
+    dps
         Number of decimal places for rounding returned shares and area.
 
     Returns
@@ -274,7 +270,7 @@ def shrratio_boundary_distance(
 
     # parameters for iteration
     _weights_base = (mpf("0.5"),) * 2
-    _gbd_step_sz = mp.power(10, -prec)
+    _gbd_step_sz = mp.power(10, -dps)
     _theta = _gbd_step_sz * (10 if weighting == "cross-product-share" else 1)
     for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
         # The wtd. avg. GUPPI is not always convex to the origin, so we
@@ -289,7 +285,7 @@ def shrratio_boundary_distance(
         while True:
             _de_1 = _s_2 / (1 - _s_1)
             _de_2 = (
-                _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
+                _s_1 / (1 - gbfn.lerp(_s_1, _s_2, _r_val))
                 if recapture_form == "inside-out"
                 else _s_1 / (1 - _s_2)
             )
@@ -344,7 +340,7 @@ def shrratio_boundary_distance(
     else:
         _s_2_oddsum -= _s_1_pre
 
-    _s_intcpt = _shrratio_boundary_intcpt(
+    _s_intcpt = gbfn._shrratio_boundary_intcpt(
         _s_1_pre,
         _delta_star,
         _r_val,
@@ -369,11 +365,9 @@ def shrratio_boundary_distance(
         # Area under boundary
         _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, "2")
 
-    _gbdry_points = np.vstack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
-        np.float64
-    )
+    _gbdry_points.append((mpf("0.0"), _s_intcpt))
     # Points defining boundary to point-of-symmetry
-    return GuidelinesBoundary(
-        np.vstack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
-        round(float(_gbdry_area_total), prec),
+    return gbfn.GuidelinesBoundary(
+        np.vstack((_gbdry_points[::-1], np.flip(_gbdry_points[1:], 1))),
+        round(float(_gbdry_area_total), dps),
     )

mergeron/core/pseudorandom_numbers.py

@@ -19,7 +19,7 @@ from .. import VERSION, ArrayDouble  # noqa: TID252
 __version__ = VERSION
 
 NTHREADS = 2 * cpu_count()
-DIST_PARMS_DEFAULT = np.array([0.0, 1.0], np.float64)
+DEFAULT_DIST_PARMS = np.array([0.0, 1.0], np.float64)
 
 
 def prng(_s: SeedSequence | None = None, /) -> np.random.Generator:
@@ -139,7 +139,7 @@ class MultithreadedRNG:
         dist_type: Literal[
             "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
         ] = "Uniform",
-        dist_parms: ArrayDouble | None = DIST_PARMS_DEFAULT,
+        dist_parms: ArrayDouble | None = DEFAULT_DIST_PARMS,
         seed_sequence: SeedSequence | None = None,
         nthreads: int = NTHREADS,
     ):
@@ -166,7 +166,7 @@ class MultithreadedRNG:
 
         self.dist_type = dist_type
 
-        if dist_parms is None or np.array_equal(dist_parms, DIST_PARMS_DEFAULT):
+        if dist_parms is None or np.array_equal(dist_parms, DEFAULT_DIST_PARMS):
             match dist_type:
                 case "Uniform":
                     self.dist_type = "Random"