mergeron 2025.739355.0__py3-none-any.whl → 2025.739355.2__py3-none-any.whl

mergeron/__init__.py

@@ -15,7 +15,7 @@ from ruamel import yaml
 
 _PKG_NAME: str = Path(__file__).parent.name
 
-VERSION = "2025.739355.0"
+VERSION = "2025.739355.2"
 
 __version__ = VERSION
 
@@ -39,7 +39,7 @@ NTHREADS = 2 * cpu_count()
 
 PKG_ATTRS_MAP: dict[str, type] = {}
 
-np.set_printoptions(precision=24, floatmode="fixed")
+np.set_printoptions(precision=28, floatmode="fixed", legacy=False)
 
 type HMGPubYear = Literal[1992, 2010, 2023]
 

mergeron/core/ftc_merger_investigations_data.py

@@ -36,6 +36,8 @@ from . import (
 
 __version__ = VERSION
 
+# cspell: "includeRegExpList": ["strings", "comments", /( {3}['"]{3}).*?\\1/g]
+
 WORK_DIR = globals().get("WORK_DIR", PKG_WORK_DIR)
 """Redefined, in case the user defines WORK_DIR betweeen module imports."""
 
@@ -61,7 +63,7 @@ CONC_HHI_DICT = {
     "3,000 - 3,999": 3000,
     "4,000 - 4,999": 4000,
     "5,000 - 6,999": 5000,
-    "7,000 +": 7000,
+    "7,000 - 10,000": 7000,
     "TOTAL": TTL_KEY,
 }
 CONC_DELTA_DICT = {
@@ -72,7 +74,7 @@ CONC_DELTA_DICT = {
     "500 - 800": 500,
     "800 - 1,200": 800,
     "1,200 - 2,500": 1200,
-    "2,500 +": 2500,
+    "2,500 - 5,000": 2500,
     "TOTAL": TTL_KEY,
 }
 CNT_FCOUNT_DICT = {
@@ -90,8 +92,8 @@ CNT_FCOUNT_DICT = {
 }
 
 
-def reverse_map(_dict: Mapping[Any, Any]) -> Mapping[Any, Any]:
-    """Reverse a mapping."""
+def invert_map(_dict: Mapping[Any, Any]) -> Mapping[Any, Any]:
+    """Invert mapping, mapping values to keys of the original mapping."""
     return {_v: _k for _k, _v in _dict.items()}
 
 
@@ -432,7 +434,7 @@ def _parse_invdata() -> INVData:
         " the source code as well as to install an additional package"
         " not distributed with this package or identified as a requirement."
     )
-    import pymupdf  # type: ignore
+    import pymupdf  # type: ignore  # noqa: PLC0415
 
     invdata_docnames = _download_invdata(FID_WORK_DIR)
 
@@ -610,41 +612,44 @@ def _process_table_blks_conc_type(
 ) -> ArrayBIGINT:
     conc_row_pat = re.compile(r"((?:0|\d,\d{3}) (?:- \d+,\d{3}|\+)|TOTAL)")
 
-    col_titles_array = tuple(CONC_DELTA_DICT.values())
-    col_totals: ArrayBIGINT = np.zeros(len(col_titles_array), int)
+    col_titles = tuple(CONC_DELTA_DICT.values())
+    col_totals: ArrayBIGINT = np.zeros(len(col_titles), int)
     invdata_array: ArrayBIGINT = np.array(None)
 
     for tbl_blk in _table_blocks:
         if conc_row_pat.match(_blk_str := tbl_blk[-3]):
             row_list: list[str] = _blk_str.strip().split("\n")
             row_title: str = row_list.pop(0)
-            row_key: int = CONC_HHI_DICT[row_title]
+            row_key: int = (
+                7000 if row_title.startswith("7,000") else CONC_HHI_DICT[row_title]
+            )
             row_total = np.array(row_list.pop().replace(",", "").split("/"), int)
-            row_array_list: list[list[int]] = []
+            data_row_list: list[list[int]] = []
             while row_list:
                 enfd_val, clsd_val = row_list.pop(0).split("/")
-                row_array_list += [
+                data_row_list += [
                     [
                         row_key,
-                        col_titles_array[len(row_array_list)],
+                        col_titles[len(data_row_list)],
                         int(enfd_val),
                         int(clsd_val),
                         int(enfd_val) + int(clsd_val),
                     ]
                 ]
-            row_array = np.array(row_array_list, int)
+            data_row_array = np.array(data_row_list, int)
+            del data_row_list
             # Check row totals
-            assert_array_equal(row_total, np.einsum("ij->j", row_array[:, 2:4]))
+            assert_array_equal(row_total, np.einsum("ij->j", data_row_array[:, 2:4]))
 
             if row_key == TTL_KEY:
-                col_totals = row_array
+                col_totals = data_row_array
             else:
                 invdata_array = (
-                    np.vstack((invdata_array, row_array))
+                    np.vstack((invdata_array, data_row_array))
                     if invdata_array.shape
-                    else row_array
+                    else data_row_array
                 )
-            del row_array, row_array_list
+            del data_row_array
         else:
             continue
 

mergeron/core/guidelines_boundary_functions.py

@@ -2,17 +2,25 @@
 
 import decimal
 from collections.abc import Callable
+from types import ModuleType
 from typing import Literal, TypedDict
 
 import matplotlib as mpl
 import matplotlib.axes as mpa
+import matplotlib.offsetbox as mof
 import matplotlib.patches as mpp
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mpt
 import numpy as np
 from mpmath import mp, mpf  # type: ignore
 
-from .. import DEFAULT_REC_RATIO, VERSION, ArrayBIGINT, ArrayDouble  # noqa: TID252
+from .. import (  # noqa: TID252
+    _PKG_NAME,
+    DEFAULT_REC_RATIO,
+    VERSION,
+    ArrayBIGINT,
+    ArrayDouble,
+)
 from . import GuidelinesBoundary, MPFloat
 
 __version__ = VERSION
@@ -467,47 +475,46 @@ def diversion_share_boundary_xact_avg(
         Array of share-pairs, area under boundary, area under boundary.
 
     """
-    _delta_star, _r_val = (mpf(f"{_v}") for _v in (_delta_star, _r_val))
     _s_mid = _delta_star / (1 + _delta_star)
-    _step_size = mp.power(10, -dps)
+    _step_size = 10**-dps
 
     _bdry_start = np.array([(_s_mid, _s_mid)])
-    _s_1 = np.array(mp.arange(_s_mid - _step_size, 0, -_step_size))
+    _s_1 = np.arange(_s_mid - _step_size, 0, -_step_size)
     if recapture_form == "inside-out":
-        _s_intcpt = mp.fdiv(
-            mp.fsub(
-                2 * _delta_star * _r_val + 1, mp.fabs(2 * _delta_star * _r_val - 1)
-            ),
-            2 * mpf(f"{_r_val}"),
+        _s_intcpt: float = (
+            2 * _delta_star * _r_val + 1 - np.abs(2 * _delta_star * _r_val - 1)
+        ) / (2 * _r_val)
+        nr_t1: ArrayDouble = (
+            1 + 2 * _delta_star * _r_val * (1 - _s_1) - _s_1 * (1 - _r_val)
         )
-        nr_t1 = 1 + 2 * _delta_star * _r_val * (1 - _s_1) - _s_1 * (1 - _r_val)
 
-        nr_sqrt_mdr = 4 * _delta_star * _r_val
-        nr_sqrt_mdr2 = nr_sqrt_mdr * _r_val
-        nr_sqrt_md2r2 = nr_sqrt_mdr2 * _delta_star
+        nr_sqrt_mdr: float = 4 * _delta_star * _r_val
+        nr_sqrt_mdr2: float = nr_sqrt_mdr * _r_val
+        nr_sqrt_md2r2: float = nr_sqrt_mdr2 * _delta_star
 
-        nr_sqrt_t1 = nr_sqrt_md2r2 * (_s_1**2 - 2 * _s_1 + 1)
-        nr_sqrt_t2 = nr_sqrt_mdr2 * _s_1 * (_s_1 - 1)
-        nr_sqrt_t3 = nr_sqrt_mdr * (2 * _s_1 - _s_1**2 - 1)
-        nr_sqrt_t4 = (_s_1**2) * (_r_val**2 - 6 * _r_val + 1)
-        nr_sqrt_t5 = _s_1 * (6 * _r_val - 2) + 1
+        nr_sqrt_t1: ArrayDouble = nr_sqrt_md2r2 * (_s_1**2 - 2 * _s_1 + 1)
+        nr_sqrt_t2: ArrayDouble = nr_sqrt_mdr2 * _s_1 * (_s_1 - 1)
+        nr_sqrt_t3: ArrayDouble = nr_sqrt_mdr * (2 * _s_1 - _s_1**2 - 1)
+        nr_sqrt_t4: ArrayDouble = (_s_1**2) * (_r_val**2 - 6 * _r_val + 1)
+        nr_sqrt_t5: ArrayDouble = _s_1 * (6 * _r_val - 2) + 1
 
-        nr_t2_mdr = nr_sqrt_t1 + nr_sqrt_t2 + nr_sqrt_t3 + nr_sqrt_t4 + nr_sqrt_t5
+        nr_t2_mdr: ArrayDouble = (
+            nr_sqrt_t1 + nr_sqrt_t2 + nr_sqrt_t3 + nr_sqrt_t4 + nr_sqrt_t5
+        )
 
         # Alternative grouping of terms in np.sqrt
-        nr_sqrt_s1sq = (_s_1**2) * (
-            nr_sqrt_md2r2 + nr_sqrt_mdr2 - nr_sqrt_mdr + _r_val**2 - 6 * _r_val + 1
-        )
-        nr_sqrt_s1 = _s_1 * (
+        nr_sqrt_nos1: float = nr_sqrt_md2r2 - nr_sqrt_mdr + 1
+        nr_sqrt_s1: ArrayDouble = _s_1 * (
             -2 * nr_sqrt_md2r2 - nr_sqrt_mdr2 + 2 * nr_sqrt_mdr + 6 * _r_val - 2
         )
-        nr_sqrt_nos1 = nr_sqrt_md2r2 - nr_sqrt_mdr + 1
-
-        nr_t2_s1 = nr_sqrt_s1sq + nr_sqrt_s1 + nr_sqrt_nos1
+        nr_sqrt_s1sq: ArrayDouble = (_s_1**2) * (
+            nr_sqrt_md2r2 + nr_sqrt_mdr2 - nr_sqrt_mdr + _r_val**2 - 6 * _r_val + 1
+        )
+        nr_t2_s1: ArrayDouble = nr_sqrt_s1sq + nr_sqrt_s1 + nr_sqrt_nos1
 
         if not np.isclose(
-            np.einsum("i->", nr_t2_mdr.astype(float)),
-            np.einsum("i->", nr_t2_s1.astype(float)),
+            np.einsum("i->", nr_t2_mdr),
+            np.einsum("i->", nr_t2_s1),
             rtol=0,
             atol=0.5 * dps,
         ):
@@ -516,25 +523,28 @@ def diversion_share_boundary_xact_avg(
                 f"with recapture spec, {f'"{recapture_form}"'} is incorrect."
             )
 
-        s_2 = (nr_t1 - np.sqrt(nr_t2_s1)) / (2 * _r_val)
+        s_2: ArrayDouble = (nr_t1 - nr_t2_s1**0.5) / (2 * _r_val)
 
     else:
-        _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
-        s_2 = (
-            (1 / 2)
+        _s_intcpt: float = _delta_star + 1 / 2 - np.abs(_delta_star - 1 / 2)
+        s_2: ArrayDouble = (
+            0.5
             + _delta_star
             - _delta_star * _s_1
-            - np.sqrt(
-                ((_delta_star**2) - 1) * (_s_1**2)
-                + (-2 * (_delta_star**2) + _delta_star + 1) * _s_1
-                + (_delta_star**2)
-                - _delta_star
-                + (1 / 4)
+            - (
+                (
+                    ((_delta_star**2) - 1) * (_s_1**2)
+                    + (-2 * (_delta_star**2) + _delta_star + 1) * _s_1
+                    + (_delta_star**2)
+                    - _delta_star
+                    + (1 / 4)
+                )
+                ** 0.5
             )
         )
 
     bdry_inner = np.stack((_s_1, s_2), axis=1)
-    bdry_end = np.array([(mpf("0.0"), _s_intcpt)], float)
+    bdry_end = np.array([(0.0, _s_intcpt)], float)
 
     bdry = np.vstack((
         bdry_end,
@@ -542,14 +552,14 @@ def diversion_share_boundary_xact_avg(
         _bdry_start,
         bdry_inner[:, ::-1],
         bdry_end[:, ::-1],
-    )).astype(float)
+    ))
     s_2 = np.concatenate((np.array([_s_mid], float), s_2))
 
     bdry_ends = [0, -1]
     bdry_odds = np.array(range(1, len(s_2), 2), int)
     bdry_evns = np.array(range(2, len(s_2), 2), int)
 
-    # Double the are under the curve, and subtract the double counted bit.
+    # Double the area under the curve, and subtract the double counted bit.
     bdry_area_simpson = 2 * _step_size * (
         (4 / 3) * np.sum(s_2.take(bdry_odds))
         + (2 / 3) * np.sum(s_2.take(bdry_evns))
@@ -779,6 +789,7 @@ def round_cust(
 
 
 def boundary_plot(
+    _plt: ModuleType,
     *,
     mktshare_plot_flag: bool = True,
     mktshare_axes_flag: bool = True,
@@ -791,11 +802,11 @@ def boundary_plot(
     if backend == "pgf":
         mpl.use("pgf")
 
-        plt.rcParams.update({
+        mpl.rcParams.update({
+            "text.usetex": True,
             "pgf.rcfonts": False,
             "pgf.texsystem": "lualatex",
             "pgf.preamble": "\n".join([
-                R"\pdfvariable minorversion=7",
                 R"\usepackage{fontspec}",
                 R"\usepackage{luacode}",
                 R"\begin{luacode}",
@@ -807,27 +818,40 @@ def boundary_plot(
                 R'  "luaotfload.patch_font", embedfull, "embedfull"'
                 R")",
                 R"\end{luacode}",
-                R"\setmainfont{STIX Two Text}",
-                r"\setsansfont{Fira Sans Light}",
-                R"\setmonofont[Scale=MatchLowercase,]{Fira Mono}",
                 R"\defaultfontfeatures[\rmfamily]{",
                 R"  Ligatures={TeX, Common},",
                 R"  Numbers={Proportional, Lining},",
                 R"  }",
-                R"\defaultfontfeatures[\sffamily]{",
+                R"\defaultfontfeatures[\sffamily, \dvsfamily]{",
                 R"  Ligatures={TeX, Common},",
                 R"  Numbers={Monospaced, Lining},",
                 R"  LetterSpace=0.50,",
                 R"  }",
+                R"\setmainfont{STIX Two Text}",
+                R"\setsansfont{Fira Sans Light}",
+                R"\setmonofont[Scale=MatchLowercase,]{Fira Mono}",
+                R"\newfontfamily\dvsfamily{DejaVu Sans}",
                 R"\usepackage{mathtools}",
                 R"\usepackage{unicode-math}",
-                R"\setmathfont[math-style=ISO]{STIX Two Math}",
+                R"\setmathfont{STIX Two Math}[math-style=ISO,range={scr,bfscr},StylisticSet=01]",
                 R"\usepackage[",
                 R"  activate={true, nocompatibility},",
                 R"  tracking=true,",
                 R"  ]{microtype}",
             ]),
         })
+    else:
+        if backend:
+            mpl.use(backend)
+        mpl.rcParams.update({
+            "text.usetex": True,
+            "pgf.rcfonts": True,
+            "font.family": "sans-serif",
+            "font.sans-serif": ["DejaVu Sans", "sans-serif"],
+            "font.monospace": ["DejaVu Mono", "monospace"],
+            "font.serif": ["stix", "serif"],
+            "mathtext.fontset": "stix",
+        })
 
     # Initialize a canvas with a single figure (set of axes)
     fig_ = plt.figure(figsize=(5, 5), dpi=600)
@@ -907,6 +931,38 @@ def boundary_plot(
                 for _t in axl_[::2]:
                     _t.set_visible(False)
 
+            # package version badge
+            # https://futurile.net/2016/03/14/partial-colouring-text-in-matplotlib-with-latex/
+            badge_fmt_str = R"{{\dvsfamily {}}}" if backend == "pgf" else "{}"
+            badge_txt_list = [
+                badge_fmt_str.format(_s) for _s in [f"{_PKG_NAME}", f"v{VERSION}"]
+            ]
+
+            badge_fmt_list = [
+                _btp := {"color": "#fff", "backgroundcolor": "#555", "size": 2},
+                _btp | {"backgroundcolor": "#007ec6"},
+            ]
+
+            badge_box = mof.HPacker(
+                sep=2.6,
+                children=[
+                    mof.TextArea(_t, textprops=_f)
+                    for _t, _f in zip(badge_txt_list, badge_fmt_list)
+                ],
+            )
+
+            ax0_.add_artist(
+                mof.AnnotationBbox(
+                    badge_box,
+                    xy=(0.5, 0.5),
+                    xybox=(-0.05, -0.12),
+                    xycoords="data",
+                    boxcoords="data",
+                    frameon=False,
+                    pad=0,
+                )
+            )
+
             # Axis labels
             if mktshare_axes_flag:
                 # x-axis

mergeron/core/guidelines_boundary_functions_extra.py

@@ -122,9 +122,9 @@ def diversion_share_boundary_qdtr_wtd_avg(
         Array of share-pairs, area under boundary.
 
     """
-    _delta_star = mpf(f"{_delta_star}")
+    _delta_star, _r_val = (mpf(_v) for _v in (f"{_delta_star}", f"{_r_val}"))
     _s_mid = _delta_star / (1 + _delta_star)
-    s_naught = 0
+    s_naught = mpf("0.0")
 
     s_1, s_2 = symbols("s_1:3", positive=True)
 
@@ -143,19 +143,17 @@ def diversion_share_boundary_qdtr_wtd_avg(
             )
 
             _bdry_func = solve(_bdry_eqn, s_2)[0]
-            s_naught = (
-                float(solve(simplify(_bdry_eqn.subs({s_2: 1 - s_1})), s_1)[0])  # type: ignore
-                if recapture_form == "inside-out"
-                else 0
-            )
-            bdry_area = float(
-                2
-                * (
+
+            if recapture_form == "inside-out":
+                s_naught = mpf(solve(simplify(_bdry_eqn.subs({s_2: 1 - s_1})), s_1)[0])
+
+            bdry_area = mp.fmul(
+                "2",
+                (
                     s_naught
                     + mp.quad(lambdify(s_1, _bdry_func, "mpmath"), (s_naught, _s_mid))
-                )
-                - (_s_mid**2 + s_naught**2)
-            )
+                ),
+            ) - (_s_mid**2 + s_naught**2)
 
         case "cross-product-share":
             mp.trap_complex = False
@@ -173,14 +171,14 @@ def diversion_share_boundary_qdtr_wtd_avg(
             )
 
             _bdry_func = solve(_bdry_eqn, s_2)[1]
-            bdry_area = float(
-                2
-                * (
+            bdry_area = (
+                mp.fmul(
+                    "2",
                     mp.quad(
                         lambdify(s_1, _bdry_func.subs({d_star: _delta_star}), "mpmath"),
                         (0, _s_mid),
-                    )
-                ).real
+                    ).real,
+                )
                 - _s_mid**2
             )
 
@@ -199,13 +197,13 @@ def diversion_share_boundary_qdtr_wtd_avg(
             )
 
             _bdry_func = solve(_bdry_eqn, s_2)[0]
-            bdry_area = float(
-                2 * (mp.quad(lambdify(s_1, _bdry_func, "mpmath"), (0, _s_mid)))
+            bdry_area = (
+                mp.fmul("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
+        lambdify(s_1, _bdry_func, "numpy"), float(bdry_area), float(s_naught)
     )
 
 

mergeron/gen/data_generation_functions.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import Literal
 
+import numexpr as ne
 import numpy as np
 from attrs import evolve
 from numpy.random import SeedSequence
@@ -438,11 +439,15 @@ def gen_divr_array(
     """
     divr_array: ArrayDouble
     if _recapture_form == RECForm.FIXED:
-        divr_array = _recapture_ratio * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
+        _frmshr_array_rev = _frmshr_array[:, ::-1]
+        divr_array = ne.evaluate(
+            "_recapture_ratio * _frmshr_array_rev / (1 - _frmshr_array)"
+        )
 
     else:
-        purchprob_array = _aggregate_purchase_prob * _frmshr_array
-        divr_array = purchprob_array[:, ::-1] / (1 - purchprob_array)
+        purchprob_array = ne.evaluate("_aggregate_purchase_prob * _frmshr_array")
+        purchprob_array_rev = purchprob_array[:, ::-1]  # noqa: F841
+        divr_array = ne.evaluate("purchprob_array_rev / (1 - purchprob_array)")
 
     divr_assert_test = (
         (np.round(np.einsum("ij->i", _frmshr_array), 15) == 1)
@@ -533,12 +538,12 @@ def gen_margin_price_data(
                 for _p in (_frmshr_array, _nth_firm_share)
             )
         case PriceSpec.RNG:
-            price_array_gen = prng(_pr_rng_seed_seq).choice(
+            _price_array_gen = prng(_pr_rng_seed_seq).choice(
                 1 + np.arange(pr_max_ratio), size=(len(_frmshr_array), 3)
             )
-            price_array = price_array_gen[:, :2]
-            nth_firm_price = price_array_gen[:, [2]]
-            # del _price_array_gen
+            price_array = _price_array_gen[:, :2]
+            nth_firm_price = _price_array_gen[:, [2]]
+            del _price_array_gen
         case PriceSpec.CSY:
             # TODO:
             # evolve PCMRestriction (save running MNL test twice); evolve copy of _mkt_sample_spec=1q
@@ -559,26 +564,22 @@ def gen_margin_price_data(
                 getattr(margin_data, _f) for _f in ("pcm_array", "mnl_test_array")
             )
 
-            price_array_here = 1 / (1 - pcm_array)
+            price_array_here = ne.evaluate("1 / (1 - pcm_array)")
             price_array = price_array_here[:, :2]
-            nth_firm_price = price_array_here[:, [-1]]
+            nth_firm_price = price_array_here[:, [-1]]  # noqa: F841
             if _pcm_spec.pcm_restriction == PCMRestriction.MNL:
                 # Generate i.i.d. PCMs then take PCM0 and construct PCM1
                 # Regenerate MNL test
-                purchase_prob_array = _aggregate_purchase_prob * _frmshr_array
-                pcm_array[:, 1] = np.divide(
-                    (
-                        m1_nr := np.divide(
-                            np.einsum(
-                                "ij,ij,ij->ij",
-                                price_array[:, [0]],
-                                pcm_array[:, [0]],
-                                1 - purchase_prob_array[:, [0]],
-                            ),
-                            1 - purchase_prob_array[:, [1]],
-                        )
-                    ),
-                    1 + m1_nr,
+                purchase_prob_array = ne.evaluate(
+                    "_aggregate_purchase_prob * _frmshr_array"
+                )
+
+                _pr_0, _pi_0 = price_array_here[:, [0]], purchase_prob_array[:, [0]]
+                _pcm_0 = pcm_array[:, [0]]
+                _pr_1, _pi_1 = price_array_here[:, [1]], purchase_prob_array[:, [1]]
+
+                pcm_array[:, [1]] = ne.evaluate(
+                    "_pcm_0 * (1 - _pi_0) / (1 - _pi_1 + _pcm_0 * (_pi_1 - _pi_0))"
                 )
                 mnl_test_array = (pcm_array[:, [1]] >= 0) & (pcm_array[:, [1]] <= 1)
 
@@ -599,8 +600,8 @@ def gen_margin_price_data(
         )
 
     # _price_array = _price_array.astype(np.float64)
-    rev_array = price_array * _frmshr_array
-    nth_firm_rev = nth_firm_price * _nth_firm_share
+    rev_array = ne.evaluate("price_array * _frmshr_array")
+    nth_firm_rev = ne.evaluate("nth_firm_price * _nth_firm_share")
 
     # Although `_test_rev_ratio_inv` is not fixed at 10%,
     # the ratio has not changed since inception of the HSR filing test,
@@ -616,7 +617,7 @@ def gen_margin_price_data(
             # Revenue ratio has been 10-to-1 since inception
             # Thus, a simple form of the HSR filing test would impose a 10-to-1
             # ratio restriction on the merging firms' revenues
-            rev_ratio = (rev_array.min(axis=1) / rev_array.max(axis=1)).round(4)
+            rev_ratio = np.divide(rev_array.min(axis=1), rev_array.max(axis=1)).round(4)
             hsr_filing_test = rev_ratio >= test_rev_ratio_inv
             # del _rev_array, _rev_ratio
         case SSZConstant.HSR_NTH:
@@ -721,16 +722,12 @@ def _gen_margin_data(
         # Impose FOCs from profit-maximization with MNL demand
         purchase_prob_array = _aggregate_purchase_prob * _frmshr_array
 
-        pcm_array[:, [1]] = np.divide(
-            np.einsum(
-                "ij,ij,ij->ij",
-                _price_array[:, [0]],
-                pcm_array[:, [0]],
-                1 - purchase_prob_array[:, [0]],
-            ),
-            np.einsum(
-                "ij,ij->ij", _price_array[:, [1]], 1 - purchase_prob_array[:, [1]]
-            ),
+        _pr_0, _pi_0 = _price_array[:, [0]], purchase_prob_array[:, [0]]
+        _pcm_0 = pcm_array[:, [0]]
+        _pr_1, _pi_1 = _price_array[:, [1]], purchase_prob_array[:, [1]]
+
+        pcm_array[:, [1]] = ne.evaluate(
+            "_pr_0 * _pcm_0 * (1 - _pi_0) / (_pr_1 * (1 - _pi_1))"
         )
 
         mnl_test_array = (pcm_array[:, 1] >= 0) & (pcm_array[:, 1] <= 1)

{mergeron-2025.739355.0.dist-info → mergeron-2025.739355.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: mergeron
-Version: 2025.739355.0
+Version: 2025.739355.2
 Summary: Python for analyzing merger enforcement policy
 License: MIT
 Keywords: merger enforcement policy,merger guidelines,merger screening,enforcement presumptions,concentration standards,diversion ratio,upward pricing pressure,GUPPI
 Author: Murthy Kambhampaty
 Author-email: smk@capeconomics.com
-Requires-Python: >=3.12
+Requires-Python: >=3.12,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
@@ -14,10 +14,9 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aenum (>=3.1.15)
 Requires-Dist: attrs (>=25.3.0)
 Requires-Dist: beautifulsoup4 (>=4.13.3)
@@ -28,6 +27,7 @@ Requires-Dist: joblib (>=1.4.2)
 Requires-Dist: lxml (>=5.3.2)
 Requires-Dist: matplotlib (>=3.10.1)
 Requires-Dist: mpmath (>=1.3.0)
+Requires-Dist: numexpr (>=2.10.2,<3.0.0)
 Requires-Dist: python-calamine (>=0.3.2)
 Requires-Dist: ruamel-yaml (>=0.18.10)
 Requires-Dist: scipy (>=1.15.2)
@@ -89,5 +89,5 @@ To install the package, use the following shell command:
 Documentation
 -------------
 
-Usage guide and API reference available `here <https://capeconomics.github.io/mergeron/>`_.
+Usage guide and API reference are `available <https://capeconomics.github.io/mergeron/>`_.
 

{mergeron-2025.739355.0.dist-info → mergeron-2025.739355.2.dist-info}/RECORD

@@ -1,20 +1,20 @@
-mergeron/__init__.py,sha256=qjmFjh6yCKnTzrgdmI7KamtTpqwtjZrAtJmc9piXGHo,5773
+mergeron/__init__.py,sha256=uuqwnqQy0tnwO6matahMTWWeMOKMSyDINJfakP7fd3Y,5787
 mergeron/core/__init__.py,sha256=4Y_q-Qu7gXENVKHS-lNebn5mPZDy9oPHFwUV7fAW9Nw,3269
 mergeron/core/empirical_margin_distribution.py,sha256=aqQ7JYpliHSjHpzyPRkYW9LhJfp-aAlSifRxYx3Dmbo,11623
-mergeron/core/ftc_merger_investigations_data.py,sha256=k4TDkP1rDBmN4uKOYF0SUvSRkYmyVhbsBvLUKDYJqOo,28537
+mergeron/core/ftc_merger_investigations_data.py,sha256=ccPN81wE6Z-jUguXtAr01JUJVovWzP8Vxlha9g3r8yI,28788
 mergeron/core/guidelines_boundaries.py,sha256=noacM3NmhzqPKLPGm7HEvLKX2UlRI1DCw1kxDa2cFXk,15586
-mergeron/core/guidelines_boundary_functions.py,sha256=ZTx4uaaR-3Qcc3Uh27S_shIu-4eyW8rLR2Lj13WvDX0,28513
-mergeron/core/guidelines_boundary_functions_extra.py,sha256=JompgWmwnwcWsodXrZbvzY_OXw-7ppb_H_Gsz9-fpgI,22080
+mergeron/core/guidelines_boundary_functions.py,sha256=GHDNYXMZSFkkNz29x4JmdodBKyANAL1uocnTB8FGxV0,30339
+mergeron/core/guidelines_boundary_functions_extra.py,sha256=hRhROaLJoRtTrtd-dNkpAGPOEeY1w_qXQHKIxfALaG4,22070
 mergeron/core/pseudorandom_numbers.py,sha256=-mPveXjJJ446NrBMAmWIa2jI6j0Px0xcCJTGEEsn3bo,10149
 mergeron/data/__init__.py,sha256=CbqheFSkXEe7NOfuAV-NLaaEiNzl9pVCndGjtUUOj9g,1846
 mergeron/data/damodaran_margin_data_serialized.zip,sha256=Wc1v9buSrYTWWAravG8W9nPbgsU07zMtSAR2RvMQU5s,623482
 mergeron/data/ftc_merger_investigations_data.zip,sha256=tiB2TLFyS9LMSFIv8DBA_oEEx12DU4MyjHni4NlsRMU,24002
 mergeron/gen/__init__.py,sha256=bRGGIFBqIVw4-zZ4AKwcNbOTM9aHKegPj7w_7MJV9-I,23856
 mergeron/gen/data_generation.py,sha256=L44YNtxso-Ya50YT71rnG-el4_PgGn4vtoA7rFDD194,17487
-mergeron/gen/data_generation_functions.py,sha256=f6aLBg6JNqOoBq57k3ovevgvtaLfIAfT-ATzZl11CEA,26076
+mergeron/gen/data_generation_functions.py,sha256=GQaeIzdiBXrYWMb9-kO2QPBY7YAVtUxaz1o1bqgnbw0,26126
 mergeron/gen/enforcement_stats.py,sha256=etTax-sBSn8DveF-IxuBJDdX0XSBD6oFU9vaZe6cYks,14387
 mergeron/gen/upp_tests.py,sha256=gRJISQ2jGmIDmFOvaTIkvYooI4mK-QbgkfgL46RrRio,7445
 mergeron/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-mergeron-2025.739355.0.dist-info/METADATA,sha256=DwSbyhgSZPnJ6V89zcswJC98ojEDui7Y3zJkrrZc0v4,3865
-mergeron-2025.739355.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-mergeron-2025.739355.0.dist-info/RECORD,,
+mergeron-2025.739355.2.dist-info/METADATA,sha256=dM_917MY6amh3JiasPM8cfk1xKu8N_75RYJmEyOX2Ok,3857
+mergeron-2025.739355.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+mergeron-2025.739355.2.dist-info/RECORD,,