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

mergeron/examples/investigations_stats_sim_tables.py

@@ -19,13 +19,14 @@ import tables as ptb  # type: ignore
 from attrs import evolve
 
 import mergeron.core.ftc_merger_investigations_data as fid
-import mergeron.core.guidelines_standards as gsf
+import mergeron.core.guidelines_standards as gsl
 import mergeron.gen.data_generation as dgl
 import mergeron.gen.guidelines_tests as gtl
 import mergeron.gen.investigations_stats as isl
 from mergeron import DATA_DIR
 from mergeron.core.guidelines_standards import GuidelinesStandards
 from mergeron.core.proportions_tests import propn_ci
+from mergeron.gen import PCMConstants, PCMSpec, RECConstants, ShareSpec, SHRConstants
 
 if not sys.warnoptions:
     warnings.simplefilter("ignore")  # , category="RuntimeWarning")
@@ -41,7 +42,7 @@ def invres_stats_sim_setup(
     _invdata: fid.INVData,
     _data_period: str,
     _merger_class: isl.INDGRPConstants | isl.EVIDENConstants,
-    _invres_parm_vec: gsf.GuidelinesSTD,
+    _invres_parm_vec: gsl.GuidelinesSTD,
     _sample_spec: dgl.MarketSampleSpec,
     _invres_stats_kwargs: Mapping[str, Any] | None = None,
     /,
@@ -86,9 +87,9 @@ def invres_stats_sim_setup(
 
     _sample_spec_here = evolve(
         _sample_spec,
-        share_spec=dgl.ShareSpec(
-            dgl.RECConstants.INOUT,
-            dgl.SHRConstants.DIR_FLAT,
+        share_spec=ShareSpec(
+            RECConstants.INOUT,
+            SHRConstants.DIR_FLAT,
             None,
             _invres_cnts_obs_byfirmcount_array[:-1, 1],
         ),
@@ -96,11 +97,7 @@ def invres_stats_sim_setup(
 
     # Generate simulated rates
     _start_time = datetime.now()
-    (
-        _invres_cnts_sim_byfirmcount_array,
-        _invres_cnts_sim_bydelta_array,
-        _invres_cnts_sim_byconczone_array,
-    ) = gtl.sim_invres_cnts_ll(
+    _upp_tests_counts = gtl.sim_invres_cnts_ll(
         _invres_parm_vec, _sample_spec_here, _invres_stats_kwargs
     )
     _total_duration = datetime.now() - _start_time
@@ -118,7 +115,7 @@ def invres_stats_sim_setup(
             "hcol_width": 54,
             "notewidth": 0.63,
             "obs_array": _invres_cnts_obs_byfirmcount_array,
-            "sim_array": _invres_cnts_sim_byfirmcount_array,
+            "sim_array": _upp_tests_counts.by_firm_count,
         },
         isl.StatsGrpSelector.DL: {
             "desc": Rf"{_test_regime.capitalize()} rates by range of $\Delta HHI$",
@@ -137,7 +134,7 @@ def invres_stats_sim_setup(
                 isl.LTX_ARRAY_LINEEND,
             )),
             "obs_array": _invres_cnts_obs_bydelta_array,
-            "sim_array": _invres_cnts_sim_bydelta_array,
+            "sim_array": _upp_tests_counts.by_delta,
         },
         isl.StatsGrpSelector.ZN: {
             "desc": f"{_test_regime.capitalize()} rates by Approximate Presumption Zone",
@@ -149,7 +146,7 @@ def invres_stats_sim_setup(
             "hcol_width": 190,
             "notewidth": 0.96,
             "obs_array": _invres_cnts_obs_byconczone_array,
-            "sim_array": _invres_cnts_sim_byconczone_array,
+            "sim_array": _upp_tests_counts.by_conczone,
         },
     }
 
@@ -180,7 +177,7 @@ def invres_stats_sim_render(
     _merger_class: isl.INDGRPConstants | isl.EVIDENConstants,
     _stats_group: isl.StatsGrpSelector,
     _stats_group_dict_sub: Mapping[str, Any],
-    _invres_parm_vec: gsf.GuidelinesSTD,
+    _invres_parm_vec: gsl.GuidelinesSTD,
     _sim_test_regime: gtl.UPPTestRegime,
     _stats_table_file: TextIOWrapper,
     /,
@@ -192,9 +189,9 @@ def invres_stats_sim_render(
         for _g, _h in (("obs_array", -2), ("sim_array", -5))
     )
 
-    _invres_select, _, _ = _sim_test_regime
+    _invres_select = _sim_test_regime.resolution
     (
-        _stats_table_content.test_regime,
+        _stats_table_content.test_res,
         _stats_table_content.obs_merger_class,
         _stats_table_content.obs_period,
     ) = (_invres_select.capitalize(), _merger_class, _data_period.split("-"))
@@ -214,7 +211,7 @@ def invres_stats_sim_render(
         R"estimated by the Wilson method, given the",
         "reported numbers of investigated mergers and cleared mergers",
         _stats_group_dict_sub["desc"].replace(
-            f"{_stats_table_content.test_regime} rates ", ""
+            f"{_stats_table_content.test_res} rates ", ""
         ),
         isl.LTX_ARRAY_LINEEND,
     ))
@@ -224,7 +221,7 @@ def invres_stats_sim_render(
         propn_ci(0.50 * _eg_count, _eg_count, method="Exact")
     )
     _stats_sim_notestr = " ".join((
-        Rf"\(\cdot\) Simulated {_stats_table_content.test_regime} rates are estimated by",
+        Rf"\(\cdot\) Simulated {_stats_table_content.test_res} rates are estimated by",
         "Monte Carlo integration over generated data representing",
         Rf"{_sim_sample_sz:,d} hypothetical mergers. Thus,",
         R"for a subset of simulations with a relative frequency",
@@ -315,7 +312,7 @@ def invres_stats_sim_render(
         f"{g} {isl.LTX_ARRAY_LINEEND}" for g in _invres_stats_hdr_list
     ])
     _stats_table_content.stats_cis = "".join([
-        f"{' & '.join(g)} {isl.LTX_ARRAY_LINEEND}" for g in _invres_stats_dat_list
+        f"{" & ".join(g)} {isl.LTX_ARRAY_LINEEND}" for g in _invres_stats_dat_list
     ])
     # Print to console
     isl.stats_print_rows(_invres_stats_hdr_list, _invres_stats_dat_list)
@@ -333,7 +330,7 @@ def invres_stats_sim_render(
     # Exclude results of IPR tests
     _stats_sim_dat_list = [_f[:-1] for _f in _stats_sim_dat_list]
     _stats_table_content.stats_sim = "".join([
-        f"{' & '.join(g)} {isl.LTX_ARRAY_LINEEND}" for g in _stats_sim_dat_list
+        f"{" & ".join(g)} {isl.LTX_ARRAY_LINEEND}" for g in _stats_sim_dat_list
     ])
     # Print to console
     isl.stats_print_rows(_stats_sim_hdr_list, _stats_sim_dat_list)
@@ -362,8 +359,7 @@ if __name__ == "__main__":
     )
 
     sample_sz_base = 10**7
-    pr_sym_spec = dgl.PRIConstants.SYM
-    pcm_dist_type, pcm_dist_parms = dgl.PCMConstants.EMPR, np.empty(2)
+    pcm_dist_type, pcm_dist_parms = PCMConstants.EMPR, None
 
     save_data_to_file_flag = False
     save_data_to_file: gtl.SaveData = False
@@ -379,8 +375,8 @@ if __name__ == "__main__":
         save_data_to_file = (True, h5datafile, "/")
 
     sim_test_regime = (
-        (isl.PolicySelector.CLRN, gtl.GUPPIWghtngSelector.MAX, None),
-        (isl.PolicySelector.ENFT, gtl.GUPPIWghtngSelector.OSD, None),
+        (isl.PolicySelector.CLRN, gtl.UPPAggrSelector.MAX, None),
+        (isl.PolicySelector.ENFT, gtl.UPPAggrSelector.OSD, None),
     )[1]
     invres_stats_kwargs = {"sim_test_regime": sim_test_regime}
 
@@ -406,17 +402,14 @@ if __name__ == "__main__":
             mkt_sample_spec = dgl.MarketSampleSpec(
                 sample_sz_base,
                 invres_parm_vec.rec,
-                pr_sym_spec,
-                pcm_spec=dgl.PCMSpec(
-                    pcm_dist_type, dgl.FM2Constants.MNL, pcm_dist_parms
-                ),
+                pcm_spec=PCMSpec(pcm_dist_type, dgl.FM2Constants.MNL, pcm_dist_parms),
                 hsr_filing_test_type=dgl.SSZConstants.HSR_NTH,
             )
 
             # A file to write tables to, and a hierarchy under which to store the data
             if save_data_to_file:
                 h5hier_pat = re.compile(r"\W")
-                h5hier = f"/{h5hier_pat.sub('_', f'{merger_class} {study_period}')}"
+                h5hier = f"/{h5hier_pat.sub("_", f"{merger_class} {study_period}")}"
                 save_data_to_file = (True, save_data_to_file[1], h5hier)
 
             table_dottex_name = invres_stats_sim_setup(

mergeron/examples/safeharbor_boundaries_for_mergers_with_asymmetric_shares.py

@@ -24,7 +24,7 @@ from numpy import (
     vstack,
 )
 
-import mergeron.core.guidelines_standards as gsf
+import mergeron.core.guidelines_standards as gsl
 from mergeron import DATA_DIR
 
 PROG_PATH = Path(__file__)
@@ -40,7 +40,7 @@ def plot_delta_boundaries(
         raise ValueError(f"Recapture specification must be one of, {_recspecs!r}")
 
     print("ΔHHI safeharbor boundary")
-    _plt, _my_fig1, _ax1, _ = gsf.boundary_plot()
+    _plt, _my_fig1, _ax1, _ = gsl.boundary_plot()
 
     _dh_bar, _r_bar, _guppi_bench, _divr_bench, _, _ = get_hmg_standards_by_key(
         _guppi_bench_key
@@ -52,7 +52,7 @@ def plot_delta_boundaries(
         if _dh_bound in (300, 500):
             continue
 
-        _dh_safeharb, _dh_prob = gsf.delta_hhi_boundary(_dh_bound / 1e4)
+        _dh_safeharb, _dh_prob = gsl.delta_hhi_boundary(_dh_bound / 1e4)
         _dh_dat_x, _dh_dat_y = zip(*_dh_safeharb, strict=True)
         if _dh_bound == 100:
             _lwval, _lsval = 0.75, "-"
@@ -69,8 +69,8 @@ def plot_delta_boundaries(
         )
 
         if _print_guppi_max_bndry_envs_flag:
-            _symshr = gsf.round_cust(sqrt(_dh_bound / 2e4))
-            _dstar = gsf.round_cust(_symshr / (1 - _symshr))
+            _symshr = gsl.round_cust(sqrt(_dh_bound / 2e4))
+            _dstar = gsl.round_cust(_symshr / (1 - _symshr))
             _m_star = _guppi_bench / (_dstar * _r_bar)
             print(_symshr, _dstar, _m_star, _r_bar, _guppi_bench, "...", end="")
 
@@ -150,10 +150,10 @@ def plot_guppi_boundaries(  # noqa PLR0915
     )
 
     # First we get the data for the ΔHHI benchmark we want to plot
-    _dh_safeharb, _dh_prob = gsf.delta_hhi_boundary(_dh_bar)
+    _dh_safeharb, _dh_prob = gsl.delta_hhi_boundary(_dh_bar)
     _dh_dat_x, _dh_dat_y = zip(*_dh_safeharb, strict=True)
 
-    _plt, _my_fig1, _ax1, _set_axis_def = gsf.boundary_plot()
+    _plt, _my_fig1, _ax1, _set_axis_def = gsl.boundary_plot()
     _plt.delaxes(_ax1)
     del _my_fig1, _ax1
 
@@ -316,13 +316,13 @@ def plot_guppi_boundaries(  # noqa PLR0915
     #  print("Diversion ratio bound")
     if _divr_bench < _r_bar:
         _m_star_bench = _guppi_bench / _divr_bench
-        _s_mid_bench = gsf.shr_from_gbd(
+        _s_mid_bench = gsl.shr_from_gbd(
             _guppi_bench, m_star=_m_star_bench, r_bar=_r_bar
         )
-        _delta_star = gsf.critical_shrratio(
+        _delta_star = gsl.critical_shrratio(
             _guppi_bench, m_star=_m_star_bench, r_bar=_r_bar
         )
-        (guppi_boundary_data, guppi_boundary_area) = gsf.shrratio_mgnsym_boundary_max(
+        (guppi_boundary_data, guppi_boundary_area) = gsl.shrratio_boundary_max(
             _delta_star
         )
         _x_drt, _y_drt = zip(*guppi_boundary_data, strict=True)
@@ -451,16 +451,16 @@ def get_hmg_standards_by_key(_guppi_bench_key: str, /) -> tuple:
     match _guppi_bench_key:
         case "DOJATR":
             return (
-                *(_tmp := gsf.GuidelinesStandards(2010).safeharbor[:2]),
+                *(_tmp := gsl.GuidelinesStandards(2010).safeharbor[:2]),
                 0.05,
                 _tmp[-1],
                 None,
                 None,
             )
         case "DH100":
-            return gsf.GuidelinesStandards(2010).safeharbor
+            return gsl.GuidelinesStandards(2010).safeharbor
         case "DH50":
-            return gsf.GuidelinesStandards(1992).safeharbor
+            return gsl.GuidelinesStandards(1992).safeharbor
         case _:
             raise ValueError(
                 f"GUPPI benchmark key must be one of, {guppi_benchmark_keys!r}"

mergeron/examples/safeharbor_boundaries_for_symmetric_firm_mergers.py

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

mergeron/examples/sound_guppi_safeharbor.py

@@ -7,15 +7,28 @@ from typing import Literal
 import numpy as np
 import tables as ptb  # type: ignore
 
-import mergeron.core.guidelines_standards as gsf
+import mergeron.core.guidelines_standards as gsl
 import mergeron.gen.data_generation as dgl
 import mergeron.gen.guidelines_tests as gtl
 import mergeron.gen.investigations_stats as isl
 from mergeron import DATA_DIR
+from mergeron.gen import (
+    EMPTY_ARRAY_DEFAULT,
+    FCOUNT_WTS_DEFAULT,
+    MarketSampleSpec,
+    PCMConstants,
+    PCMSpec,
+    ShareSpec,
+    SHRConstants,
+)
 
 tests_of_interest: tuple[gtl.UPPTestRegime, ...] = (
-    (isl.PolicySelector.CLRN, gtl.GUPPIWghtngSelector.MAX, gtl.GUPPIWghtngSelector.MAX),
-    (isl.PolicySelector.ENFT, gtl.GUPPIWghtngSelector.MIN, gtl.GUPPIWghtngSelector.MIN),
+    gtl.UPPTestRegime(
+        isl.PolicySelector.CLRN, gtl.UPPAggrSelector.MAX, gtl.UPPAggrSelector.MAX
+    ),
+    gtl.UPPTestRegime(
+        isl.PolicySelector.ENFT, gtl.UPPAggrSelector.MIN, gtl.UPPAggrSelector.MIN
+    ),
 )
 
 PROG_PATH = Path(__file__)
@@ -24,9 +37,7 @@ PROG_PATH = Path(__file__)
 def analyze_invres_data(
     _sample_size: int = 10**6,
     _hmg_std_pub_year: Literal[1992, 2010, 2023] = 1992,
-    _test_sel: tuple[
-        str, gtl.GUPPIWghtngSelector, gtl.GUPPIWghtngSelector | None
-    ] = tests_of_interest[1],
+    _test_sel: gtl.UPPTestRegime = tests_of_interest[1],
     /,
     *,
     save_data_to_file_flag: bool = False,
@@ -50,7 +61,7 @@ def analyze_invres_data(
         If True, simulated data are save to file (hdf5 format)
 
     """
-    _invres_parm_vec = gsf.GuidelinesStandards(_hmg_std_pub_year).presumption
+    _invres_parm_vec = gsl.GuidelinesStandards(_hmg_std_pub_year).presumption
 
     _save_data_to_file: gtl.SaveData = False
     if save_data_to_file_flag:
@@ -61,10 +72,10 @@ def analyze_invres_data(
         _h5_datafile = ptb.open_file(
             DATA_DIR / PROG_PATH.with_suffix(".h5").name,
             mode="w",
-            title=f"GUPPI Safeharbor {_test_sel[0].capitalize()} Rate Module",
+            title=f"GUPPI Safeharbor {_test_sel.resolution.capitalize()} Rate Module",
             filters=_blosc_filters,
         )
-        _h5_hier = f"/{_h5_hier_pat.sub('_', f'Standards from {_hmg_std_pub_year} Guidelines')}"
+        _h5_hier = f"/{_h5_hier_pat.sub("_", f"Standards from {_hmg_std_pub_year} Guidelines")}"
 
         _save_data_to_file = (True, _h5_datafile, _h5_hier)
 
@@ -77,11 +88,7 @@ def analyze_invres_data(
         [
             tuple(
                 zip(
-                    (
-                        dgl.PCMConstants.UNI,
-                        dgl.PCMConstants.BETA,
-                        dgl.PCMConstants.EMPR,
-                    ),
+                    (PCMConstants.UNI, PCMConstants.BETA, PCMConstants.EMPR),
                     (
                         np.array((0, 1), dtype=np.float64),
                         np.array((10, 10), dtype=np.float64),
@@ -106,24 +113,23 @@ def analyze_invres_data(
 
         print()
         print(
-            f"Simulated {_test_sel[0].capitalize()} rates by range of ∆HHI",
+            f"Simulated {_test_sel.resolution.capitalize()} rates by range of ∆HHI",
             f'recapture-rate calibrated, "{_recapture_spec_test}"',
             f'Firm 2 margins, "{_pcm_dist_firm2_test}"',
             f"and margins distributed {_pcm_dist_type_test}{_pcm_dist_parms_test}:",
             sep="; ",
         )
 
-        _ind_sample_spec = dgl.MarketSampleSpec(
+        _ind_sample_spec = MarketSampleSpec(
             _sample_size,
             _invres_parm_vec.rec,
-            dgl.PRIConstants.SYM,
-            share_spec=dgl.ShareSpec(
+            share_spec=ShareSpec(
                 _recapture_spec_test,
-                dgl.SHRConstants.UNI,
-                dgl.EMPTY_ARRAY_DEFAULT,
-                dgl.FCOUNT_WTS_DEFAULT,
+                SHRConstants.UNI,
+                EMPTY_ARRAY_DEFAULT,
+                FCOUNT_WTS_DEFAULT,
             ),
-            pcm_spec=dgl.PCMSpec(
+            pcm_spec=PCMSpec(
                 _pcm_dist_type_test, _pcm_dist_firm2_test, _pcm_dist_parms_test
             ),
         )
@@ -134,11 +140,8 @@ def analyze_invres_data(
         }
 
         _start_time = datetime.now()
-        (
-            _invres_rate_sim_byfirmcount_array,
-            _invres_rate_sim_bydelta_array,
-            _invres_rate_sim_byconczone_array,
-        ) = gtl.sim_invres_cnts_ll(
+
+        upp_test_counts = gtl.sim_invres_cnts_ll(
             _invres_parm_vec, _ind_sample_spec, _invres_cnts_kwargs
         )
         _run_duration = datetime.now() - _start_time
@@ -149,7 +152,7 @@ def analyze_invres_data(
         )
 
         _stats_hdr_list, _stats_dat_list = isl.latex_tbl_invres_stats_1dim(
-            _invres_rate_sim_bydelta_array,
+            upp_test_counts.by_delta,
             return_type_sel=isl.StatsReturnSelector.RPT,
             sort_order=isl.SortSelector.REV,
         )

mergeron/examples/testIntrinsicClearanceRates.py

@@ -24,28 +24,28 @@ d_bar = 0.2  # 0.2  # r_bar  # g_bar  # 0.8 * 0.125 / (1 - 0.125)
 sample_sz = 10**8
 
 
-def icr_gsh_sym(_ssz: int = sample_sz) -> NDArray[float]:
+def icr_gsh_sym(_ssz: int = sample_sz) -> NDArray[np.float64]:
     """With symmetric shares, margins, and prices; closed-form integrand."""
     _m_lim = g_bar / d_bar
     _m_star = _m_lim + (1.0 - _m_lim) * rng.uniform(size=(_ssz, 1))
     _d_star = g_bar / (r_bar * _m_star)
     _divr_limit_prob = 2 * g_bar / (r_bar + d_bar)
-    _gsf_bound_prob = 2 * (1 - _m_lim) * (_d_star / (1 + _d_star)).mean()
-    return np.array([_ssz, _divr_limit_prob + _gsf_bound_prob, np.nan, np.nan])
+    _guppi_bound_prob = 2 * (1 - _m_lim) * (_d_star / (1 + _d_star)).mean()
+    return np.array([_ssz, _divr_limit_prob + _guppi_bound_prob, np.nan, np.nan])
 
 
-def icr_gsh_asymmshr(_ssz: int = sample_sz) -> NDArray[float]:
+def icr_gsh_asymmshr(_ssz: int = sample_sz) -> NDArray[np.float64]:
     """With symmetric margins and prices, unequal shares; closed-form integrand."""
     _m_lim = g_bar / d_bar
     _m_star = _m_lim + (1.0 - _m_lim) * rng.random(size=(_ssz, 1))
 
     _d_star = g_bar / (r_bar * _m_star)
     _divr_limit_prob = 2 * (g_bar / r_bar) * d_bar / (r_bar + d_bar)
-    _gsf_bound_prob = 2 * (1 - _m_lim) * (_d_star**2 / (1 + _d_star)).mean()
-    return np.array([_ssz, _divr_limit_prob + _gsf_bound_prob, np.nan, np.nan])
+    _guppi_bound_prob = 2 * (1 - _m_lim) * (_d_star**2 / (1 + _d_star)).mean()
+    return np.array([_ssz, _divr_limit_prob + _guppi_bound_prob, np.nan, np.nan])
 
 
-def gen_qtyshr(_ssz: int = sample_sz, *, sym_flag: bool = False) -> NDArray[float]:
+def gen_qtyshr(_ssz: int = sample_sz, *, sym_flag: bool = False) -> NDArray[np.float64]:
     """Unequal shares and margins, and symmetric prices; indicator-function integrand."""
     if sym_flag:
         # for symmetric shares
@@ -57,7 +57,7 @@ def gen_qtyshr(_ssz: int = sample_sz, *, sym_flag: bool = False) -> NDArray[floa
     return _mktshr_array
 
 
-def icr_gsh_asymmshrmgn(_ssz: int = sample_sz) -> NDArray[float]:
+def icr_gsh_asymmshrmgn(_ssz: int = sample_sz) -> NDArray[np.float64]:
     """With symmetric prices, unequal shares and margins; indicator-function integrand."""
 
     _shr_sym_flag = False
@@ -98,17 +98,17 @@ def icr_gsh_asymmshrmgn(_ssz: int = sample_sz) -> NDArray[float]:
     _divr_test = _divr_array.max(axis=1) < d_bar
     _pcm_min_test = _pcm_array.min(axis=1) >= (g_bar / d_bar)
     _divr_limit_test = _gbd_test & _divr_test & np.logical_not(_pcm_min_test)
-    _gsf_not_in_deltah = np.logical_not(_delta_test) & _gbd_test & _divr_test
+    _gbd_not_in_deltah = np.logical_not(_delta_test) & _gbd_test & _divr_test
 
     _scount = len(_gbd_test)
-    _gsf_prob = len(_gbd_test[_gbd_test & _divr_test]) / _scount
+    _gbd_prob = len(_gbd_test[_gbd_test & _divr_test]) / _scount
     _deltah_prob = len(_gbd_test[_delta_test]) / _scount
-    _cum_clr_prob = len(_gbd_test[_delta_test | _gsf_not_in_deltah]) / _scount
+    _cum_clr_prob = len(_gbd_test[_delta_test | _gbd_not_in_deltah]) / _scount
 
     del _guppi_array, _divr_array, _pcm_array
     del _gbd_test, _divr_test, _pcm_min_test, _divr_limit_test
 
-    return np.array([_scount, _gsf_prob, _deltah_prob, _cum_clr_prob])
+    return np.array([_scount, _gbd_prob, _deltah_prob, _cum_clr_prob])
 
 
 if __name__ == "__main__":

mergeron/examples/visualize_guidelines_tests.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import gc
 from contextlib import suppress
+from dataclasses import fields
 from pathlib import Path
 from typing import Final
 
@@ -21,12 +22,13 @@ from matplotlib import cm, colors
 from matplotlib.ticker import StrMethodFormatter
 from numpy.typing import NDArray
 
-import mergeron.core.guidelines_standards as gsf
+import mergeron.core.guidelines_standards as gsl
 import mergeron.gen.data_generation as dgl
 import mergeron.gen.guidelines_tests as gtl
 import mergeron.gen.investigations_stats as isl
 from mergeron import DATA_DIR
 from mergeron.core.pseudorandom_numbers import DIST_PARMS_DEFAULT
+from mergeron.gen import ShareSpec
 
 PROG_PATH = Path(__file__)
 
@@ -37,14 +39,10 @@ blosc_filters = ptb.Filters(
 
 
 def gen_plot_data(
-    _market_data: dgl.MarketsSample,
-    _std_vec: gsf.GuidelinesSTD,
-    _pcm_firm2_star: float = 0.30,
-    _test_regime: gtl.UPPTestRegime = (
-        isl.PolicySelector.CLRN,
-        gtl.GUPPIWghtngSelector.MAX,
-        None,
-    ),
+    _market_data: dgl.MarketDataSample,
+    _std_vec: gsl.GuidelinesSTD,
+    _pcm_firm2_star: float,
+    _test_regime: gtl.UPPTestRegime,
     /,
     *,
     h5handle: ptb.File | None = None,
@@ -59,14 +57,19 @@ def gen_plot_data(
     ))
     del _m1
 
-    _upp_tests = gtl.gen_upp_arrays(
+    _upp_test_raw = gtl.gen_upp_arrays(
         _std_vec,
-        dgl.MarketsSample(_market_data.frmshr_array, _pcm_array, *_market_data[2:]),
+        dgl.MarketDataSample(*[
+            _pcm_array.astype(_f.type)
+            if _f.name == "pcm_array"
+            else getattr(_market_data, _f.name)
+            for _f in fields(_market_data)
+        ]),
         _test_regime,
     )
 
-    _gbd_test_rows = np.where(_upp_tests.guppi_test_simple)[0]
-    del _upp_tests
+    _gbd_test_rows = np.where(_upp_test_raw.guppi_test_simple)[0]
+    del _upp_test_raw
 
     _qtyshr_firm1_inv, _qtyshr_firm2_inv = (
         _market_data.frmshr_array[_gbd_test_rows][:, [0]],
@@ -99,7 +102,7 @@ def gen_plot_data(
             )
 
     _pcm_sorter = np.argsort(_pcm_plotter, axis=0)
-    if _test_regime[0] != isl.PolicySelector.CLRN:
+    if test_regime.resolution != isl.PolicySelector.CLRN:
         _pcm_sorter = _pcm_sorter[::-1, :]
     _qtyshr_firm1_plotter = _qtyshr_firm1_inv[_pcm_sorter]
     _qtyshr_firm2_plotter = _qtyshr_firm2_inv[_pcm_sorter]
@@ -118,14 +121,16 @@ def gen_plot_data(
 
 # Generate market data
 def _main(
-    _hmg_pub_year: gsf.HMGPubYear,
+    _hmg_pub_year: gsl.HMGPubYear,
     _market_sample_spec: dgl.MarketSampleSpec,
     _test_regime: gtl.UPPTestRegime,
     _save_data_to_file: gtl.SaveData,
 ) -> None:
     guidelins_std_vec = getattr(
-        gsf.GuidelinesStandards(_hmg_pub_year),
-        "safeharbor" if _test_regime[0] == isl.PolicySelector.ENFT else "presumption",
+        gsl.GuidelinesStandards(_hmg_pub_year),
+        "safeharbor"
+        if test_regime.resolution == isl.PolicySelector.ENFT
+        else "presumption",
     )
 
     _, _r_bar, _g_bar, _divr_bar, *_ = guidelins_std_vec
@@ -140,14 +145,14 @@ def _main(
     )
     _fig_norm = colors.Normalize(0.0, 1.0)
     _cmap_kwargs = {"cmap": "cividis", "norm": _fig_norm}
-    _plt, _, _, _set_axis_def = gsf.boundary_plot()
+    _plt, _, _, _set_axis_def = gsl.boundary_plot()
 
     _fig_2dsg = _plt.figure(figsize=(8.5, 9.5), dpi=600)
 
     _fig_grid = _fig_2dsg.add_gridspec(
         nrows=1, ncols=2, figure=_fig_2dsg, width_ratios=[6, 0.125], wspace=0.0
     )
-    _fig_grid_gsf = _fig_grid[0, 0].subgridspec(
+    _fig_grid_gbd = _fig_grid[0, 0].subgridspec(
         nrows=3, ncols=1, wspace=0, hspace=0.125
     )
 
@@ -156,7 +161,7 @@ def _main(
         _g_bar / _divr_bar,
         _g_bar / _r_bar,
     )):
-        _ax_now = _fig_2dsg.add_subplot(_fig_grid_gsf[_ax_row, 0])
+        _ax_now = _fig_2dsg.add_subplot(_fig_grid_gbd[_ax_row, 0])
         _ax_now = _set_axis_def(_ax_now, mktshares_plot_flag=True)
         _ax_now.set_xlabel(None)
         _ax_now.set_ylabel(None)
@@ -237,10 +242,10 @@ def _main(
 
     _base_name = DATA_DIR / "{}_{}Rate_{}gbar{}PCT_{}Recapture".format(
         PROG_PATH.stem,
-        f"{_test_regime[0]}".capitalize(),
+        f"{test_regime.resolution}".capitalize(),
         _hmg_pub_year,
         f"{_g_bar * 100:02.0f}",
-        market_sample_spec.share_spec[0],
+        market_sample_spec.share_spec.recapture_spec,
     )
     _my_fig_2dsg_savepath = DATA_DIR / f"{_base_name}_2DScatterGrid.pdf"
     print(f"Save 2D plot to, {f'"{_my_fig_2dsg_savepath}"'}")
@@ -250,14 +255,14 @@ def _main(
 if __name__ == "__main__":
     # Get Guidelines parameter values
     hmg_pub_year: Final = 2023
-    test_regime: gtl.UPPTestRegime = (
-        isl.PolicySelector.ENFT,
-        gtl.GUPPIWghtngSelector.MIN,
-        gtl.GUPPIWghtngSelector.MIN,
+    test_regime: gtl.UPPTestRegime = gtl.UPPTestRegime(
+        isl.PolicySelector.ENFT, gtl.UPPAggrSelector.MIN, gtl.UPPAggrSelector.MIN
     )
     r_bar = getattr(
-        gsf.GuidelinesStandards(hmg_pub_year),
-        "presumption" if test_regime[0] == isl.PolicySelector.ENFT else "safeharbor",
+        gsl.GuidelinesStandards(hmg_pub_year),
+        "presumption"
+        if test_regime.resolution == isl.PolicySelector.ENFT
+        else "safeharbor",
     ).rec
 
     sample_sz = 10**7
@@ -265,7 +270,7 @@ if __name__ == "__main__":
     market_sample_spec = dgl.MarketSampleSpec(
         sample_sz,
         r_bar,
-        share_spec=dgl.ShareSpec(
+        share_spec=ShareSpec(
             dgl.RECConstants.INOUT, dgl.SHRConstants.UNI, DIST_PARMS_DEFAULT, None
         ),
     )