mergeron 2025.739290.3__py3-none-any.whl → 2025.739290.5__py3-none-any.whl

mergeron/gen/data_generation_functions.py

@@ -18,7 +18,7 @@ from .. import (  # noqa: TID252
     ArrayFloat,
     RECForm,
 )
-from ..core.empirical_margin_distribution import mgn_data_resampler  # noqa: TID252
+from ..core.empirical_margin_distribution import margin_data_resampler  # noqa: TID252
 from ..core.pseudorandom_numbers import (  # noqa: TID252
     DEFAULT_BETA_DIST_PARMS,
     DEFAULT_DIST_PARMS,
@@ -26,6 +26,7 @@ from ..core.pseudorandom_numbers import (  # noqa: TID252
     prng,
 )
 from . import (
+    DEFAULT_BETA_BND_DIST_PARMS,
     DEFAULT_FCOUNT_WTS,
     FM2Constraint,
     MarginDataSample,
@@ -69,36 +70,23 @@ def gen_share_data(
 
     """
 
-    _dist_type_mktshr, _firm_count_prob_wts, _dist_parms_mktshr, _recapture_form = (
+    dist_type_mktshr, firm_count_prob_wts, dist_parms_mktshr, recapture_form = (
         getattr(_share_spec, _f)
         for _f in ("dist_type", "firm_counts_weights", "dist_parms", "recapture_form")
     )
 
-    _ssz = _sample_size
-    if not len(_dist_parms_mktshr):
-        _dist_parms_mktshr = (
-            DEFAULT_DIST_PARMS
-            if _dist_type_mktshr == "Uniform"
-            else np.ones(1 + len(_firm_count_prob_wts), float)
+    if dist_type_mktshr == SHRDistribution.UNI:
+        mkt_share_sample = gen_market_shares_uniform(
+            _sample_size, dist_parms_mktshr, _mktshr_rng_seed_seq, _nthreads
         )
 
-    if _dist_type_mktshr == SHRDistribution.UNI:
-        _mkt_share_sample = gen_market_shares_uniform(
-            _ssz, _dist_parms_mktshr, _mktshr_rng_seed_seq, _nthreads
-        )
-
-    elif _dist_type_mktshr.name.startswith("DIR_"):
-        _firm_count_prob_wts = (
-            None
-            if _firm_count_prob_wts is None
-            else np.array(_firm_count_prob_wts, float)
-        )
-        _mkt_share_sample = _gen_market_shares_dirichlet_multimarket(
-            _ssz,
-            _recapture_form,
-            _dist_type_mktshr,
-            _dist_parms_mktshr,
-            _firm_count_prob_wts,
+    elif dist_type_mktshr.name.startswith("DIR_"):
+        mkt_share_sample = _gen_market_shares_dirichlet_multimarket(
+            _sample_size,
+            recapture_form,
+            dist_type_mktshr,
+            dist_parms_mktshr,
+            firm_count_prob_wts,
             _fcount_rng_seed_seq,
             _mktshr_rng_seed_seq,
             _nthreads,
@@ -106,21 +94,21 @@ def gen_share_data(
 
     else:
         raise ValueError(
-            f'Unexpected type, "{_dist_type_mktshr}" for share distribution.'
+            f'Unexpected type, "{dist_type_mktshr}" for share distribution.'
         )
 
     # If recapture_form == "inside-out", recalculate _aggregate_purchase_prob
-    _frmshr_array = _mkt_share_sample.mktshr_array[:, :2]
-    _r_bar = _share_spec.recapture_ratio or DEFAULT_REC_RATIO
-    if _recapture_form == RECForm.INOUT:
-        _mkt_share_sample = ShareDataSample(
-            _mkt_share_sample.mktshr_array,
-            _mkt_share_sample.fcounts,
-            _mkt_share_sample.nth_firm_share,
-            _r_bar / (1 - (1 - _r_bar) * _frmshr_array.min(axis=1, keepdims=True)),
+    frmshr_array = mkt_share_sample.mktshr_array[:, :2]
+    r_bar_ = _share_spec.recapture_ratio or DEFAULT_REC_RATIO
+    if recapture_form == RECForm.INOUT:
+        mkt_share_sample = ShareDataSample(
+            mkt_share_sample.mktshr_array,
+            mkt_share_sample.fcounts,
+            mkt_share_sample.nth_firm_share,
+            r_bar_ / (1 - (1 - r_bar_) * frmshr_array.min(axis=1, keepdims=True)),
         )
 
-    return _mkt_share_sample
+    return mkt_share_sample
 
 
 def gen_market_shares_uniform(
@@ -149,46 +137,41 @@ def gen_market_shares_uniform(
 
     """
 
-    _frmshr_array: ArrayDouble = np.empty((_s_size, 2), float)
+    frmshr_array: ArrayDouble = np.empty((_s_size, 2), float)
 
-    _mrng = MultithreadedRNG(
-        _frmshr_array,
+    MultithreadedRNG(
+        frmshr_array,
         dist_type="Uniform",
         dist_parms=_dist_parms_mktshr,
         seed_sequence=_mktshr_rng_seed_seq,
         nthreads=_nthreads,
-    )
-    _mrng.fill()
+    ).fill()
 
     # Convert draws on U[0, 1] to Uniformly-distributed draws on simplex, s_1 + s_2 <= 1
-    _frmshr_array = np.hstack((
-        _frmshr_array.min(axis=1, keepdims=True),
-        np.abs(np.diff(_frmshr_array, axis=1)),
+    frmshr_array = np.hstack((
+        frmshr_array.min(axis=1, keepdims=True),
+        np.abs(np.diff(frmshr_array, axis=1)),
     ))
 
     # Keep only share combinations representing feasible mergers
     # This is a no-op for 64-bit floats, but is necessary for smaller floats
-    _frmshr_array = _frmshr_array[_frmshr_array.min(axis=1) > 0]
+    frmshr_array = frmshr_array[frmshr_array.min(axis=1) > 0]
 
     # Let a third column have values of "np.nan", so HHI calculations return "np.nan"
-    _mktshr_array = np.pad(
-        _frmshr_array, ((0, 0), (0, 1)), "constant", constant_values=np.nan
+    mktshr_array_ = np.pad(
+        frmshr_array, ((0, 0), (0, 1)), "constant", constant_values=np.nan
     )
 
-    _fcounts = np.empty((_s_size, 1), np.int64)
-    _nth_firm_share, _aggregate_purchase_prob = (
-        np.empty(_fcounts.shape, np.float64)
-        for _ in ("nth_firm_share", "aggregate_purchase_prob")
+    fcounts_, nth_firm_share_, aggregate_purchase_prob_ = (
+        np.empty((_s_size, 1), type_) for type_ in (np.uint8, np.float64, np.float64)
     )
 
-    # This array is meant to be ignored, so a sentinel value is fine
-    _fcounts.fill(-1)
-
-    _nth_firm_share.fill(np.nan)
-    _aggregate_purchase_prob.fill(np.nan)
+    fcounts_.fill(0)
+    nth_firm_share_.fill(np.nan)
+    aggregate_purchase_prob_.fill(np.nan)
 
     return ShareDataSample(
-        _mktshr_array, _fcounts, _nth_firm_share, _aggregate_purchase_prob
+        mktshr_array_, fcounts_, nth_firm_share_, aggregate_purchase_prob_
     )
 
 
@@ -245,83 +228,79 @@ def _gen_market_shares_dirichlet_multimarket(
         else _firm_count_wts
     )
 
-    _min_choice_wt = 0.03 if _dist_type_dir == SHRDistribution.DIR_FLAT_CONSTR else 0.00
-    _fcount_keys, _choice_wts = zip(
+    min_choice_wt = 0.03 if _dist_type_dir == SHRDistribution.DIR_FLAT_CONSTR else 0.00
+    fcount_keys, choice_wts = zip(
         *(
-            _f
-            for _f in zip(
-                2 + np.arange(len(_firm_count_wts)),
+            f_
+            for f_ in zip(
+                2 + np.arange(len(_firm_count_wts), dtype=np.uint8),
                 _firm_count_wts / _firm_count_wts.sum(),
                 strict=True,
             )
-            if _f[1] > _min_choice_wt
+            if f_[1] > min_choice_wt
         )
     )
-    _choice_wts = _choice_wts / sum(_choice_wts)
+    choice_wts /= sum(choice_wts)
 
-    _fc_max = _fcount_keys[-1]
-    _dir_alphas_full = (
-        _dist_parms_dir[:_fc_max] if len(_dist_parms_dir) else [1.0] * _fc_max
+    fc_max = fcount_keys[-1]
+    dir_alphas_full = (
+        _dist_parms_dir[:fc_max] if len(_dist_parms_dir) else [1.0] * fc_max
     )
     if _dist_type_dir == SHRDistribution.DIR_ASYM:
-        _dir_alphas_full = [2.0] * 6 + [1.5] * 5 + [1.25] * min(7, _fc_max)
+        dir_alphas_full = [2.0] * 6 + [1.5] * 5 + [1.25] * min(7, fc_max)
 
     if _dist_type_dir == SHRDistribution.DIR_COND:
 
         def _gen_dir_alphas(_fcv: int) -> ArrayDouble:
-            _dat = [2.5] * 2
-            if _fcv > len(_dat):
-                _dat += [1.0 / (_fcv - 2)] * (_fcv - 2)
-            return np.array(_dat, float)
+            dat_ = [2.5] * 2
+            if _fcv > len(dat_):
+                dat_ += [1.0 / (_fcv - 2)] * (_fcv - 2)
+            return np.array(dat_, float)
 
     else:
 
         def _gen_dir_alphas(_fcv: int) -> ArrayDouble:
-            return np.array(_dir_alphas_full[:_fcv], float)
+            return np.array(dir_alphas_full[:_fcv], float)
 
-    _fcounts = prng(_fcount_rng_seed_seq).choice(
-        _fcount_keys, size=(_s_size, 1), p=_choice_wts
+    fcounts_ = prng(_fcount_rng_seed_seq).choice(
+        fcount_keys, size=(_s_size, 1), p=choice_wts
     )
 
-    _mktshr_seed_seq_ch = (
-        _mktshr_rng_seed_seq.spawn(len(_fcount_keys))
-        if isinstance(_mktshr_rng_seed_seq, SeedSequence)
-        else SeedSequence(pool_size=8).spawn(len(_fcounts))
-    )
+    mktshr_seed_seq_ch = _mktshr_rng_seed_seq.spawn(len(fcount_keys))
 
-    _aggregate_purchase_prob, _nth_firm_share = (
+    aggregate_purchase_prob_, nth_firm_share_ = (
         np.empty((_s_size, 1)) for _ in range(2)
     )
-    _mktshr_array = np.empty((_s_size, _fc_max), float)
-    for _f_val, _f_sseq in zip(_fcount_keys, _mktshr_seed_seq_ch, strict=True):
-        _fcounts_match_rows = np.where(_fcounts == _f_val)[0]
-        _dir_alphas_test = _gen_dir_alphas(_f_val)
+    mktshr_array_ = np.empty((_s_size, fc_max), float)
+    for f_val, f_sseq in zip(fcount_keys, mktshr_seed_seq_ch, strict=True):
+        fcounts_match_rows = np.where(fcounts_ == f_val)[0]
+        dir_alphas_test = _gen_dir_alphas(f_val)
 
         try:
-            _mktshr_sample_f = gen_market_shares_dirichlet(
-                _dir_alphas_test,
-                len(_fcounts_match_rows),
+            mktshr_sample_f = gen_market_shares_dirichlet(
+                dir_alphas_test,
+                len(fcounts_match_rows),
                 _recapture_form,
-                _f_sseq,
+                f_sseq,
                 _nthreads,
             )
-        except ValueError as _err:
-            print(_f_val, len(_fcounts_match_rows))
-            raise _err
+        except ValueError as err_:
+            print(f_val, len(fcounts_match_rows))
+            raise err_
 
         # Push data for present sample to parent
-        _mktshr_array[_fcounts_match_rows] = np.pad(
-            _mktshr_sample_f.mktshr_array,
-            ((0, 0), (0, _fc_max - _mktshr_sample_f.mktshr_array.shape[1])),
+        mktshr_array_[fcounts_match_rows] = np.pad(
+            mktshr_sample_f.mktshr_array,
+            ((0, 0), (0, fc_max - mktshr_sample_f.mktshr_array.shape[1])),
             "constant",
         )
-        _aggregate_purchase_prob[_fcounts_match_rows] = (
-            _mktshr_sample_f.aggregate_purchase_prob
+        aggregate_purchase_prob_[fcounts_match_rows] = (
+            mktshr_sample_f.aggregate_purchase_prob
         )
-        _nth_firm_share[_fcounts_match_rows] = _mktshr_sample_f.nth_firm_share
+        nth_firm_share_[fcounts_match_rows] = mktshr_sample_f.nth_firm_share
 
-    if (_iss := np.round(np.einsum("ij->", _mktshr_array))) != _s_size or _iss != len(
-        _mktshr_array
+    if (iss_ := np.round(np.einsum("ij->", mktshr_array_))) != _s_size or iss_ != len(
+        mktshr_array_
     ):
         raise ValueError(
             "DATA GENERATION ERROR: {} {} {}".format(
@@ -332,7 +311,7 @@ def _gen_market_shares_dirichlet_multimarket(
         )
 
     return ShareDataSample(
-        _mktshr_array, _fcounts, _nth_firm_share, _aggregate_purchase_prob
+        mktshr_array_, fcounts_, nth_firm_share_, aggregate_purchase_prob_
     )
 
 
@@ -377,27 +356,29 @@ def gen_market_shares_dirichlet(
     if _recapture_form == RECForm.OUTIN:
         _dir_alphas = np.concatenate((_dir_alphas, _dir_alphas[-1:]))
 
-    _mktshr_seed_seq_ch = (
-        _mktshr_rng_seed_seq
-        if isinstance(_mktshr_rng_seed_seq, SeedSequence)
-        else SeedSequence(pool_size=8)
-    )
-
-    _mktshr_array = np.empty((_s_size, len(_dir_alphas)), float)
-    _mrng = MultithreadedRNG(
-        _mktshr_array,
+    mktshr_array = np.empty((_s_size, len(_dir_alphas)), float)
+    MultithreadedRNG(
+        mktshr_array,
         dist_type="Dirichlet",
         dist_parms=_dir_alphas,
-        seed_sequence=_mktshr_seed_seq_ch,
+        seed_sequence=_mktshr_rng_seed_seq,
         nthreads=_nthreads,
-    )
-    _mrng.fill()
-
-    if (_iss := np.round(np.einsum("ij->", _mktshr_array))) != _s_size or _iss != len(
-        _mktshr_array
+    ).fill()
+    # mrng_ = MultithreadedRNG(
+    #     mktshr_array,
+    #     dist_type="Dirichlet",
+    #     dist_parms=_dir_alphas,
+    #     seed_sequence=_mktshr_rng_seed_seq,
+    #     nthreads=_nthreads,
+    # )
+    # mrng_.fill()
+    # del mrng_
+
+    if (iss_ := np.round(np.einsum("ij->", mktshr_array))) != _s_size or iss_ != len(
+        mktshr_array
     ):
-        print(_dir_alphas, _iss, repr(_s_size), len(_mktshr_array))
-        print(repr(_mktshr_array[-10:, :]))
+        print(_dir_alphas, iss_, repr(_s_size), len(mktshr_array))
+        print(repr(mktshr_array[-10:, :]))
         raise ValueError(
             "DATA GENERATION ERROR: {} {} {}".format(
                 "Generation of sample shares is inconsistent:",
@@ -407,17 +388,17 @@ def gen_market_shares_dirichlet(
         )
 
     # If recapture_form == 'inside_out', further calculations downstream
-    _aggregate_purchase_prob = np.empty((_s_size, 1), float)
-    _aggregate_purchase_prob.fill(np.nan)
+    aggregate_purchase_prob_ = np.empty((_s_size, 1), float)
+    aggregate_purchase_prob_.fill(np.nan)
     if _recapture_form == RECForm.OUTIN:
-        _aggregate_purchase_prob = 1 - _mktshr_array[:, [-1]]  # type: ignore
-        _mktshr_array = _mktshr_array[:, :-1] / _aggregate_purchase_prob
+        aggregate_purchase_prob_ = 1 - mktshr_array[:, [-1]]  # type: ignore
+        mktshr_array = mktshr_array[:, :-1] / aggregate_purchase_prob_
 
     return ShareDataSample(
-        _mktshr_array,
-        (_mktshr_array.shape[-1] * np.ones((_s_size, 1))).astype(np.int64),
-        _mktshr_array[:, [-1]],
-        _aggregate_purchase_prob,
+        mktshr_array,
+        (mktshr_array.shape[-1] * np.ones((_s_size, 1))).astype(np.int64),
+        mktshr_array[:, [-1]],
+        aggregate_purchase_prob_,
     )
 
 
@@ -462,19 +443,19 @@ def gen_divr_array(
 
     """
 
-    _divr_array: ArrayDouble
+    divr_array: ArrayDouble
     if _recapture_form == RECForm.FIXED:
-        _divr_array = _recapture_ratio * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
+        divr_array = _recapture_ratio * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
 
     else:
-        _purchprob_array = _aggregate_purchase_prob * _frmshr_array
-        _divr_array = _purchprob_array[:, ::-1] / (1 - _purchprob_array)
+        purchprob_array = _aggregate_purchase_prob * _frmshr_array
+        divr_array = purchprob_array[:, ::-1] / (1 - purchprob_array)
 
-    _divr_assert_test = (
+    divr_assert_test = (
         (np.round(np.einsum("ij->i", _frmshr_array), 15) == 1)
-        | (np.argmin(_frmshr_array, axis=1) == np.argmax(_divr_array, axis=1))
+        | (np.argmin(_frmshr_array, axis=1) == np.argmax(divr_array, axis=1))
     )[:, None]
-    if not all(_divr_assert_test):
+    if not all(divr_assert_test):
         raise ValueError(
             "{} {} {} {}".format(
                 "Data construction fails tests:",
@@ -484,10 +465,10 @@ def gen_divr_array(
             )
         )
 
-    return _divr_array
+    return divr_array
 
 
-def gen_margin_price_data(
+def gen_margin_price_data(  # noqa: PLR0914
     _frmshr_array: ArrayDouble,
     _nth_firm_share: ArrayDouble,
     _aggregate_purchase_prob: ArrayDouble,
@@ -539,86 +520,86 @@ def gen_margin_price_data(
         Simulated margin- and price-data arrays for mergers in the sample.
     """
 
-    _margin_data = MarginDataSample(
+    margin_data = MarginDataSample(
         np.empty_like(_frmshr_array), np.ones(len(_frmshr_array)) == 0
     )
 
-    _nth_firm_price: ArrayDouble
-    _price_array: ArrayDouble = np.ones_like(_frmshr_array, np.float64)
+    nth_firm_price: ArrayDouble
+    price_array: ArrayDouble = np.ones_like(_frmshr_array, np.float64)
 
-    _pr_max_ratio = 5.0
+    pr_max_ratio = 5.0
     match _price_spec:
         case PriceSpec.SYM:
-            _nth_firm_price = np.ones((len(_frmshr_array), 1), np.float64)
+            nth_firm_price = np.ones((len(_frmshr_array), 1), np.float64)
         case PriceSpec.POS:
-            _price_array, _nth_firm_price = (
-                np.ceil(_p * _pr_max_ratio) for _p in (_frmshr_array, _nth_firm_share)
+            price_array, nth_firm_price = (
+                np.ceil(_p * pr_max_ratio) for _p in (_frmshr_array, _nth_firm_share)
             )
         case PriceSpec.NEG:
-            _price_array, _nth_firm_price = (
-                np.ceil((1 - _p) * _pr_max_ratio)
+            price_array, nth_firm_price = (
+                np.ceil((1 - _p) * pr_max_ratio)
                 for _p in (_frmshr_array, _nth_firm_share)
             )
-        case PriceSpec.ZERO:
-            _price_array_gen = prng(_pr_rng_seed_seq).choice(
-                1 + np.arange(_pr_max_ratio), size=(len(_frmshr_array), 3)
+        case PriceSpec.RNG:
+            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]]
+            price_array = price_array_gen[:, :2]
+            nth_firm_price = price_array_gen[:, [2]]
             # del _price_array_gen
         case PriceSpec.CSY:
             # TODO:
             # evolve FM2Constraint (save running MNL test twice); evolve copy of _mkt_sample_spec=1q
             # generate the margin data
             # generate price and margin data
-            _frmshr_array_plus = np.hstack((_frmshr_array, _nth_firm_share))
-            _pcm_spec_here = evolve(_pcm_spec, firm2_pcm_constraint=FM2Constraint.IID)
-            _margin_data = _gen_margin_data(
-                _frmshr_array_plus,
-                np.ones_like(_frmshr_array_plus, np.float64),
+            frmshr_array_plus = np.hstack((_frmshr_array, _nth_firm_share))
+            pcm_spec_here = evolve(_pcm_spec, firm2_pcm_constraint=FM2Constraint.IID)
+            margin_data = _gen_margin_data(
+                frmshr_array_plus,
+                np.ones_like(frmshr_array_plus, np.float64),
                 _aggregate_purchase_prob,
-                _pcm_spec_here,
+                pcm_spec_here,
                 _pcm_rng_seed_seq,
                 _nthreads,
             )
 
-            _pcm_array, _mnl_test_array = (
-                getattr(_margin_data, _f) for _f in ("pcm_array", "mnl_test_array")
+            pcm_array, mnl_test_array = (
+                getattr(margin_data, _f) for _f in ("pcm_array", "mnl_test_array")
             )
 
-            _price_array_here = 1 / (1 - _pcm_array)
-            _price_array = _price_array_here[:, :2]
-            _nth_firm_price = _price_array_here[:, [-1]]
+            price_array_here = 1 / (1 - pcm_array)
+            price_array = price_array_here[:, :2]
+            nth_firm_price = price_array_here[:, [-1]]
             if _pcm_spec.firm2_pcm_constraint == FM2Constraint.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(
+                purchase_prob_array = _aggregate_purchase_prob * _frmshr_array
+                pcm_array[:, 1] = np.divide(
                     (
-                        _m1_nr := np.divide(
+                        m1_nr := np.divide(
                             np.einsum(
                                 "ij,ij,ij->ij",
-                                _price_array[:, [0]],
-                                _pcm_array[:, [0]],
-                                1 - _purchase_prob_array[:, [0]],
+                                price_array[:, [0]],
+                                pcm_array[:, [0]],
+                                1 - purchase_prob_array[:, [0]],
                             ),
-                            1 - _purchase_prob_array[:, [1]],
+                            1 - purchase_prob_array[:, [1]],
                         )
                     ),
-                    1 + _m1_nr,
+                    1 + m1_nr,
                 )
-                _mnl_test_array = (_pcm_array[:, [1]] >= 0) & (_pcm_array[:, [1]] <= 1)
+                mnl_test_array = (pcm_array[:, [1]] >= 0) & (pcm_array[:, [1]] <= 1)
 
-            _margin_data = MarginDataSample(_pcm_array[:, :2], _mnl_test_array)
-            del _price_array_here
+            margin_data = MarginDataSample(pcm_array[:, :2], mnl_test_array)
+            del price_array_here
         case _:
             raise ValueError(
                 f'Specification of price distribution, "{_price_spec.value}" is invalid.'
             )
     if _price_spec != PriceSpec.CSY:
-        _margin_data = _gen_margin_data(
+        margin_data = _gen_margin_data(
             _frmshr_array,
-            _price_array,
+            price_array,
             _aggregate_purchase_prob,
             _pcm_spec,
             _pcm_rng_seed_seq,
@@ -626,13 +607,13 @@ 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 = price_array * _frmshr_array
+    nth_firm_rev = 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,
     # so we treat it as a constant of merger enforcement policy.
-    _test_rev_ratio, _test_rev_ratio_inv = 10, 1 / 10
+    test_rev_ratio, test_rev_ratio_inv = 10, 1 / 10
 
     match _hsr_filing_test_type:
         case SSZConstant.HSR_TEN:
@@ -643,8 +624,8 @@ 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)
-            _hsr_filing_test = _rev_ratio >= _test_rev_ratio_inv
+            rev_ratio = (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:
             # To get around the 10-to-1 ratio restriction, specify that the nth firm test:
@@ -653,25 +634,26 @@ def gen_margin_price_data(
             # the size test is considered met.
             # Alternatively, if the smaller merging firm has 10% or greater share,
             # the value of transaction test is considered met.
-            _rev_ratio_to_nth = np.round(np.sort(_rev_array, axis=1) / _nth_firm_rev, 4)
-            _hsr_filing_test = (
+            rev_ratio_to_nth = np.round(np.sort(rev_array, axis=1) / nth_firm_rev, 4)
+            hsr_filing_test = (
                 np.einsum(
                     "ij->i",
-                    1 * (_rev_ratio_to_nth > [1, _test_rev_ratio]),
+                    1 * (rev_ratio_to_nth > [1, test_rev_ratio]),
                     dtype=np.int64,
                 )
-                == _rev_ratio_to_nth.shape[1]
+                == rev_ratio_to_nth.shape[1]
             )
 
             # del _nth_firm_rev, _rev_ratio_to_nth
         case _:
             # Otherwise, all draws meet the filing test
-            _hsr_filing_test = np.ones(len(_frmshr_array), dtype=bool)
-    _hsr_filing_test = _hsr_filing_test | (
-        _frmshr_array.min(axis=1) >= _test_rev_ratio_inv
-    )
+            hsr_filing_test = np.ones(len(_frmshr_array), dtype=bool)
 
-    return _margin_data, PriceDataSample(_price_array, _hsr_filing_test)
+    # Assume that if minimum mergeing-firm share is 10%, merger filing required
+    # under value-of-transactions test or merger triggers post-consummation review
+    hsr_filing_test |= _frmshr_array.min(axis=1) >= test_rev_ratio_inv
+
+    return margin_data, PriceDataSample(price_array, hsr_filing_test)
 
 
 def _gen_margin_data(
@@ -683,90 +665,91 @@ def _gen_margin_data(
     _nthreads: int,
     /,
 ) -> MarginDataSample:
-    _dist_type_pcm, _dist_firm2_pcm, _dist_parms_pcm = (
+    dist_type_pcm, dist_parms_pcm, dist_firm2_pcm = (
         getattr(_pcm_spec, _f)
-        for _f in ("dist_type", "firm2_pcm_constraint", "dist_parms")
+        for _f in ("dist_type", "dist_parms", "firm2_pcm_constraint")
     )
 
-    _pcm_array = (
+    pcm_array = (
         np.empty((len(_frmshr_array), 1), float)
         if _pcm_spec.firm2_pcm_constraint == FM2Constraint.SYM
         else np.empty_like(_frmshr_array, float)
     )
 
-    _dist_parms: ArrayFloat
-    _beta_min, _beta_max = [0.0] * 2  # placeholder
-    if _dist_type_pcm == PCMDistribution.EMPR:
-        _pcm_array = mgn_data_resampler(
-            _pcm_array.shape, seed_sequence=_pcm_rng_seed_seq
+    dist_parms_: ArrayFloat
+    beta_min, beta_max = [0.0] * 2  # placeholder
+    if dist_type_pcm == PCMDistribution.EMPR:
+        pcm_array = margin_data_resampler(
+            pcm_array.shape, seed_sequence=_pcm_rng_seed_seq
         )
     else:
-        _dist_type: Literal["Beta", "Uniform"]
-        if _dist_type_pcm in (PCMDistribution.BETA, PCMDistribution.BETA_BND):
-            _dist_type = "Beta"
-            _dist_parms_pcm = (
-                (
-                    np.array([0.5, 1, 0, 1], float)
-                    if _dist_type_pcm == PCMDistribution.BETA_BND
-                    else DEFAULT_BETA_DIST_PARMS
+        dist_type_: Literal["Beta", "Uniform"]
+        if dist_type_pcm in {PCMDistribution.BETA, PCMDistribution.BETA_BND}:
+            dist_type_ = "Beta"
+            if dist_type_pcm == PCMDistribution.BETA_BND:
+                dist_parms_pcm = (
+                    DEFAULT_BETA_BND_DIST_PARMS
+                    if dist_parms_pcm is None  # Eliminated by converter
+                    else dist_parms_pcm
+                )
+                dist_parms_ = beta_located_bound(dist_parms_pcm)
+            else:
+                dist_parms_ = (
+                    DEFAULT_BETA_DIST_PARMS
+                    if dist_parms_pcm is None
+                    else dist_parms_pcm
                 )
-                if _dist_parms_pcm is None or not len(_dist_parms_pcm)
-                else _dist_parms_pcm
-            )
-            _dist_parms = beta_located_bound(_dist_parms_pcm)
 
         else:
-            _dist_type = "Uniform"
-            _dist_parms = (
+            dist_type_ = "Uniform"
+            dist_parms_ = (
                 DEFAULT_DIST_PARMS
-                if _dist_parms_pcm is None or not len(_dist_parms_pcm)
-                else _dist_parms_pcm
+                if dist_parms_pcm is None or not len(dist_parms_pcm)
+                else dist_parms_pcm
             )
 
-        _pcm_rng = MultithreadedRNG(
-            _pcm_array,
-            dist_type=_dist_type,
-            dist_parms=_dist_parms,
+        MultithreadedRNG(
+            pcm_array,
+            dist_type=dist_type_,
+            dist_parms=dist_parms_,
             seed_sequence=_pcm_rng_seed_seq,
             nthreads=_nthreads,
-        )
-        _pcm_rng.fill()
-        del _pcm_rng
+        ).fill()
 
-    if _dist_type_pcm == PCMDistribution.BETA_BND:
-        _beta_min, _beta_max = _dist_parms_pcm[2:]
-        _pcm_array = (_beta_max - _beta_min) * _pcm_array + _beta_min
-        del _beta_min, _beta_max
+    if dist_type_pcm == PCMDistribution.BETA_BND:
+        beta_min, beta_max = dist_parms_pcm[2:]
+        pcm_array = (beta_max - beta_min) * pcm_array + beta_min
+        del beta_min, beta_max
 
-    if _dist_firm2_pcm == FM2Constraint.SYM:
-        _pcm_array = np.column_stack((_pcm_array,) * _frmshr_array.shape[1])
-    if _dist_firm2_pcm == FM2Constraint.MNL:
+    if dist_firm2_pcm == FM2Constraint.SYM:
+        pcm_array = np.column_stack((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:
+        if dist_type_pcm == PCMDistribution.EMPR:
             print(
                 "NOTE: Estimated Firm 2 parameters will not be consistent with "
                 "the empirical distribution of margins in the source data. For "
                 "consistency, respecify pcm_spec.firm2_pcm_constraint = FM2Constraint.IID."
             )
-        _purchase_prob_array = _aggregate_purchase_prob * _frmshr_array
+        purchase_prob_array = _aggregate_purchase_prob * _frmshr_array
 
-        _pcm_array[:, [1]] = np.divide(
+        pcm_array[:, [1]] = np.divide(
             np.einsum(
                 "ij,ij,ij->ij",
                 _price_array[:, [0]],
-                _pcm_array[:, [0]],
-                1 - _purchase_prob_array[:, [0]],
+                pcm_array[:, [0]],
+                1 - purchase_prob_array[:, [0]],
             ),
             np.einsum(
-                "ij,ij->ij", _price_array[:, [1]], 1 - _purchase_prob_array[:, [1]]
+                "ij,ij->ij", _price_array[:, [1]], 1 - purchase_prob_array[:, [1]]
             ),
         )
 
-        _mnl_test_array = _pcm_array[:, 1].__ge__(0) & _pcm_array[:, 1].__le__(1)
+        mnl_test_array = (pcm_array[:, 1] >= 0) & (pcm_array[:, 1] <= 1)
     else:
-        _mnl_test_array = np.ones(len(_pcm_array), dtype=bool)
+        mnl_test_array = np.ones(len(pcm_array), dtype=bool)
 
-    return MarginDataSample(_pcm_array, _mnl_test_array)
+    return MarginDataSample(pcm_array, mnl_test_array)
 
 
 def _beta_located(
@@ -790,8 +773,8 @@ def _beta_located(
 
     """
 
-    _mul = -1 + _mu * (1 - _mu) / _sigma**2
-    return np.array([_mu * _mul, (1 - _mu) * _mul], float)
+    mul = -1 + _mu * (1 - _mu) / _sigma**2
+    return np.array([_mu * mul, (1 - _mu) * mul], float)
 
 
 def beta_located_bound(_dist_parms: ArrayDouble, /) -> ArrayDouble:
@@ -822,5 +805,5 @@ def beta_located_bound(_dist_parms: ArrayDouble, /) -> ArrayDouble:
     .. [8] NIST, Beta Distribution. https://www.itl.nist.gov/div898/handbook/eda/section3/eda366h.htm
     """  # noqa: RUF002
 
-    _bmu, _bsigma, _bmin, _bmax = _dist_parms
-    return _beta_located((_bmu - _bmin) / (_bmax - _bmin), _bsigma / (_bmax - _bmin))
+    bmu, bsigma, bmin, bmax = _dist_parms
+    return _beta_located((bmu - bmin) / (bmax - bmin), bsigma / (bmax - bmin))