mergeron 2024.738940.0__py3-none-any.whl → 2024.738949.0__py3-none-any.whl

mergeron/examples/concentration_as_diversion.py

@@ -32,7 +32,7 @@ from numpy import pi
 from xlsxwriter import Workbook
 
 import mergeron.core.excel_helper as xlh
-import mergeron.core.guidelines_standards as gsl
+import mergeron.core.guidelines_boundaries as gbl
 import mergeron.ext.tol_colors as ptcolor
 from mergeron import DATA_DIR
 
@@ -46,20 +46,20 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "ΔHHI boundary",
         "sheet_name": "ΔHHI",
         "func_str": R"\Delta HHI",
-        "func": gsl.delta_hhi_boundary,
+        "func": gbl.delta_hhi_boundary,
     },
     "OSWAG Own-shr-wtd Div Ratio Index": {
         "title_str": "Aggregated-diversion-ratio boundary, own-share wtd. avg.",
         "sheet_name": "OSWAG, wtd avg",
         "func_str": R"(s_1 d_{12} + s_2 d_{21}) / s_M",
-        "func": gsl.shrratio_boundary_wtd_avg,
+        "func": gbl.shrratio_boundary_wtd_avg,
         "func_kwargs": {"wgtng_policy": "own-share", "recapture_spec": RECAPTURE_SPEC},
     },
     "OSWAG Own-shr-wtd Div Ratio Distance": {
         "title_str": "Aggregated-diversion-ratio boundary, own-shr. wtd. distance",
         "sheet_name": "OSWAG, distance",
         "func_str": R"\surd (s_1 d_{12}^2 / s_M + s_2 d_{21}^2 / s_M)",
-        "func": gsl.shrratio_boundary_wtd_avg,
+        "func": gbl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "own-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -70,20 +70,20 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, minimum",
         "sheet_name": "OSWAG, minimum",
         "func_str": R"\min (d_{12}, d_{21})",
-        "func": gsl.shrratio_boundary_min,
+        "func": gbl.shrratio_boundary_min,
         "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
     },
     "SAG Combined Share": {
         "title_str": "Combined Share boundary",
         "sheet_name": "SAG, combined-share",
         "func_str": R"s_M",
-        "func": gsl.combined_share_boundary,
+        "func": gbl.combined_share_boundary,
     },
     "SAG Div Ratio Distance": {
         "title_str": "Aggregated-diversion-ratio boundary, distance",
         "sheet_name": "SAG, distance",
         "func_str": R"\surd (d_{12}^2 / 2 + d_{21}^2 / 2)",
-        "func": gsl.shrratio_boundary_wtd_avg,
+        "func": gbl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": None,
             "recapture_spec": RECAPTURE_SPEC,
@@ -94,20 +94,20 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, simple average",
         "sheet_name": "SAG, average",
         "func_str": R"(d_{12} + d_{21}) / 2",
-        "func": gsl.shrratio_boundary_xact_avg,
+        "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",
         "func_str": R"HHI_M^{pre}",
-        "func": gsl.hhi_pre_contrib_boundary,
+        "func": gbl.hhi_pre_contrib_boundary,
     },
     "CPSWAG Cross-product-shr-wtd Div Ratio Index": {
         "title_str": "Aggregated-diversion-ratio boundary, cross-product-share wtd. avg.",
         "sheet_name": "CPSWAG, wtd avg",
         "func_str": R"(s_2 d_{12} / s_M  + s_1 d_{21} / s_M)",
-        "func": gsl.shrratio_boundary_wtd_avg,
+        "func": gbl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "cross-product-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -117,7 +117,7 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, cross-prod-shr. wtd. distance",
         "sheet_name": "CPSWAG, distance",
         "func_str": R"\surd (s_2 d_{12}^2 / s_M + s_1 d_{21}^2 / s_M)",
-        "func": gsl.shrratio_boundary_wtd_avg,
+        "func": gbl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "cross-product-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -128,7 +128,7 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, maximum",
         "sheet_name": "CPSWAG, maximum",
         "func_str": R"\max (d_{12}, d_{21})",
-        "func": gsl.shrratio_boundary_max,
+        "func": gbl.shrratio_boundary_max,
     },
 }
 
@@ -142,7 +142,7 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
         are drawn
 
     """
-    gso = gsl.GuidelinesStandards(_gpubyr)
+    gso = gbl.GuidelinesThresholds(_gpubyr)
     _dhhi_val, _r_val, _g_val = (
         getattr(gso.presumption, _f) for _f in ("delta", "rec", "guppi")
     )
@@ -200,7 +200,7 @@ def _dhhi_stats(
 
     _delta_val = _s_mid / (1 - _s_mid)
     if _dhhi_val * 1e4 in (50, 100, 200):
-        _delta_val = gsl.round_cust(_r_val * _delta_val) / _r_val
+        _delta_val = gbl.round_cust(_r_val * _delta_val) / _r_val
     _divr_val = _r_val * _delta_val
 
     print(
@@ -225,7 +225,7 @@ def _dhhi_stats(
 def _bdry_stats_col(
     _bdry_spec: str, _dhhi_val: float, _delta_val: float, _r_val: float, /
 ) -> tuple[str, str]:
-    _dhhi_prob = 2 * gsl.dh_area(_dhhi_val)
+    _dhhi_prob = 2 * gbl.dh_area(_dhhi_val)
     _cs_prob = 2 * _dhhi_val
     _hhi_m_pre_prob = pi * _dhhi_val / 2
 
@@ -262,11 +262,11 @@ def plot_and_save_boundary_coords(
     /,
     layout: Literal["collected", "distributed"] = "collected",
 ) -> None:
-    gso = gsl.GuidelinesStandards(_gpubyr)
+    gso = gbl.GuidelinesThresholds(_gpubyr)
 
     _hmg_standards_strings_dict = {
         "distributed": ("presumption", "inferred presumption", "safeharbor"),
-        "collected": ("safeharbor", "inferred_presumption", "presumption"),
+        "collected": ("safeharbor", "imputed_presumption", "presumption"),
     }
     _hmg_standards_strings = _hmg_standards_strings_dict.get(layout, ())
     if not _hmg_standards_strings:
@@ -276,7 +276,7 @@ def plot_and_save_boundary_coords(
         )
 
     # Initialize plot area
-    _plt, _my_fig1, _ax1, _set_axis_def = gsl.boundary_plot()
+    _plt, _my_fig1, _ax1, _set_axis_def = gbl.boundary_plot()
 
     _divr_agg_methods = ("OSWAG", "SAG", "CPSWAG")
 
@@ -284,7 +284,7 @@ def plot_and_save_boundary_coords(
         _divr_agg_methods, _hmg_standards_strings, strict=True
     ):
         _r_bar, _g_bar = (getattr(gso.presumption, _f) for _f in ("rec", "guppi"))
-        _dhhi_val = getattr(gso, _hmg_standards_str)[0]
+        _dhhi_val = getattr(gso, _hmg_standards_str).delta
         _divr_val = (
             _g_bar
             if _hmg_standards_str == "safeharbor"
@@ -352,7 +352,7 @@ def plot_and_save_boundary_coords(
 
 def gen_plot_boundary(
     _bndry_data_dict: Mapping[str, Sequence[tuple[float]]],
-    _gso: gsl.GuidelinesStandards,
+    _gso: gbl.GuidelinesThresholds,
     _gs_str: str,
     _bdry_spec: tuple[str, Mapping[str, Any]],
     _ax1: mpa.Axes,
@@ -366,7 +366,7 @@ def gen_plot_boundary(
     _bndry_data_dict
         mapping for storing boundary coordinates for each plotted boundary
     _gso
-        gsl.GuidelinesStandards instance of tuples listing
+        gbl.GuidelinesStandards instance of tuples listing
         concentration standard, default recapture-rate, GUPPI bound,
         and diversion ratio bound for "safeharbor", "weak presumption",
         and "presumption", where "weak presumption" represents an alternative
@@ -426,17 +426,17 @@ def gen_plot_boundary(
 
     _bdry_func = _bdry_spec_dict["func"]
     if "Div Ratio" in _bdry_spec_str:
-        _bdry_data, _bdry_area = _bdry_func(
+        _bdry_boundary = _bdry_func(
             _delta_val,
             _r_bar,
             **_bdry_spec_dict.get("func_kwargs", {}),  # tupe: ignore
         )
         _plot_label_mag, _plot_label_uom = _r_bar * _delta_val * 1e2, "%"
     elif _bdry_spec_str.endswith("Combined Share"):
-        _bdry_data, _bdry_area = _bdry_func(2 * _s_mid)
+        _bdry_boundary = _bdry_func(2 * _s_mid)
         _plot_label_mag, _plot_label_uom = 2 * _s_mid * 1e2, "%"
     else:
-        _bdry_data, _bdry_area = _bdry_func(_dhhi_val)
+        _bdry_boundary = _bdry_func(_dhhi_val)
         _plot_label_mag, _plot_label_uom = _dhhi_val * 1e4, " points"
 
     _plot_label = R"${0}$ = {1:.{2}f}{3}".format(
@@ -447,9 +447,13 @@ def gen_plot_boundary(
     )
 
     _bndry_data_dict |= {
-        _bdry_spec_str: (_bdry_spec_dict["sheet_name"], _bdry_data, _bdry_area)
+        _bdry_spec_str: (
+            _bdry_spec_dict["sheet_name"],
+            _bdry_boundary.coordinates,
+            _bdry_boundary.area,
+        )
     }  # type: ignore
-    _bdry_s1, _bdry_s2 = zip(*_bdry_data, strict=True)
+    _bdry_s1, _bdry_s2 = zip(*_bdry_boundary.coordinates, strict=True)
 
     _ax1.plot(
         _bdry_s1,

mergeron/examples/{safeharbor_boundaries_for_mergers_with_asymmetric_shares.py → enforcement_boundaries_for_mergers_with_asymmetric_shares.py}

@@ -5,45 +5,44 @@ Draw boundaries for various standards from U.S. Horizontal Merger Guidelines.
 
 from itertools import product as iterprod
 from pathlib import Path
-from typing import Literal
+from typing import Literal, TypedDict
 
 import matplotlib.axis
 from matplotlib import cm as colormgr
 from matplotlib import colormaps
 from matplotlib import colors as mcolors
 from matplotlib.ticker import StrMethodFormatter
-from numpy import (
-    arange,
-    arctan,
-    array,
-    concatenate,
-    insert,
-    rad2deg,
-    round,
-    sqrt,
-    vstack,
-)
-
-import mergeron.core.guidelines_standards as gsl
+from numpy import arange, arctan, array, hsplit, insert, rad2deg, round, sqrt, vstack
+
+import mergeron.core.guidelines_boundaries as gbl
 from mergeron import DATA_DIR
 
 PROG_PATH = Path(__file__)
 
 
+class _CMAPArgs(TypedDict):
+    cmap: mcolors.Colormap
+    norm: mcolors.Normalize
+
+
+_color_kwargs = _CMAPArgs(cmap=colormaps["cividis"], norm=mcolors.Normalize(0, 1.0))
+
+
 def plot_delta_boundaries(
     _guppi_bench_key: str,
-    _print_guppi_max_bndry_envs_flag: bool = False,
-    *,
-    recapture_spec: str = "inside-out",
+    _print_guppi_max_bndry_envs_flag: bool,
+    _recapture_spec: Literal["inside-out", "proportional"],
+    _color_kwargs: _CMAPArgs = _color_kwargs,
+    /,
 ):
-    if recapture_spec not in (_recspecs := ("inside-out", "proportional")):
-        raise ValueError(f"Recapture specification must be one of, {_recspecs!r}")
+    _print_guppi_max_bndry_envs_flag = _print_guppi_max_bndry_envs_flag or False
 
     print("ΔHHI safeharbor boundary")
-    _plt, _my_fig1, _ax1, _ = gsl.boundary_plot()
+    _plt, _my_fig1, _ax1, _ = gbl.boundary_plot()
 
-    _dh_bar, _r_bar, _guppi_bench, _divr_bench, _, _ = get_hmg_standards_by_key(
-        _guppi_bench_key
+    _hmg_thresholds = get_hmg_thresholds_by_key(_guppi_bench_key)
+    _dh_bar, _r_bar, _guppi_bench, _divr_bench = (
+        getattr(_hmg_thresholds, _f) for _f in ("delta", "rec", "guppi", "divr")
     )
 
     print("Contour map of selected ∆HHI boundaries")
@@ -52,8 +51,8 @@ def plot_delta_boundaries(
         if _dh_bound in (300, 500):
             continue
 
-        _dh_safeharb, _dh_prob = gsl.delta_hhi_boundary(_dh_bound / 1e4)
-        _dh_dat_x, _dh_dat_y = zip(*_dh_safeharb, strict=True)
+        _dh_boundary = gbl.delta_hhi_boundary(_dh_bound / 1e4)
+        _dh_dat_x, _dh_dat_y = (_z.T[0] for _z in hsplit(_dh_boundary.coordinates, 2))
         if _dh_bound == 100:
             _lwval, _lsval = 0.75, "-"
         else:
@@ -69,13 +68,13 @@ def plot_delta_boundaries(
         )
 
         if _print_guppi_max_bndry_envs_flag:
-            _symshr = gsl.round_cust(sqrt(_dh_bound / 2e4))
-            _dstar = gsl.round_cust(_symshr / (1 - _symshr))
+            _symshr = gbl.round_cust(sqrt(_dh_bound / 2e4))
+            _dstar = gbl.round_cust(_symshr / (1 - _symshr))
             _m_star = _guppi_bench / (_dstar * _r_bar)
             print(_symshr, _dstar, _m_star, _r_bar, _guppi_bench, "...", end="")
 
             _guppi_bdry_env_xs = (0, _symshr, 1)
-            if recapture_spec == "inside-out":
+            if _recapture_spec == "inside-out":
                 # ## Plot envelope of GUPPI boundaries with
                 #   r_k = r_bar if s_k = min(_s_1, _s_2)
                 # ## See (s_i, s_j) in equation~(44), or thereabouts, in paper
@@ -98,39 +97,35 @@ def plot_delta_boundaries(
                 _guppi_bdry_env_xs[::-1],
                 linewidth=0.5,
                 linestyle="--",
-                color=colormaps["cividis"](_m_star),
+                color=_color_kwargs["cmap"](_m_star),
                 zorder=3,
             )
-            del _symshr, _dstar, _m_star, _guppi_bdry_env_xs
-
-        if _dh_bound not in (200, 300, 500):
-            _ax1.annotate(
-                rf"$\Delta HHI$ = {_dh_bound:,d} pts.",
-                xy=(_dh_dat_x[0], _dh_dat_y[0]),
-                xytext=(_dh_dat_x[0], _dh_dat_y[0]),
-                textcoords="data",
-                ha="left",
-                va="center",
-                fontsize=5,
-                zorder=5.1,
-            )
+            del _symshr, _dstar, _m_star
+
+            if _recapture_spec == "inside-out" and _dh_bound not in (200, 300, 500):
+                _ax1.annotate(
+                    rf"$\Delta HHI$ = {_dh_bound:,d} pts.",
+                    xy=(_dh_dat_x[1], _dh_dat_y[1]),
+                    xytext=(_dh_dat_x[1], _dh_dat_y[1]),
+                    textcoords="data",
+                    ha="left",
+                    va="center",
+                    fontsize=5,
+                    zorder=5.1,
+                )
+            del _guppi_bdry_env_xs
 
         if _dh_bound == 100:
             _ax1.fill_between(
-                (0, *_dh_dat_x, 100),
-                (100, *_dh_dat_y, 0),
+                _dh_dat_x,
+                _dh_dat_y,
                 0,
                 edgecolor=None,
                 facecolor="#64bb64",
                 alpha=0.7,
                 rasterized=True,
             )
-        del (
-            _dh_safeharb,
-            _dh_prob,
-            _dh_dat_x,
-            _dh_dat_y,
-        )  # , _dh_dat_x_pla, _dh_dat_y_pla
+        del (_dh_boundary, _dh_dat_x, _dh_dat_y)  # , _dh_dat_x_pla, _dh_dat_y_pla
 
     _my_fig1.savefig((DATA_DIR / f"{PROG_PATH.stem}_DH100_deltaHHI_only.pdf"), dpi=600)
 
@@ -140,22 +135,23 @@ def plot_delta_boundaries(
 def plot_guppi_boundaries(  # noqa PLR0915
     _guppi_bench_key: str,
     _pcm_same_flag: bool,
-    _recapture_spec: Literal["proportional", "inside-out"] = "inside-out",
+    _recapture_spec: Literal["proportional", "inside-out"],
+    _color_kwargs: _CMAPArgs = _color_kwargs,
+    /,
 ):
     if recapture_spec not in (_recspecs := ("inside-out", "proportional")):
         raise ValueError(f"Recapture specification must be one of, {_recspecs!r}")
 
-    _dh_bar, _r_bar, _guppi_bench, _divr_bench, _, _ = get_hmg_standards_by_key(
-        _guppi_bench_key
+    _hmg_thresholds = get_hmg_thresholds_by_key(_guppi_bench_key)
+    _dh_bar, _r_bar, _guppi_bench, _divr_bench = (
+        getattr(_hmg_thresholds, _f) for _f in ("delta", "rec", "guppi", "divr")
     )
 
     # First we get the data for the ΔHHI benchmark we want to plot
-    _dh_safeharb, _dh_prob = gsl.delta_hhi_boundary(_dh_bar)
-    _dh_dat_x, _dh_dat_y = zip(*_dh_safeharb, strict=True)
+    _dh_boundary = gbl.delta_hhi_boundary(_dh_bar)
+    _dh_dat_x, _dh_dat_y = (_z.T[0] for _z in hsplit(_dh_boundary.coordinates, 2))
 
-    _plt, _my_fig1, _ax1, _set_axis_def = gsl.boundary_plot()
-    _plt.delaxes(_ax1)
-    del _my_fig1, _ax1
+    _plt, _, _, _set_axis_def = gbl.boundary_plot()
 
     _my_fig1 = _plt.figure(figsize=(5.5, 5.0))
 
@@ -168,14 +164,12 @@ def plot_guppi_boundaries(  # noqa PLR0915
         wspace=0.0,
     )
     _ax1 = _my_fig1.add_subplot(_fig1_grid[0, 0])
-    _ax1 = _set_axis_def(_ax1)
-    _ax1.set_aspect(1.0)
-    _ax1.set_facecolor("#F6F6F6")
+    _ax1 = _set_axis_def(_ax1, mktshares_plot_flag=True, mktshares_axlbls_flag=True)
 
     _ax1.plot(_dh_dat_x, _dh_dat_y, linewidth=0.75, color="black", zorder=3)
     _ax1.fill_between(
-        (0, *_dh_dat_x, 100),
-        (100, *_dh_dat_y, 0),
+        _dh_dat_x,
+        _dh_dat_y,
         0,
         edgecolor=None,
         facecolor="#64bb64",
@@ -188,6 +182,8 @@ def plot_guppi_boundaries(  # noqa PLR0915
     _m_lim = _guppi_bench / _r_bar
     _mst_vec = arange(_m_lim, 1.00 + _step_size, _step_size)
     _sym_shr_vec = (_dst_vec := _m_lim / _mst_vec) / (1 + _dst_vec)
+    # _sym_shr_vec = np.arange(gbl.shr_from_gbd(g_bar), 0.5 + step_size, step_size)
+    # _mst_vec = (g_bar / r_bar) * (1 - sym_shr_vec) / sym_shr_vec
     # https://stackoverflow.com/questions/39753282/
     _ax1.scatter(
         _sym_shr_vec,
@@ -197,12 +193,12 @@ def plot_guppi_boundaries(  # noqa PLR0915
         s=(0.25 * 72.0 / _my_fig1.dpi) ** 2,
         edgecolor=None,
         c=_mst_vec,
-        **cmap_kwargs,
+        **_color_kwargs,
         rasterized=True,
         zorder=3,
     )
 
-    for _m_star in concatenate((arange(1.00, _m_lim, -0.10), (_m_lim,))):
+    for _m_star in arange(1.00, _m_lim - 0.10, -0.10):
         _m_star, _delta_star, _s_mid = (
             round(_s, 4)
             for _s in (_m_star, _m_lim / _m_star, _m_lim / (_m_star + _m_lim))
@@ -216,7 +212,7 @@ def plot_guppi_boundaries(  # noqa PLR0915
                 _s2_vals,
                 linestyle="--",
                 linewidth=0.75,
-                color=colormaps["cividis"](_m_star),
+                color=_color_kwargs["cmap"](_m_star),
                 zorder=3,
             )
         else:
@@ -316,23 +312,21 @@ def plot_guppi_boundaries(  # noqa PLR0915
     #  print("Diversion ratio bound")
     if _divr_bench < _r_bar:
         _m_star_bench = _guppi_bench / _divr_bench
-        _s_mid_bench = gsl.shr_from_gbd(
+        _s_mid_bench = gbl.shr_from_gbd(
             _guppi_bench, m_star=_m_star_bench, r_bar=_r_bar
         )
-        _delta_star = gsl.critical_shrratio(
+        _delta_star = gbl.critical_shrratio(
             _guppi_bench, m_star=_m_star_bench, r_bar=_r_bar
         )
-        (guppi_boundary_data, guppi_boundary_area) = gsl.shrratio_boundary_max(
-            _delta_star
-        )
-        _x_drt, _y_drt = zip(*guppi_boundary_data, strict=True)
+        guppi_boundary = gbl.shrratio_boundary_max(_delta_star)
+        _x_drt, _y_drt = zip(*guppi_boundary.coordinates, strict=True)
 
         _ax1.plot(
             _x_drt,
             _y_drt,
             linestyle="-",
             linewidth=0.75,
-            color=colormaps["cividis"](_m_star_bench),
+            color=_color_kwargs["cmap"](_m_star_bench),
             zorder=4,
         )
 
@@ -381,7 +375,7 @@ def plot_guppi_boundaries(  # noqa PLR0915
         xerr=_ebar_array,
         yerr=_ebar_array,
         fmt=".",
-        mfc=colormaps["cividis"](_guppi_bench / _r_bar),
+        mfc=_color_kwargs["cmap"](_guppi_bench / _r_bar),
         mec="None",
         alpha=0.9,
         zorder=5,
@@ -390,7 +384,7 @@ def plot_guppi_boundaries(  # noqa PLR0915
     # https://stackoverflow.com/questions/22995797/
     for _ix in range(2):
         _ebar_plot[-1][_ix].set(
-            color=colormaps["cividis"](_guppi_bench / _r_bar),
+            color=_color_kwargs["cmap"](_guppi_bench / _r_bar),
             linestyle="--",
             linewidth=0.5,
             alpha=0.9,
@@ -410,7 +404,7 @@ def plot_guppi_boundaries(  # noqa PLR0915
     ax1_cb = _my_fig1.add_subplot(_fig1_grid[0, 1], frameon=False)
     ax1_cb.axis("off")
     _cm_plot = _my_fig1.colorbar(
-        colormgr.ScalarMappable(**cmap_kwargs),
+        colormgr.ScalarMappable(**_color_kwargs),
         use_gridspec=True,
         ax=ax1_cb,
         orientation="vertical",
@@ -447,20 +441,21 @@ def grad_est(_ax: matplotlib.axis.Axis, _pt_xs: tuple, _pt_ys: tuple) -> float:
     return (_pt2[1] - _pt1[1]) / (_pt2[0] - _pt1[0])
 
 
-def get_hmg_standards_by_key(_guppi_bench_key: str, /) -> tuple:
+def get_hmg_thresholds_by_key(_guppi_bench_key: str, /) -> gbl.HMGThresholds:
     match _guppi_bench_key:
         case "DOJATR":
-            return (
-                *(_tmp := gsl.GuidelinesStandards(2010).safeharbor[:2]),
+            return gbl.HMGThresholds(
+                (_tmp := gbl.GuidelinesThresholds(2010).safeharbor).delta,
+                _tmp.rec,
                 0.05,
-                _tmp[-1],
-                None,
-                None,
+                _tmp.divr,
+                _tmp.cmcr,
+                _tmp.ipr,
             )
         case "DH100":
-            return gsl.GuidelinesStandards(2010).safeharbor
+            return gbl.GuidelinesThresholds(2010).safeharbor
         case "DH50":
-            return gsl.GuidelinesStandards(1992).safeharbor
+            return gbl.GuidelinesThresholds(1992).safeharbor
         case _:
             raise ValueError(
                 f"GUPPI benchmark key must be one of, {guppi_benchmark_keys!r}"
@@ -470,17 +465,14 @@ def get_hmg_standards_by_key(_guppi_bench_key: str, /) -> tuple:
 if __name__ == "__main__":
     print("Define parameters for GUPPI safeharbor plots")
 
-    _pcm_colornorm = mcolors.Normalize(0, 1.0)
-    cmap_kwargs = {"cmap": "cividis", "norm": _pcm_colornorm}
-
     guppi_benchmark_keys = ("DH50", "DH100", "DOJATR")
 
     print("Plot countour-maps of ∆HHI boundaries and GUPPI safeharbor boundaries")
 
-    plot_delta_boundaries("DH100", True, recapture_spec="inside-out")
+    pcm_same_flag: bool = True
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out"
+    plot_delta_boundaries("DH100", pcm_same_flag, recapture_spec, _color_kwargs)
 
-    pcm_same_flag: bool
-    recapture_spec: Literal["inside-out", "proportional"]
     print("GUPPI safeharbor boundaries, by precentage price-cost margin")
     for pcm_same_flag, recapture_spec in iterprod(
         (False, True), ("inside-out", "proportional")
@@ -490,4 +482,6 @@ if __name__ == "__main__":
 
         print(f"Symmetric margins: {pcm_same_flag!r}; recapture: '{recapture_spec}'")
         for guppi_bench_key in guppi_benchmark_keys:
-            plot_guppi_boundaries(guppi_bench_key, pcm_same_flag, recapture_spec)
+            plot_guppi_boundaries(
+                guppi_bench_key, pcm_same_flag, recapture_spec, _color_kwargs
+            )

mergeron/examples/{safeharbor_boundaries_for_symmetric_firm_mergers.py → enforcement_boundaries_for_symmetric_firm_mergers.py}

@@ -12,14 +12,14 @@ from matplotlib import cm as colormgr
 from matplotlib import colors as mcolors
 from matplotlib.ticker import AutoMinorLocator, MultipleLocator, StrMethodFormatter
 
-import mergeron.core.guidelines_standards as gsl
+import mergeron.core.guidelines_boundaries as gbl
 from mergeron import DATA_DIR
 
 PROG_PATH = Path(__file__)
 
 
 def _main() -> None:
-    plt, _, _, set_axis_def = gsl.boundary_plot()
+    plt, _, _, set_axis_def = gbl.boundary_plot()
     # plt.delaxes(ax1)
     # del my_fig1, ax1
     # del ax1
@@ -45,7 +45,7 @@ def _main() -> None:
     g_bar, r_bar, dr_bar = 0.06, 0.80, 0.20
 
     step_size = 10**-5
-    sym_shr_vec = np.arange(gsl.shr_from_gbd(g_bar), 0.5 + step_size, step_size)
+    sym_shr_vec = np.arange(gbl.shr_from_gbd(g_bar), 0.5 + step_size, step_size)
     mst_vec = (g_bar / r_bar) * (1 - sym_shr_vec) / sym_shr_vec
 
     print("Setup basic figure and axes for plots of safe harbor boundaries.")

mergeron/examples/guidelines_enforcement_patterns.py

@@ -1,19 +1,22 @@
 from __future__ import annotations
 
-from numpy import array, column_stack
+import numpy as np
 
 import mergeron.core.proportions_tests as pcl
 
-enf_counts = array((
-    (24, 25, 33, 33),
-    (30, 33, 27, 32),
-    (14, 15, 9, 11),
-    (13, 22, 6, 11),
-    (6, 8, 7, 9),
-    (1, 3, 2, 4),
-    (1, 3, 2, 4),
-    (1e-15, 1e-15, 1, 1),
-))
+enf_counts = np.array(
+    (
+        (24, 25, 33, 33),
+        (30, 33, 27, 32),
+        (14, 15, 9, 11),
+        (13, 22, 6, 11),
+        (6, 8, 7, 9),
+        (1, 3, 2, 4),
+        (1, 3, 2, 4),
+        (1e-15, 1e-15, 1, 1),
+    ),
+    np.int16,
+)
 
 if __name__ == "__main__":
     adj_n = len(enf_counts)
@@ -37,13 +40,12 @@ if __name__ == "__main__":
                 count, ic_1996_2003.sum(), alpha=0.05 / adj_n, method="Wilson"
             )[2:]
         )
-    del count
 
     print("Conf. intervals for relative frequency of II Requests (Goodman, 1965)")
     for goodman_alternative in "default", "simplified":
         for goodman_method in "goodman", "quesenberry-hurst":
             print(f"Method, {goodman_method!r}; alternative, {goodman_alternative!r}")
-            for _cis in column_stack([
+            for _cis in np.column_stack([
                 pcl.propn_ci_multinomial(
                     enf_counts[:, _cidx],
                     method=goodman_method,
@@ -56,11 +58,11 @@ if __name__ == "__main__":
 
     print()
     print("Conf. intervals for differences in proportions enforced (Goodman, 1964)")
-    print(repr(pcl.propn_ci_diff_multinomial(enf_counts[:, [1, 3]])))
+    print(repr(pcl.propn_diff_ci_multinomial(enf_counts[:, [1, 3]])))
 
     print()
     print("Goodman's chi-squared test for homogeneity of enforcement patterns")
-    print(repr(pcl.propn_diff_multinomial_chisq(enf_counts[:, [1, 3]])))
+    print(repr(pcl.propn_test_multinomial(enf_counts[:, [1, 3]])))
 
     print()
     print(
@@ -68,5 +70,5 @@ if __name__ == "__main__":
         "(Bonnferoni-adjusted Newcombe C.I.s)",
     )
     for counts in enf_counts:
-        print(pcl.propn_diff_ci(*counts, alpha=0.05 / adj_n, method="Newcombe")[2:])
+        print(pcl.propn_diff_ci(*counts, alpha=0.05 / adj_n, method="Newcombe"))
     print()