mergeron 2025.739290.6__py3-none-any.whl → 2025.739290.9__py3-none-any.whl

mergeron/core/guidelines_boundary_functions_extra.py

@@ -17,6 +17,7 @@ from scipy.spatial.distance import minkowski as distance_function  # type: ignor
 from sympy import lambdify, simplify, solve, symbols  # type: ignore
 
 from .. import DEFAULT_REC_RATIO, VERSION, ArrayDouble  # noqa: TID252
+from . import GuidelinesBoundary, MPFloat
 from . import guidelines_boundary_functions as gbf
 
 __version__ = VERSION
@@ -505,7 +506,7 @@ def shrratio_boundary_xact_avg_mp(  # noqa: PLR0914
             )
         )
 
-    bdry_inner = np.column_stack((_s_1, s_2))
+    bdry_inner = np.stack((_s_1, s_2), axis=1)
     bdry_end = np.array([(mpf("0.0"), s_intcpt)])
 
     bdry = np.vstack((
@@ -529,3 +530,209 @@ def shrratio_boundary_xact_avg_mp(  # noqa: PLR0914
     ) - mp.power(_s_mid, 2)
 
     return gbf.GuidelinesBoundary(bdry, float(mp.nstr(bdry_area_simpson, dps)))
+
+
+# shrratio_boundary_wtd_avg_autoroot
+# this function is about half as fast as the manual one! ... and a touch less precise
+def _shrratio_boundary_wtd_avg_autoroot(  # noqa: PLR0914
+    _delta_star: float = 0.075,
+    _r_val: float = DEFAULT_REC_RATIO,
+    /,
+    *,
+    agg_method: Literal[
+        "arithmetic mean", "geometric mean", "distance"
+    ] = "arithmetic mean",
+    weighting: Literal["own-share", "cross-product-share", None] = "own-share",
+    recapture_form: Literal["inside-out", "proportional"] = "inside-out",
+    dps: int = 5,
+) -> GuidelinesBoundary:
+    """
+    Share combinations on the share-weighted average diversion ratio boundary.
+
+    Parameters
+    ----------
+    _delta_star
+        Share ratio (:math:`\\overline{d} / \\overline{r}`)
+    _r_val
+        recapture ratio
+    agg_method
+        Whether "arithmetic mean", "geometric mean", or "distance".
+    weighting
+        Whether "own-share" or "cross-product-share"  (or None for simple, unweighted average).
+    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 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 = symbols("s_1 s_2", positive=True)
+
+        g_val, r_val, m_val = 0.06, 0.80, 0.30
+        delta_star = g_val / (r_val * m_val)
+
+        # recapture_form == "inside-out"
+        oswag = solve(
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
+            s_2
+        )[0]
+        symplot(
+            oswag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+        cpswag = solve(
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
+            s_2
+        )[1]
+        symplot(
+            cpwag,
+            (s_1, 0.0, d_hat / (1 + d_hat)), ylabel=s_2
+        )
+
+        # recapture_form == "proportional"
+        oswag = solve(
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
+             s_2
+        )[0]
+        symplot(
+            oswag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+        cpswag = solve(
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
+             s_2
+        )[1]
+        symplot(
+            cpswag,
+            (s_1, 0.0, d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+
+    """
+
+    _delta_star, _r_val = (mpf(f"{_v}") for _v in (_delta_star, _r_val))
+    _s_mid = mp.fdiv(_delta_star, 1 + _delta_star)
+
+    # initial conditions
+    bdry = [(_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, 0.0
+
+    # parameters for iteration
+    _step_size = mp.power(10, -dps)
+    theta_ = _step_size * (10 if weighting == "cross-product-share" else 1)
+    for s_1 in mp.arange(_s_mid - _step_size, 0, -_step_size):
+
+        def delta_test(x: MPFloat) -> MPFloat:
+            _de_1 = x / (1 - s_1)
+            _de_2 = (
+                s_1 / (1 - gbf.lerp(s_1, x, _r_val))
+                if recapture_form == "inside-out"
+                else s_1 / (1 - x)
+            )
+            _w = (
+                mp.fdiv(s_1 if weighting == "cross-product-share" else x, s_1 + x)
+                if weighting
+                else 0.5
+            )
+
+            match agg_method:
+                case "geometric mean":
+                    delta_test = mp.expm1(
+                        gbf.lerp(mp.log1p(_de_1), mp.log1p(_de_2), _w)
+                    )
+                case "distance":
+                    delta_test = mp.sqrt(gbf.lerp(_de_1**2, _de_2**2, _w))
+                case _:
+                    delta_test = gbf.lerp(_de_1, _de_2, _w)
+
+            return _delta_star - delta_test
+
+        try:
+            s_2 = mp.findroot(
+                delta_test,
+                x0=(s_2_pre * (1 - theta_), s_2_pre * (1 + theta_)),
+                tol=mp.sqrt(_step_size),
+                solver="ridder",
+            )
+        except (mp.ComplexResult, ValueError, ZeroDivisionError) as _e:
+            print(s_1, s_2_pre)
+            raise _e
+
+        # Build-up boundary points
+        bdry.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_1_pre + s_2_pre) > mpf("0.99875"):
+            # Loss of accuracy at 3-9s and up
+            break
+
+    if s_2_oddval:
+        s_2_evnsum -= s_2_pre
+    else:
+        s_2_oddsum -= s_1_pre
+
+    _s_intcpt = gbf._shrratio_boundary_intcpt(
+        s_2_pre,
+        _delta_star,
+        _r_val,
+        recapture_form=recapture_form,
+        agg_method=agg_method,
+        weighting=weighting,
+    )
+
+    if weighting == "own-share":
+        gbd_prtlarea = (
+            _step_size * (4 * s_2_oddsum + 2 * s_2_evnsum + _s_mid + s_2_pre) / 3
+        )
+        # Area under boundary
+        bdry_area_total = float(
+            2 * (s_1_pre + gbd_prtlarea)
+            - (mp.power(_s_mid, "2") + mp.power(s_1_pre, "2"))
+        )
+
+    else:
+        gbd_prtlarea = (
+            _step_size * (4 * s_2_oddsum + 2 * s_2_evnsum + _s_mid + _s_intcpt) / 3
+        )
+        # Area under boundary
+        bdry_area_total = float(2 * gbd_prtlarea - mp.power(_s_mid, "2"))
+
+    bdry.append((mpf("0.0"), _s_intcpt))
+    bdry_array = np.array(bdry, float)
+
+    # Points defining boundary to point-of-symmetry
+    return GuidelinesBoundary(
+        np.vstack((bdry_array[::-1], bdry_array[1:, ::-1]), dtype=float),
+        round(float(bdry_area_total), dps),
+    )

mergeron/data/__init__.py

@@ -12,10 +12,9 @@ from .. import _PKG_NAME, VERSION  # noqa: TID252
 
 __version__ = VERSION
 
+data_resources = resources.files(f"{_PKG_NAME}.data")
 
-DAMODARAN_MARGIN_WORKBOOK = resources.files(f"{_PKG_NAME}.data").joinpath(
-    "damodaran_margin_data.xls"
-)
+DAMODARAN_MARGIN_WORKBOOK = data_resources / "damodaran_margin_data.xls"
 """
 Python object pointing to included copy of Prof. Damodaran's margin data
 
@@ -36,9 +35,7 @@ Use as, for example:
     shutil.copy2(DAMODARAN_MARGIN_WORKBOOK, Path.home() / f"{DAMODARAN_MARGIN_WORKBOOK.name}")
 """
 
-FTC_MERGER_INVESTIGATIONS_DATA = resources.files(f"{_PKG_NAME}.data").joinpath(
-    "ftc_merger_investigations_data.zip"
-)
+FTC_MERGER_INVESTIGATIONS_DATA = data_resources / "ftc_merger_investigations_data.zip"
 """
 FTC merger investigtions data published in 2004, 2007, 2008, and 2013
 
@@ -46,7 +43,7 @@ NOTES
 -----
 Raw data tables published by the FTC are loaded into a nested distionary, organized by
 data period, table type, and table number. Each table is stored as a numerical array
-(:module:`numpy` arrray), with additonal attrubutes for the industry group and additonal
+(:mod:`numpy` arrray), with additonal attrubutes for the industry group and additonal
 evidence noted in the source data.
 
 Data for additonal data periods (time spans) not reported in the  source data,

mergeron/gen/__init__.py

@@ -13,7 +13,7 @@ from operator import attrgetter
 
 import h5py  # type: ignore
 import numpy as np
-from attrs import Attribute, Converter, cmp_using, field, frozen, validators
+from attrs import Attribute, Converter, cmp_using, field, frozen
 from numpy.random import SeedSequence
 
 from .. import (  # noqa: TID252
@@ -588,45 +588,39 @@ class INVResolution(str, Enameled):
 class UPPTestRegime:
     """Configuration for UPP tests."""
 
-    resolution: INVResolution = field(
-        kw_only=False,
-        default=INVResolution.ENFT,
-        validator=validators.in_([INVResolution.CLRN, INVResolution.ENFT]),
-    )
-    """Whether to test clearance, enforcement, or both."""
-
-    guppi_aggregator: UPPAggrSelector = field(
-        kw_only=False, default=UPPAggrSelector.MIN
-    )
-    """Aggregator for GUPPI test."""
-
-    divr_aggregator: UPPAggrSelector = field(kw_only=False, default=UPPAggrSelector.MIN)
-    """Aggregator for diversion ratio test."""
-
+    resolution: INVResolution = field(kw_only=False, default=INVResolution.ENFT)
+    """Whether to test clearance, enforcement."""
 
-@frozen
-class UPPTestsRaw:
-    """Container for arrays marking test failures and successes
-
-    A test success is a draw ("market") that meeets the
-    specified test criterion, and a test failure is
-    one that does not; test criteria are evaluated in
-    :func:`enforcement_stats.gen_upp_arrays`.
-    """
+    @resolution.validator
+    def _resvdtr(
+        _i: UPPTestRegime, _a: Attribute[INVResolution], _v: INVResolution
+    ) -> None:
+        if _v == INVResolution.BOTH:
+            raise ValueError(
+                "GUPPI test cannot be performed with both resolutions; only useful for reporting"
+            )
+        elif _v not in {INVResolution.CLRN, INVResolution.ENFT}:
+            raise ValueError(
+                f"Must be one of, {INVResolution.CLRN!r} or {INVResolution.ENFT!r}"
+            )
 
-    guppi_test_simple: ArrayBoolean
-    """True if GUPPI estimate meets criterion"""
+    guppi_aggregator: UPPAggrSelector = field(kw_only=False)
+    """Aggregator for GUPPI test."""
 
-    guppi_test_compound: ArrayBoolean
-    """True if both GUPPI estimate and diversion ratio estimate
-    meet criterion
-    """
+    @guppi_aggregator.default
+    def __gad(_i: UPPTestRegime) -> UPPAggrSelector:
+        return (
+            UPPAggrSelector.MIN
+            if _i.resolution == INVResolution.ENFT
+            else UPPAggrSelector.MAX
+        )
 
-    cmcr_test: ArrayBoolean
-    """True if CMCR estimate meets criterion"""
+    divr_aggregator: UPPAggrSelector = field(kw_only=False)
+    """Aggregator for diversion ratio test."""
 
-    ipr_test: ArrayBoolean
-    """True if IPR (partial price-simulation) estimate meets criterion"""
+    @divr_aggregator.default
+    def __dad(_i: UPPTestRegime) -> UPPAggrSelector:
+        return _i.guppi_aggregator
 
 
 @frozen

mergeron/gen/data_generation.py

@@ -27,6 +27,7 @@ from ..core import guidelines_boundaries as gbl  # noqa: TID252
 from ..core.guidelines_boundaries import HMGThresholds  # noqa: TID252
 from . import (
     FM2Constraint,
+    INVResolution,  # noqa: F401
     MarketSampleData,
     PCMDistribution,
     PCMSpec,
@@ -396,7 +397,7 @@ class MarketSample:
             for _k in ("by_firm_count", "by_delta", "by_conczone")
         ])
         upp_test_results = UPPTestsCounts(*[
-            np.column_stack((
+            np.hstack((
                 (_gv := getattr(res_list_stacks, _g.name))[0, :, :_h],
                 np.einsum("ijk->jk", _gv[:, :, _h:], dtype=np.int64),
             ))
@@ -453,15 +454,6 @@ class MarketSample:
                 )
 
             if not _ndt:
-                # byte_stream = io.BytesIO()
-                # with h5py.File(byte_stream, "w") as h5f:
-                #     for _a in self.dataset.__attrs_attrs__:
-                #         if all((
-                #             (_arr := getattr(self.dataset, _a.name)).any(),
-                #             not np.isnan(_arr).all(),
-                #         )):
-                #             h5f.create_dataset(_a.name, data=_arr, fletcher32=True)
-
                 with (zpath / f"{name_root}_dataset.h5").open("wb") as _hfh:
                     _hfh.write(self.dataset.to_h5bin())
 
@@ -490,10 +482,7 @@ class MarketSample:
             if _dt:
                 with _dp.open("rb") as _hfh:
                     object.__setattr__(  # noqa: PLC2801
-                        market_sample_,
-                        "dataset",
-                        # MarketSampleData(**{_a: h5f[_a][:] for _a in h5f}),
-                        MarketSampleData.from_h5f(_hfh),
+                        market_sample_, "dataset", MarketSampleData.from_h5f(_hfh)
                     )
             if _et:
                 object.__setattr__(  # noqa: PLC2801

mergeron/gen/data_generation_functions.py

@@ -722,7 +722,7 @@ def _gen_margin_data(
         del beta_min, beta_max
 
     if dist_firm2_pcm == FM2Constraint.SYM:
-        pcm_array = np.column_stack((pcm_array,) * _frmshr_array.shape[1])
+        pcm_array = np.hstack((pcm_array,) * _frmshr_array.shape[1])
     if dist_firm2_pcm == FM2Constraint.MNL:
         # Impose FOCs from profit-maximization with MNL demand
         if dist_type_pcm == PCMDistribution.EMPR:

mergeron/gen/enforcement_stats.py

@@ -7,7 +7,7 @@ import enum
 from collections.abc import Mapping
 
 import numpy as np
-from scipy.interpolate import interp1d  # type: ignore
+from scipy.interpolate import make_interp_spline  # type: ignore
 
 from .. import VERSION, ArrayBIGINT, Enameled, this_yaml  # noqa: TID252
 from ..core import ftc_merger_investigations_data as fid  # noqa: TID252
@@ -77,7 +77,7 @@ HHI_DELTA_KNOTS = np.array(
 )
 HHI_POST_ZONE_KNOTS = np.array([0, 1800, 2400, 10001], dtype=np.int64)
 hhi_delta_ranger, hhi_zone_post_ranger = (
-    interp1d(_f / 1e4, _f, kind="previous", assume_sorted=True)
+    make_interp_spline(_f / 1e4, _f, k=0)
     for _f in (HHI_DELTA_KNOTS, HHI_POST_ZONE_KNOTS)
 )
 
@@ -193,7 +193,7 @@ def enf_cnts_obs_byfirmcount(
         case INVResolution.BOTH:
             stats_kept_indxs = [-1, -3, -2]
 
-    return np.column_stack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
+    return np.hstack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
 
 
 def enf_cnts_obs_byhhianddelta(
@@ -226,7 +226,7 @@ def enf_cnts_obs_byhhianddelta(
         case INVResolution.BOTH:
             stats_kept_indxs = [-1, -3, -2]
 
-    return np.column_stack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
+    return np.hstack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
 
 
 def table_no_lku(
@@ -256,11 +256,16 @@ def table_no_lku(
 
 
 def enf_cnts_byfirmcount(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
+    if not _cnts_array[:, 0].any():
+        return np.array([], int)
+
     ndim_in = 1
     return np.vstack([
         np.concatenate([
             (_i,),
-            np.einsum("ij->j", _cnts_array[_cnts_array[:, 0] == _i][:, ndim_in:]),
+            np.einsum(
+                "ij->j", _cnts_array[_cnts_array[:, 0] == _i][:, ndim_in:], dtype=int
+            ),
         ])
         for _i in np.unique(_cnts_array[:, 0])
     ])
@@ -271,14 +276,16 @@ def enf_cnts_bydelta(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
     return np.vstack([
         np.concatenate([
             (_k,),
-            np.einsum("ij->j", _cnts_array[_cnts_array[:, 1] == _k][:, ndim_in:]),
+            np.einsum(
+                "ij->j", _cnts_array[_cnts_array[:, 1] == _k][:, ndim_in:], dtype=int
+            ),
         ])
         for _k in HHI_DELTA_KNOTS[:-1]
     ])
 
 
 def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
-    if not _cnts_array.any():
+    if not _cnts_array[:, 0].any() or np.isnan(_cnts_array[:, 0]).all():
         return np.array([], int)
     # Step 1: Tag and agg. from HHI-post and Delta to zone triple
     # NOTE: Although you could just map and not (partially) aggregate in this step,
@@ -315,7 +322,9 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
                 np.array(
                     (
                         *zone_val,
-                        *np.einsum("ij->j", _cnts_array[:, _ndim_in:][conc_test]),
+                        *np.einsum(
+                            "ij->j", _cnts_array[:, _ndim_in:][conc_test], dtype=int
+                        ),
                     ),
                     dtype=int,
                 ),
@@ -326,10 +335,10 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
         # Logical-and of multiple vectors:
         hhi_zone_test = (
             1
-            * np.column_stack([
+            * np.stack([
                 cnts_byhhipostanddelta[:, _idx] == _val
                 for _idx, _val in enumerate(zone_val)
-            ])
+            ], axis=1)
         ).prod(axis=1) == 1
 
         cnts_byconczone = np.vstack((
@@ -338,7 +347,9 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
                 (
                     zone_val,
                     np.einsum(
-                        "ij->j", cnts_byhhipostanddelta[hhi_zone_test][:, _nkeys:]
+                        "ij->j",
+                        cnts_byhhipostanddelta[hhi_zone_test][:, _nkeys:],
+                        dtype=int,
                     ),
                 ),
                 dtype=int,