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

mergeron/core/guidelines_boundaries_specialized_functions.py

@@ -0,0 +1,341 @@
+"""
+Specialized routines for defining and analyzing boundaries for Guidelines standards.
+
+These routines provide improved precision or demonstrate additional methods, but tend
+to have poor performance
+
+"""
+
+from importlib.metadata import version
+from typing import Literal
+
+import numpy as np
+from mpmath import mp, mpf  # type: ignore
+from scipy.spatial.distance import minkowski as distance_function  # type: ignore
+from sympy import lambdify, simplify, solve, symbols
+
+from .. import _PKG_NAME  # noqa: TID252
+from .guidelines_boundaries import (
+    GuidelinesBoundary,
+    GuidelinesBoundaryCallable,
+    _shrratio_boundary_intcpt,
+    lerp,
+)
+
+__version__ = version(_PKG_NAME)
+
+
+mp.prec = 80
+mp.trap_complex = True
+
+
+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.
+    prec
+        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]  # type: ignore
+    _s_nought = float(solve(_hhi_eqn.subs({_s_2: 1 - _s_1}), _s_1)[0])  # type: ignore
+
+    _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 shrratio_boundary_qdtr_wtd_avg(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    weighting: 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
+    weighting
+        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.
+
+    """
+
+    _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 weighting:
+        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]  # type: ignore
+            _s_naught = (
+                float(solve(simplify(_bdry_eqn.subs({_s_2: 1 - _s_1})), _s_1)[0])  # type: ignore
+                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]  # type: ignore
+            _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]  # type: ignore
+            _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_distance(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    agg_method: Literal["arithmetic", "distance"] = "arithmetic",
+    weighting: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+    prec: int = 5,
+) -> GuidelinesBoundary:
+    """
+    Share combinations for the GUPPI boundaries using various aggregators with
+    symmetric merging-firm margins.
+
+    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 useful for testing the output of `shrratio_boundary_wtd_avg`
+    but runs considerably slower.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    agg_method
+        Whether "arithmetic", "geometric", or "distance".
+    weighting
+        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").
+    prec
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+
+    # initial conditions
+    _gbdry_points = [(_s_mid, _s_mid)]
+    _s_1_pre, _s_2_pre = _s_mid, _s_mid
+    _s_2_oddval, _s_2_oddsum, _s_2_evnsum = True, 0, 0
+
+    # parameters for iteration
+    _weights_base = (mpf("0.5"),) * 2
+    _gbd_step_sz = mp.power(10, -prec)
+    _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
+        #   increment _s_2 after each iteration in which our algorithm
+        #   finds (s1, s2) on the boundary
+        _s_2 = _s_2_pre * (1 + _theta)
+
+        if (_s_1 + _s_2) > mpf("0.99875"):
+            # 1: # We lose accuracy at 3-9s and up
+            break
+
+        while True:
+            _de_1 = _s_2 / (1 - _s_1)
+            _de_2 = (
+                _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
+                if recapture_spec == "inside-out"
+                else _s_1 / (1 - _s_2)
+            )
+
+            _weights_i = (
+                (
+                    _w1 := mp.fdiv(
+                        _s_2 if weighting == "cross-product-share" else _s_1,
+                        _s_1 + _s_2,
+                    ),
+                    1 - _w1,
+                )
+                if weighting
+                else _weights_base
+            )
+
+            match agg_method:
+                case "arithmetic":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=1, w=_weights_i
+                    )
+                case "distance":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=2, w=_weights_i
+                    )
+
+            _test_flag, _incr_decr = (
+                (_delta_test > _delta_star, -1)
+                if weighting == "cross-product-share"
+                else (_delta_test < _delta_star, 1)
+            )
+
+            if _test_flag:
+                _s_2 += _incr_decr * _gbd_step_sz
+            else:
+                break
+
+        # Build-up boundary points
+        _gbdry_points.append((_s_1, _s_2))
+
+        # Build up area terms
+        _s_2_oddsum += _s_2 if _s_2_oddval else 0
+        _s_2_evnsum += _s_2 if not _s_2_oddval else 0
+        _s_2_oddval = not _s_2_oddval
+
+        # Hold share points
+        _s_2_pre = _s_2
+        _s_1_pre = _s_1
+
+    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,
+        agg_method=agg_method,
+        weighting=weighting,
+    )
+
+    if weighting == "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), prec),
+    )

mergeron/core/pseudorandom_numbers.py

@@ -145,7 +145,7 @@ class MultithreadedRNG:
         dist_type: Literal[
             "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
         ] = "Uniform",
-        dist_parms: NDArray[np.floating[TF]] | None = DIST_PARMS_DEFAULT,
+        dist_parms: NDArray[np.floating[TF]] | None = DIST_PARMS_DEFAULT,  # type: ignore
         seed_sequence: SeedSequence | None = None,
         nthreads: int = NTHREADS,
     ):

mergeron/examples/concentration_as_diversion.py

@@ -27,19 +27,21 @@ from pathlib import Path
 from typing import Any, Literal
 
 import matplotlib.axes as mpa
+from jinja2 import FileSystemLoader
+from joblib import Parallel, cpu_count, delayed  # type: ignore
+from numpy import pi
+from xlsxwriter import Workbook  # type: ignore
+
 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
+from mergeron import DATA_DIR, RECConstants, UPPAggrSelector
+from mergeron.core import UPPBoundarySpec
 
 PROG_PATH = Path(__file__)
 
-RECAPTURE_SPEC = "inside-out"
+RECAPTURE_SPEC = RECConstants.INOUT
 # Map boundary forms to titles and generating-function names, with
 #   additional parameters as relevant
 BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
@@ -53,26 +55,22 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {"wgtng_policy": "own-share", "recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.OSA,
+        "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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "own-share",
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
+        "agg_method": UPPAggrSelector.OSD,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "OSWAG Min Div Ratio": {
         "title_str": "Aggregated-diversion-ratio boundary, minimum",
         "sheet_name": "OSWAG, minimum",
         "func_str": R"\min (d_{12}, d_{21})",
-        "func": gbl.shrratio_boundary_min,
-        "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.MIN,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "SAG Combined Share": {
         "title_str": "Combined Share boundary",
@@ -84,19 +82,15 @@ 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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {"wgtng_policy": None, "recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.AVG,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": None,
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
+        "agg_method": UPPAggrSelector.DIS,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Premerger HHI-contribution": {
         "title_str": "Premerger HHI-contribution boundary",
@@ -108,28 +102,22 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "cross-product-share",
-            "recapture_spec": RECAPTURE_SPEC,
-        },
+        "agg_method": UPPAggrSelector.CPA,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Cross-product-shr-wtd Div Ratio Distance": {
         "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": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "cross-product-share",
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
+        "agg_method": UPPAggrSelector.CPD,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Max Div Ratio": {
         "title_str": "Aggregated-diversion-ratio boundary, maximum",
         "sheet_name": "CPSWAG, maximum",
         "func_str": R"\max (d_{12}, d_{21})",
-        "func": gbl.shrratio_boundary_max,
+        "agg_method": UPPAggrSelector.MAX,
+        "recapture_spec": RECAPTURE_SPEC,
     },
 }
 
@@ -254,9 +242,13 @@ def _bdry_stats_col(
         case "CPSWAG Premerger HHI-contribution":
             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(
-                _delta_val, _r_val, **BDRY_SPECS_DICT[_bdry_spec].get("func_kwargs", {})
+            _within_bdry_area = gbl.shrratio_boundary(
+                UPPBoundarySpec(
+                    _delta_val,
+                    _r_val,
+                    agg_method=BDRY_SPECS_DICT[_bdry_spec]["agg_method"],
+                    recapture_spec=BDRY_SPECS_DICT[_bdry_spec]["recapture_spec"],
+                )
             ).area
             _within_bdry_prob = 2 * _within_bdry_area
             if _bdry_spec.startswith("CPSWAG"):
@@ -266,7 +258,7 @@ def _bdry_stats_col(
             else:
                 _within_conc_bdry_prob = _dhhi_prob
 
-            return _bdry_spec, R"{{ {:6.5f} \\ {:.2f}\% }}".format(
+            return _bdry_spec, R"{{ {:6.5f} \\ {:.2f}\% }}".format(  # noqa: UP032
                 _within_bdry_prob,
                 100 * (1 - (_within_conc_bdry_prob / _within_bdry_prob)),
             )
@@ -408,10 +400,11 @@ def gen_plot_boundary(
     print(_bdry_spec_dict["title_str"])
 
     _pt_mdco: ptcolor.Mcset = ptcolor.tol_cset("medium-contrast")  # type: ignore
+    _pt_vbco: ptcolor.Vcset = ptcolor.tol_cset("vibrant")  # type: ignore
 
     _plot_line_width = 1.0
     _plot_line_alpha = 0.8
-    _plot_line_color = _pt_mdco.black
+    _plot_line_color = _pt_vbco.black
     _plot_line_style = {"OSWAG": "-", "SAG": "-.", "CPSWAG": "--"}.get(
         _bdry_spec_str.split(" ")[0], "-"
     )
@@ -425,15 +418,14 @@ def gen_plot_boundary(
             case _ if _bdry_spec_str.startswith(("SAG Combined", "CPSWAG Premerger")):
                 _zrdr = 2
             case _ if "Distance" in _bdry_spec_str:
-                _plot_line_color = _pt_mdco.light_blue
+                _plot_line_color = _pt_vbco.blue
                 _zrdr = 3
             case _ if "shr-wtd" in _bdry_spec_str or "Mean" in _bdry_spec_str:
-                _plot_line_color = _pt_mdco.light_yellow
+                _plot_line_color = _pt_vbco.teal
                 _zrdr = 3
             case _:
-                _plot_line_color = _pt_mdco.dark_red
+                _plot_line_color = _pt_vbco.red
 
-    _dh_bar = _gso.safeharbor.divr
     _g_val = _gso.safeharbor.guppi
 
     _r_bar = _gso.presumption.rec
@@ -442,12 +434,15 @@ def gen_plot_boundary(
     _s_mid = sqrt(_dhhi_val / 2)
     _delta_val = _g_val / _r_bar if _gs_str == "safeharbor" else _s_mid / (1 - _s_mid)
 
-    _bdry_func = _bdry_spec_dict["func"]
+    _bdry_func = _bdry_spec_dict.get("func", gbl.shrratio_boundary)
     if "Div Ratio" in _bdry_spec_str:
-        _bdry_boundary = _bdry_func(
-            _delta_val,
-            _r_bar,
-            **_bdry_spec_dict.get("func_kwargs", {}),  # tupe: ignore
+        _bdry_boundary = gbl.shrratio_boundary(
+            UPPBoundarySpec(
+                _delta_val,
+                _r_bar,
+                agg_method=_bdry_spec_dict["agg_method"],
+                recapture_spec=_bdry_spec_dict["recapture_spec"],
+            )
         )
         _plot_label_mag, _plot_label_uom = _r_bar * _delta_val * 1e2, "%"
     elif _bdry_spec_str.endswith("Combined Share"):

mergeron/examples/enforcement_boundaries_for_mergers_with_asymmetric_shares.py

@@ -15,7 +15,8 @@ from matplotlib.ticker import StrMethodFormatter
 from numpy import arange, arctan, array, hsplit, insert, rad2deg, round, sqrt, vstack
 
 import mergeron.core.guidelines_boundaries as gbl
-from mergeron import DATA_DIR
+from mergeron import DATA_DIR, UPPAggrSelector
+from mergeron.core import UPPBoundarySpec
 
 PROG_PATH = Path(__file__)
 
@@ -34,7 +35,7 @@ def plot_delta_boundaries(
     _recapture_spec: Literal["inside-out", "proportional"],
     _color_kwargs: _CMAPArgs = _color_kwargs,
     /,
-):
+) -> None:
     _print_guppi_max_bndry_envs_flag = _print_guppi_max_bndry_envs_flag or False
 
     print("ΔHHI safeharbor boundary")
@@ -81,7 +82,7 @@ def plot_delta_boundaries(
                 _smin_nr = _dstar * (1 - _r_bar)
                 _smax_nr = 1 - _dstar * _r_bar
                 _guppi_bdry_env_dr = _smin_nr + _smax_nr
-                _guppi_bdry_env_xs = (
+                _guppi_bdry_env_xs = (  # type: ignore
                     0,
                     _smin_nr / _guppi_bdry_env_dr,
                     _symshr,
@@ -138,7 +139,7 @@ def plot_guppi_boundaries(  # noqa PLR0915
     _recapture_spec: Literal["proportional", "inside-out"],
     _color_kwargs: _CMAPArgs = _color_kwargs,
     /,
-):
+) -> None:
     if recapture_spec not in (_recspecs := ("inside-out", "proportional")):
         raise ValueError(f"Recapture specification must be one of, {_recspecs!r}")
 
@@ -318,7 +319,9 @@ def plot_guppi_boundaries(  # noqa PLR0915
         _delta_star = gbl.critical_shrratio(
             _guppi_bench, m_star=_m_star_bench, r_bar=_r_bar
         )
-        guppi_boundary = gbl.shrratio_boundary_max(_delta_star)
+        guppi_boundary = gbl.shrratio_boundary(
+            UPPBoundarySpec(_delta_star, _r_bar, agg_method=UPPAggrSelector.MAX)
+        )
         _x_drt, _y_drt = zip(*guppi_boundary.coordinates, strict=True)
 
         _ax1.plot(
@@ -429,7 +432,9 @@ def plot_guppi_boundaries(  # noqa PLR0915
     del _dh_dat_x, _dh_dat_y
 
 
-def grad_est(_ax: matplotlib.axis.Axis, _pt_xs: tuple, _pt_ys: tuple) -> float:
+def grad_est(
+    _ax: matplotlib.axis.Axis, _pt_xs: tuple[float, ...], _pt_ys: tuple[float, ...]
+) -> float:
     if (_pt_len := max(len(_pt_xs), len(_pt_ys))) > 2:
         raise ValueError(
             "Expecting only 2 points for calculation of line-gradient; got {_pt_len}."
@@ -438,7 +443,8 @@ def grad_est(_ax: matplotlib.axis.Axis, _pt_xs: tuple, _pt_ys: tuple) -> float:
         _ax.transData.transform_point((_pt_xs[_i], _pt_ys[_i]))  # type: ignore
         for _i in range(2)
     )
-    return (_pt2[1] - _pt1[1]) / (_pt2[0] - _pt1[0])
+    _grad: float = (_pt2[1] - _pt1[1]) / (_pt2[0] - _pt1[0])
+    return _grad
 
 
 def get_hmg_thresholds_by_key(_guppi_bench_key: str, /) -> gbl.HMGThresholds: