mergeron 2024.738949.1__py3-none-any.whl → 2024.738949.5__py3-none-any.whl

mergeron/core/guidelines_boundaries.py

@@ -5,6 +5,7 @@ with a canvas on which to draw boundaries for Guidelines standards.
 """
 
 import decimal
+from collections.abc import Callable
 from dataclasses import dataclass
 from importlib.metadata import version
 from typing import Any, Literal, TypeAlias
@@ -14,6 +15,7 @@ from attrs import define, field
 from mpmath import mp, mpf  # type: ignore
 from numpy.typing import NDArray
 from scipy.spatial.distance import minkowski as distance_function
+from sympy import lambdify, simplify, solve, symbols
 
 from .. import _PKG_NAME  # noqa: TID252
 
@@ -32,6 +34,13 @@ class GuidelinesBoundary:
     area: float
 
 
+@dataclass(slots=True, frozen=True)
+class GuidelinesBoundaryCallable:
+    boundary_function: Callable[[NDArray[np.float64]], NDArray[np.float64]]
+    area: float
+    s_naught: float = 0
+
+
 @define(slots=True, frozen=True)
 class HMGThresholds:
     delta: float
@@ -278,7 +287,12 @@ def gbd_from_dsf(
 
 
 def critical_shrratio(
-    _gbd: float = 0.06, /, *, m_star: float = 1.00, r_bar: float = 0.80
+    _gbd: float = 0.06,
+    /,
+    *,
+    m_star: float = 1.00,
+    r_bar: float = 0.80,
+    frac: float = 1e-16,
 ) -> mpf:
     """
     Corollary to GUPPI bound.
@@ -298,7 +312,7 @@ def critical_shrratio(
         for given margin and recapture rate.
 
     """
-    return mpf(f"{_gbd}") / mp.fmul(f"{m_star}", f"{r_bar}")
+    return round_cust(mpf(f"{_gbd}") / mp.fmul(f"{m_star}", f"{r_bar}"), frac=frac)
 
 
 def shr_from_gbd(
@@ -371,18 +385,18 @@ def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
             r"\setsansfont{Fira Sans Light}",
             R"\setmonofont[Scale=MatchLowercase,]{Fira Mono}",
             R"\defaultfontfeatures[\rmfamily]{",
-            R"	Ligatures={TeX, Common},",
-            R"	Numbers={Proportional, Lining},",
-            R"	}",
+            R"  Ligatures={TeX, Common},",
+            R"  Numbers={Proportional, Lining},",
+            R"  }",
             R"\defaultfontfeatures[\sffamily]{",
-            R"	Ligatures={TeX, Common},",
-            R"	Numbers={Monospaced, Lining},",
-            R"	LetterSpace=0.50,",
-            R"	}",
+            R"  Ligatures={TeX, Common},",
+            R"  Numbers={Monospaced, Lining},",
+            R"  LetterSpace=0.50,",
+            R"  }",
             R"\usepackage[",
-            R"	activate={true, nocompatibility},",
-            R"	tracking=true,",
-            R"	]{microtype}",
+            R"  activate={true, nocompatibility},",
+            R"  tracking=true,",
+            R"  ]{microtype}",
         ]),
     })
 
@@ -589,19 +603,16 @@ def delta_hhi_boundary(
     _s1_zero = 1 / 2 * (1 - mp.sqrt(1 - 2 * _dh_val))
     _s1_one = 1 - _s1_zero
 
-    _s_mid = mp.sqrt(_dh_val / 2)
-
     _dh_step_sz = mp.power(10, -6)
-    _s_1 = np.array(mp.arange(_s_mid, _s1_zero, -_dh_step_sz))
+    _s_1 = np.array(mp.arange(_s1_zero, _s1_one + _dh_step_sz, _dh_step_sz))
     _s_2 = _dh_val / (2 * _s_1)
 
     # Boundary points
-    _dh_half = np.row_stack((
-        np.column_stack((_s_1, _s_2)),
-        np.array([(_s1_zero, _s1_one)]),
+    _dh_bdry_pts = np.row_stack((
         np.array([(mpf("0.0"), mpf("1.0"))]),
+        np.column_stack((_s_1, _s_2)),
+        np.array([(mpf("1.0"), mpf("0.0"))]),
     ))
-    _dh_bdry_pts = np.row_stack((np.flip(_dh_half, 0), np.flip(_dh_half[1:], 1)))
 
     _s_1_pts, _s_2_pts = np.split(_dh_bdry_pts, 2, axis=1)
     return GuidelinesBoundary(
@@ -613,6 +624,42 @@ def delta_hhi_boundary(
     )
 
 
+def delta_hhi_boundary_qdtr(_dh_val: float = 0.01) -> GuidelinesBoundaryCallable:
+    """
+    Generate the list of share combination on the ΔHHI boundary.
+
+    Parameters
+    ----------
+    _dh_val:
+        Merging-firms' ΔHHI bound.
+    dh_dps
+        Number of decimal places for rounding reported shares.
+
+    Returns
+    -------
+        Callable to generate array of share-pairs, area under boundary.
+
+    """
+
+    _dh_val = mpf(f"{_dh_val}")
+
+    _s_1, _s_2 = symbols("s_1, s_2", positive=True)
+
+    _hhi_eqn = _s_2 - 0.01 / (2 * _s_1)
+
+    _hhi_bdry = solve(_hhi_eqn, _s_2)[0]
+    _s_nought = float(solve(_hhi_eqn.subs({_s_2: 1 - _s_1}), _s_1)[0])
+
+    _hhi_bdry_area = 2 * (
+        _s_nought
+        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))
+    )
+
+    return GuidelinesBoundaryCallable(
+        lambdify(_s_1, _hhi_bdry, "numpy"), _hhi_bdry_area, _s_nought
+    )
+
+
 def combined_share_boundary(
     _s_intcpt: float = 0.0625, /, *, bdry_dps: int = 10
 ) -> GuidelinesBoundary:
@@ -801,6 +848,130 @@ def shrratio_boundary_min(
     )
 
 
+def shrratio_boundary_qdtr_wtd_avg(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+) -> GuidelinesBoundaryCallable:
+    """
+    Share combinations for the share-weighted average GUPPI boundary with symmetric
+    merging-firm margins.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    wgtng_policy
+        Whether "own-share" or "cross-product-share" (or None for simple, unweighted average)
+    recapture_spec
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    if _delta_star > 1:
+        raise ValueError(
+            "Margin-adjusted benchmark share ratio, `_delta_star` cannot exceed 1."
+        )
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+    _s_naught = 0
+
+    _s_1, _s_2 = symbols("s_1:3", positive=True)
+
+    match wgtng_policy:
+        case "own-share":
+            _bdry_eqn = (
+                _s_1 * _s_2 / (1 - _s_1)
+                + _s_2
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - (_s_1 + _s_2) * _delta_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[0]
+            _s_naught = (
+                float(solve(simplify(_bdry_eqn.subs({_s_2: 1 - _s_1})), _s_1)[0])
+                if recapture_spec == "inside-out"
+                else 0
+            )
+            _bdry_area = float(
+                2
+                * (
+                    _s_naught
+                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))
+                )
+                - (_s_mid**2 + _s_naught**2)
+            )
+
+        case "cross-product-share":
+            mp.trap_complex = False
+            _d_star = symbols("d", positive=True)
+            _bdry_eqn = (
+                _s_2 * _s_2 / (1 - _s_1)
+                + _s_1
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - (_s_1 + _s_2) * _d_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[1]
+            _bdry_area = float(
+                2
+                * (
+                    mp.quad(
+                        lambdify(
+                            _s_1, _bdry_func.subs({_d_star: _delta_star}), "mpmath"
+                        ),
+                        (0, _s_mid),
+                    )
+                ).real
+                - _s_mid**2
+            )
+
+        case _:
+            _bdry_eqn = (
+                1 / 2 * _s_2 / (1 - _s_1)
+                + 1
+                / 2
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - _delta_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[0]
+            _bdry_area = float(
+                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))
+                - _s_mid**2
+            )
+
+    return GuidelinesBoundaryCallable(
+        lambdify(_s_1, _bdry_func, "numpy"), _bdry_area, _s_naught
+    )
+
+
 def shrratio_boundary_wtd_avg(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
@@ -815,16 +986,36 @@ def shrratio_boundary_wtd_avg(
     Share combinations for the share-weighted average GUPPI boundary with symmetric
     merging-firm margins.
 
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    avg_method
+        Whether "arithmetic", "geometric", or "distance".
+    wgtng_policy
+        Whether "own-share" or "cross-product-share"  (or None for simple, unweighted average).
+    recapture_spec
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+    gbd_dps
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
     Notes
     -----
     An analytical expression for the share-weighted arithmetic mean boundary
     is derived and plotted from y-intercept to the ray of symmetry as follows::
 
         from sympy import plot as symplot, solve, symbols
-        s_1, s_2, delta_star = symbols("s_1 s_2 \\delta^*")
+        s_1, s_2 = symbols("s_1 s_2", positive=True)
 
         g_val, r_val, m_val = 0.06, 0.80, 0.30
-        d_hat = g_val / (r_val * m_val)
+        delta_star = g_val / (r_val * m_val)
 
         # recapture_spec == "inside-out"
         oswag = solve(
@@ -834,7 +1025,7 @@ def shrratio_boundary_wtd_avg(
             s_2
         )[0]
         symplot(
-            oswag.subs({delta_star: d_hat}),
+            oswag,
             (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
@@ -846,7 +1037,7 @@ def shrratio_boundary_wtd_avg(
             s_2
         )[1]
         symplot(
-            cpwag.subs({delta_star: d_hat}),
+            cpwag,
             (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
@@ -859,7 +1050,7 @@ def shrratio_boundary_wtd_avg(
              s_2
         )[0]
         symplot(
-            oswag.subs({delta_star: d_hat}),
+            oswag,
             (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
@@ -871,30 +1062,11 @@ def shrratio_boundary_wtd_avg(
              s_2
         )[1]
         symplot(
-            cpswag.subs({delta_star: d_hat}),
+            cpswag,
             (s_1, 0.0, d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
-    Parameters
-    ----------
-    _delta_star
-        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
-    _r_val
-        recapture ratio
-    avg_method
-        Whether "arithmetic", "geometric", or "distance".
-    wgtng_policy
-        Whether "own-share" or "cross-product-share".
-    recapture_spec
-        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
-        value for both merging firms ("proportional").
-    gbd_dps
-        Number of decimal places for rounding returned shares and area.
-
-    Returns
-    -------
-        Array of share-pairs, area under boundary.
 
     """
 
@@ -921,7 +1093,7 @@ def shrratio_boundary_wtd_avg(
         _s_2 = _s_2_pre * (1 + _theta)
 
         if (_s_1 + _s_2) > mpf("0.99875"):
-            # 1: # We lose accuracy at 3-9s and up
+            # Loss of accuracy at 3-9s and up
             break
 
         while True:
@@ -948,10 +1120,11 @@ def shrratio_boundary_wtd_avg(
                 case _:
                     _delta_test = lerp(_de_1, _de_2, _r)
 
-            if wgtng_policy == "cross-product-share":
-                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
-            else:
-                _test_flag, _incr_decr = (_delta_test < _delta_star, 1)
+            _test_flag, _incr_decr = (
+                (_delta_test > _delta_star, -1)
+                if wgtng_policy == "cross-product-share"
+                else (_delta_test < _delta_star, 1)
+            )
 
             if _test_flag:
                 _s_2 += _incr_decr * _gbd_step_sz
@@ -970,31 +1143,41 @@ def shrratio_boundary_wtd_avg(
         _s_2_pre = _s_2
         _s_1_pre = _s_1
 
-    _gbd_prtlarea = _gbd_step_sz * (
-        (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _delta_star) / 3
-        if wgtng_policy == "cross-product-share"
-        else (
-            (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
-            + _s_1_pre * (1 + _s_2_pre) / 2
-        )
+    if _s_2_oddval:
+        _s_2_evnsum -= _s_2_pre
+    else:
+        _s_2_oddsum -= _s_1_pre
+
+    _s_intcpt = _shrratio_boundary_intcpt(
+        _s_1_pre,
+        _delta_star,
+        _r_val,
+        recapture_spec=recapture_spec,
+        avg_method=avg_method,
+        wgtng_policy=wgtng_policy,
     )
 
-    # Area under boundary
-    _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
+    if wgtng_policy == "own-share":
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
+        )
+        # Area under boundary
+        _gbdry_area_total = float(
+            2 * (_s_1_pre + _gbd_prtlarea)
+            - (mp.power(_s_mid, "2") + mp.power(_s_1_pre, "2"))
+        )
 
-    match wgtng_policy:
-        case "cross-product-share":
-            _s_intcpt = _delta_star
-        case "own-product-share":
-            _s_intcpt = mpf("1.0")
-        case None if avg_method == "distance":
-            _s_intcpt = _delta_star * mp.sqrt("2")
-        case _:
-            _s_intcpt = _s_2_pre
+    else:
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_intcpt) / 3
+        )
+        # Area under boundary
+        _gbdry_area_total = float(2 * _gbd_prtlarea - mp.power(_s_mid, "2"))
 
     _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
         np.float64
     )
+
     # Points defining boundary to point-of-symmetry
     return GuidelinesBoundary(
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
@@ -1281,10 +1464,10 @@ def shrratio_boundary_avg(
     _s_intcpt = _s_2
 
     _gbd_prtlarea = 2 * _gbd_step_sz * (
-        mp.fmul(4 / 3, _s_2_oddsum)
-        + mp.fmul(2 / 3, _s_2_evnsum)
-        + mp.fmul(1 / 3, _s_mid + _s_intcpt)
-    ) - mp.power(_s_mid, 2)
+        mp.fmul(4, _s_2_oddsum)
+        + mp.fmul(2, _s_2_evnsum)
+        + mp.fmul(1, _s_mid + _s_intcpt)
+    ) / 3 - mp.power(_s_mid, 2)
 
     _gbdry_points = np.array(_gbdry_points, np.float64)
     return GuidelinesBoundary(
@@ -1310,8 +1493,8 @@ def shrratio_boundary_distance(
     Reimplements the arithmetic-averages and distance estimations from function,
     `shrratio_boundary_wtd_avg`but uses the Minkowski-distance function,
     `scipy.spatial.distance.minkowski` for all aggregators. This reimplementation
-    is primarifly useful for testing the output of `shrratio_boundary_wtd_avg`
-    as it tests considerably slower.
+    is useful for testing the output of `shrratio_boundary_wtd_avg`
+    but runs considerably slower.
 
     Parameters
     ----------
@@ -1392,10 +1575,11 @@ def shrratio_boundary_distance(
                         (_de_1, _de_2), (0.0, 0.0), p=2, w=_weights_i
                     )
 
-            if wgtng_policy == "cross-product-share":
-                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
-            else:
-                _test_flag, _incr_decr = (_delta_test < _delta_star, 1)
+            _test_flag, _incr_decr = (
+                (_delta_test > _delta_star, -1)
+                if wgtng_policy == "cross-product-share"
+                else (_delta_test < _delta_star, 1)
+            )
 
             if _test_flag:
                 _s_2 += _incr_decr * _gbd_step_sz
@@ -1414,22 +1598,60 @@ def shrratio_boundary_distance(
         _s_2_pre = _s_2
         _s_1_pre = _s_1
 
-    _gbd_prtlarea = _gbd_step_sz * (
-        (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _delta_star) / 3
-        if wgtng_policy == "cross-product-share"
-        else (
-            (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
-            + _s_1_pre * (1 + _s_2_pre) / 2
+    if _s_2_oddval:
+        _s_2_evnsum -= _s_2_pre
+    else:
+        _s_2_oddsum -= _s_1_pre
+
+    _s_intcpt = _shrratio_boundary_intcpt(
+        _s_1_pre,
+        _delta_star,
+        _r_val,
+        recapture_spec=recapture_spec,
+        avg_method=avg_method,
+        wgtng_policy=wgtng_policy,
+    )
+
+    if wgtng_policy == "own-share":
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
         )
+        # Area under boundary
+        _gbdry_area_total = 2 * (_s_1_pre + _gbd_prtlarea) - (
+            mp.power(_s_mid, "2") + mp.power(_s_1_pre, "2")
+        )
+
+    else:
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_intcpt) / 3
+        )
+        # Area under boundary
+        _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, "2")
+
+    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
+        np.float64
+    )
+    # Points defining boundary to point-of-symmetry
+    return GuidelinesBoundary(
+        np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
+        round(float(_gbdry_area_total), gbd_dps),
     )
 
-    # Area under boundary
-    _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
 
+def _shrratio_boundary_intcpt(
+    _s_2_pre: float,
+    _delta_star: mpf,
+    _r_val: mpf,
+    /,
+    *,
+    recapture_spec: Literal["inside-out", "proportional"],
+    avg_method: Literal["arithmetic", "geometric", "distance"],
+    wgtng_policy: Literal["cross-product-share", "own-share"] | None,
+) -> float:
     match wgtng_policy:
         case "cross-product-share":
             _s_intcpt = _delta_star
-        case "own-product-share":
+        case "own-share":
             _s_intcpt = mpf("1.0")
         case None if avg_method == "distance":
             _s_intcpt = _delta_star * mp.sqrt("2")
@@ -1445,11 +1667,4 @@ def shrratio_boundary_distance(
         case _:
             _s_intcpt = _s_2_pre
 
-    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
-        np.float64
-    )
-    # Points defining boundary to point-of-symmetry
-    return GuidelinesBoundary(
-        np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
-        round(float(_gbdry_area_total), gbd_dps),
-    )
+    return _s_intcpt

mergeron/examples/concentration_as_diversion.py

@@ -27,14 +27,15 @@ from pathlib import Path
 from typing import Any, Literal
 
 import matplotlib.axes as mpa
-from joblib import Parallel, cpu_count, delayed
-from numpy import pi
-from xlsxwriter import Workbook
-
 import mergeron.core.excel_helper as xlh
 import mergeron.core.guidelines_boundaries as gbl
 import mergeron.ext.tol_colors as ptcolor
+import mergeron.gen.investigations_stats as isl
+from jinja2 import FileSystemLoader
+from joblib import Parallel, cpu_count, delayed
 from mergeron import DATA_DIR
+from numpy import pi
+from xlsxwriter import Workbook
 
 PROG_PATH = Path(__file__)
 
@@ -79,6 +80,13 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "func_str": R"s_M",
         "func": gbl.combined_share_boundary,
     },
+    "SAG Average Div Ratio": {
+        "title_str": "Aggregated-diversion-ratio boundary, simple average",
+        "sheet_name": "SAG, average",
+        "func_str": R"(d_{12} + d_{21}) / 2",
+        "func": gbl.shrratio_boundary_wtd_avg,
+        "func_kwargs": {"wgtng_policy": None, "recapture_spec": RECAPTURE_SPEC},
+    },
     "SAG Div Ratio Distance": {
         "title_str": "Aggregated-diversion-ratio boundary, distance",
         "sheet_name": "SAG, distance",
@@ -90,13 +98,6 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
             "avg_method": "distance",
         },
     },
-    "SAG Average Div Ratio": {
-        "title_str": "Aggregated-diversion-ratio boundary, simple average",
-        "sheet_name": "SAG, average",
-        "func_str": R"(d_{12} + d_{21}) / 2",
-        "func": gbl.shrratio_boundary_xact_avg,
-        "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
-    },
     "CPSWAG Premerger HHI-contribution": {
         "title_str": "Premerger HHI-contribution boundary",
         "sheet_name": "CPSWAG, HHI-contrib-pre",
@@ -133,7 +134,7 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
 }
 
 
-def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
+def tabulate_boundary_stats(_gpubyr: gbl.HMGPubYear, /) -> None:
     """
     Parameters
     ----------
@@ -142,15 +143,17 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
         are drawn
 
     """
+    _invres_rate_table_content = isl.StatsContainer()
+
     gso = gbl.GuidelinesThresholds(_gpubyr)
     _dhhi_val, _r_val, _g_val = (
         getattr(gso.presumption, _f) for _f in ("delta", "rec", "guppi")
     )
 
     _dhhi_seq = (
-        (0.01, 0.02, 0.03125, 0.05, _dhhi_val)
+        (0.005, 0.01, 0.02, gso.imputed_presumption.delta, 0.08)
         if _gpubyr == 2010
-        else (0.005, 0.01, 0.02, 0.03125, _dhhi_val)
+        else (0.005, 0.01, 0.02, gso.imputed_presumption.delta, 0.08)
     )
 
     _bdry_approx_data_dict = {
@@ -166,7 +169,7 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
                 ),
             )
             for _k in BDRY_SPECS_DICT
-            if not _k.endswith("Distance")
+            # if not _k.endswith("Distance")
         }
     }
     _bdry_approx_data_dict |= {
@@ -176,32 +179,46 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
     }
 
     _bdry_data = Parallel(n_jobs=-1)(
-        delayed(_dhhi_stats)(_dhhi_val, _r_val, _g_val) for _dhhi_val in _dhhi_seq
+        delayed(_dhhi_stats)(_dhhi_val, _r_val) for _dhhi_val in _dhhi_seq
     )
     _bdry_approx_data_dict |= dict(_bdry_data)
 
-    print(" & ".join(_k for _k in _bdry_approx_data_dict), R" \\")
+    _data_str = ""
+    _data_str = "{} \\\\ \n".format(
+        " & ".join(
+            _k.replace("Criterion", R"{\text{} \\ Criterion}")  # \phantom{Criterion}
+            for _k in _bdry_approx_data_dict
+        )
+    )
     for _sk in _bdry_approx_data_dict["Criterion"]:
-        print(
-            " & ".join(
-                _bdry_approx_data_dict[_k][_sk] for _k in _bdry_approx_data_dict
-            ),
-            R"\\",
+        _data_str += "{} \\\\ \n".format(
+            " & ".join(_bdry_approx_data_dict[_k][_sk] for _k in _bdry_approx_data_dict)
         )
+    print(_data_str)
+
+    _invres_rate_table_content.data_str = _data_str
+
+    _j2_env = isl.latex_jinja_env
+    _j2_env.loader = FileSystemLoader(str(PROG_PATH.parent / "templates"))
+    _j2_templ = _j2_env.get_template(
+        "concentration_as_diversion_intrinsic_enforcement_rates.tex.jinja2"
+    )
+    PROG_PATH.parents[1].joinpath(
+        f"{PROG_PATH.stem}_intrinsic_enforcement_rates_{_gpubyr}.tex"
+    ).write_text(_j2_templ.render(tmpl_data=_invres_rate_table_content))
 
 
-def _dhhi_stats(
-    _dhhi_val: float, _r_val: float, _g_val: float
-) -> tuple[str, dict[str, str]]:
+def _dhhi_stats(_dhhi_val: float, _r_val: float) -> tuple[str, dict[str, str]]:
     _dhhi_val = round(_dhhi_val, 5)
 
-    _r_val = round(_r_val, 4)
-    _s_mid = sqrt(_dhhi_val / 2)
+    _divr_val = gbl.gbd_from_dsf(_dhhi_val, r_bar=_r_val)
+    _delta_val = gbl.critical_shrratio(_divr_val, r_bar=_r_val)
+    # _s_mid = sqrt(_dhhi_val / 2)
 
-    _delta_val = _s_mid / (1 - _s_mid)
-    if _dhhi_val * 1e4 in (50, 100, 200):
-        _delta_val = gbl.round_cust(_r_val * _delta_val) / _r_val
-    _divr_val = _r_val * _delta_val
+    # _delta_val = _s_mid / (1 - _s_mid)
+    # if _dhhi_val * 1e4 in (50, 100, 200):
+    #     _delta_val = gbl.critical_shrratio()(_r_val * _delta_val) / _r_val
+    # _divr_val = _r_val * _delta_val
 
     print(
         "Processing data for ΔHHI = {0:.{1}f} points;".format(
@@ -238,15 +255,16 @@ def _bdry_stats_col(
             return _bdry_spec, f"{_hhi_m_pre_prob:6.5f}"
         case _ if "Div Ratio" in _bdry_spec:
             _gbd_func = BDRY_SPECS_DICT[_bdry_spec]["func"]
-            _, _within_bdry_area = _gbd_func(
+            _within_bdry_area = _gbd_func(
                 _delta_val, _r_val, **BDRY_SPECS_DICT[_bdry_spec].get("func_kwargs", {})
-            )
+            ).area
             _within_bdry_prob = 2 * _within_bdry_area
-            _within_conc_bdry_prob = (
-                _hhi_m_pre_prob
-                if _bdry_spec.startswith("CPSWAG")
-                else (_cs_prob if _bdry_spec.startswith("SAG") else _dhhi_prob)
-            )
+            if _bdry_spec.startswith("CPSWAG"):
+                _within_conc_bdry_prob = _hhi_m_pre_prob
+            elif _bdry_spec.startswith("SAG"):
+                _within_conc_bdry_prob = _cs_prob
+            else:
+                _within_conc_bdry_prob = _dhhi_prob
 
             return _bdry_spec, R"{{ {:6.5f} \\ {:.2f}\% }}".format(
                 _within_bdry_prob,
@@ -257,7 +275,7 @@ def _bdry_stats_col(
 
 
 def plot_and_save_boundary_coords(
-    _gpubyr: Literal[1992, 2010, 2023],
+    _gpubyr: gbl.HMGPubYear,
     _xl_book: Workbook,
     /,
     layout: Literal["collected", "distributed"] = "collected",
@@ -599,8 +617,9 @@ def boundary_data_to_worksheet(
 
 
 if __name__ == "__main__":
-    for gpubyr in [1992, 2010, 2023][2:]:
-        # tabulate_boundary_stats(gpubyr)
+    gpubyrs: list[gbl.HMGPubYear] = [1992, 2010, 2023]
+    for gpubyr in gpubyrs[2:][:1]:
+        tabulate_boundary_stats(gpubyr)
 
         # Initiliaze workbook for saving boundary coordinates
         with Workbook(

{mergeron-2024.738949.1.dist-info → mergeron-2024.738949.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mergeron
-Version: 2024.738949.1
+Version: 2024.738949.5
 Summary: Analysis of standards defined in Horizontal Merger Guidelines
 License: MIT
 Keywords: merger policy analysis,merger guidelines,merger screening,policy presumptions,concentration standards,upward pricing pressure,GUPPI

{mergeron-2024.738949.1.dist-info → mergeron-2024.738949.5.dist-info}/RECORD

@@ -5,11 +5,11 @@ mergeron/core/__init__.py,sha256=iyfxkX3-SoMS4ZQZKHKPn8JEMN536vpty9oSZf0LHv8,115
 mergeron/core/damodaran_margin_data.py,sha256=DHTQdFjuZ5Yl3Dbq0db0QR4FHUqJpZj4yi5zdUncLtg,8166
 mergeron/core/excel_helper.py,sha256=wU3Y325r_YNfoyr92y605m_9ZCDJ01WiR-vahi4KGmc,8094
 mergeron/core/ftc_merger_investigations_data.py,sha256=YYkgeF-b_2_Tk8dsy_4dMz5QpV5UQEr7tB9ORiqKmww,26760
-mergeron/core/guidelines_boundaries.py,sha256=wAoX5Es83g87jXAw1s65C8xrKwzLxwa81aP-N3LdgKk,44733
+mergeron/core/guidelines_boundaries.py,sha256=E38g6aonHqqFiSP0Duh_UfUGaHkZlKQt-23Q7EAEtBA,50541
 mergeron/core/proportions_tests.py,sha256=tCrbya1el5u1OFOXphODP6yWOGywuNY6z9LBTsNRKzM,15320
 mergeron/core/pseudorandom_numbers.py,sha256=mSAMJ1zZ58k8j9duT3Ohi_1TCjZaFG1Ud1P_JI1ryYY,9430
 mergeron/examples/__init__.py,sha256=iyfxkX3-SoMS4ZQZKHKPn8JEMN536vpty9oSZf0LHv8,115
-mergeron/examples/concentration_as_diversion.py,sha256=p9-VzqC8Tb3fMJD1mLnqmMnvOCrCTULjIPCEG0RhASQ,20645
+mergeron/examples/concentration_as_diversion.py,sha256=oDo5InVGLL-pON_ror8XWOMwC6S2dnDvei7Yw_AXgFw,21620
 mergeron/examples/enforcement_boundaries_for_mergers_with_asymmetric_shares.py,sha256=-jOHETKp788pqKTv7U25t28UzVtJNMmUn1FVH7jCiCU,16020
 mergeron/examples/enforcement_boundaries_for_symmetric_firm_mergers.py,sha256=DAljm5NJquE56f-x4pLXzKCdhYQyVpWaM8uGlD6rIEs,5779
 mergeron/examples/example_parameterizations.py,sha256=VP-hi7L0j30ffcEzmJ3P8mOj1VjwEWKCTZSx_CaVQxA,4197
@@ -37,6 +37,6 @@ mergeron/jinja_LaTex_templates/mergeron.cls,sha256=AV2mk4-uERvAuMkE95Ka7el6LZsb0
 mergeron/jinja_LaTex_templates/mergeron_table_collection_template.tex.jinja2,sha256=nr6xUI0_2KHG4Sz9k1JFVQjs2h9qS9BGt1MeE6Tygs8,2429
 mergeron/jinja_LaTex_templates/setup_tikz_tables.tex.jinja2,sha256=WKVxtp3eoMchfGliQAJMj4w2FtBkWG5z2V3-hBYUYUQ,3292
 mergeron/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-mergeron-2024.738949.1.dist-info/METADATA,sha256=JMtJF46he9UZoHGhQaGjWHEgFXP3y1jEprH4C5gxvoc,6362
-mergeron-2024.738949.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-mergeron-2024.738949.1.dist-info/RECORD,,
+mergeron-2024.738949.5.dist-info/METADATA,sha256=v_U_sf-0kwTsgcg3SpLqUv5X9iaTHBOVhuMAt4N7xb0,6362
+mergeron-2024.738949.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mergeron-2024.738949.5.dist-info/RECORD,,