mergeron 2024.738930.0__py3-none-any.whl → 2024.738936.2__py3-none-any.whl

mergeron/core/__init__.py

@@ -1,5 +1,5 @@
 from importlib.metadata import version
 
-from .. import _PKG_NAME
+from .. import _PKG_NAME  # noqa: TID252
 
 __version__ = version(_PKG_NAME)

mergeron/core/guidelines_standards.py

@@ -12,12 +12,12 @@ from .. import _PKG_NAME  # noqa: TID252
 __version__ = version(_PKG_NAME)
 
 import decimal
-from dataclasses import dataclass
 from typing import Any, Literal, TypeAlias
 
 import numpy as np
 from mpmath import mp, mpf  # type: ignore
 from numpy.typing import NDArray
+from scipy.spatial.distance import minkowski as distance_function
 
 mp.prec = 80
 mp.trap_complex = True
@@ -26,7 +26,6 @@ HMGPubYear: TypeAlias = Literal[1992, 2010, 2023]
 GuidelinesSTD = namedtuple("GuidelinesSTD", "delta rec guppi divr cmcr ipr")
 
 
-@dataclass
 class GuidelinesStandards:
     """
     Guidelines standards by Guidelines publication year
@@ -170,7 +169,7 @@ def lerp(
     /,
 ) -> float | mpf | NDArray[np.float64]:
     """
-    From the C++ standard function of the same name.
+    From the function of the same name in the C++ standard [2]_
 
     Constructs the weighted average, :math:`w_1 x_1 + w_2 x_2`, where
     :math:`w_1 = 1 - r` and :math:`w_2 = r`.
@@ -180,21 +179,35 @@ def lerp(
     _x1, _x2
         bounds :math:`x_1, x_2` to interpolate between.
     _r
-        interpolation weight :math:`r` assigned to :math:`x_2`.
+        interpolation weight :math:`r` assigned to :math:`x_2`
 
     Returns
     -------
-        The linear interpolation, or weighted average, :math:`x_1 (1 - r) + x_2 r`.
+        The linear interpolation, or weighted average,
+        :math:`x_1 + r \\cdot (x_1 - x_2) \\equiv (1 - r) \\cdot x_1 + r \\cdot x_2`.
 
     Raises
     ------
     ValueError
         If the interpolation weight is not in the interval, :math:`[0, 1]`.
 
+    References
+    ----------
+
+    .. [2] C++ Reference, https://en.cppreference.com/w/cpp/numeric/lerp
+
     """
+
     if not 0 <= _r <= 1:
         raise ValueError("Specified interpolation weight must lie in [0, 1].")
-    return _x2 * _r + _x1 * (1 - _r)
+    elif _r == 0:
+        return _x1
+    elif _r == 1:
+        return _x2
+    elif _r == 0.5:
+        return 1 / 2 * (_x1 + _x2)
+    else:
+        return _r * _x2 + (1 - _r) * _x1
 
 
 def gbd_from_dsf(
@@ -337,9 +350,7 @@ def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
     _fig = plt.figure(figsize=(5, 5), dpi=600)
     _ax_out = _fig.add_subplot()
 
-    def _set_axis_def(
-        _ax1: mpa._axes.Axes, /, mktshares_plot_flag: bool = False
-    ) -> mpa.Axes:
+    def _set_axis_def(_ax1: mpa.Axes, /, mktshares_plot_flag: bool = False) -> mpa.Axes:
         # Set the width of axis gridlines, and tick marks:
         # both axes, both major and minor ticks
         # Frame, grid, and facecolor
@@ -556,7 +567,7 @@ def delta_hhi_boundary(
 
 
 def combined_share_boundary(
-    _s_incpt: float = 0.0625, /, *, bdry_dps: int = 10
+    _s_intcpt: float = 0.0625, /, *, bdry_dps: int = 10
 ) -> tuple[NDArray[np.float64], float]:
     """
     Share combinations on the merging-firms' combined share boundary.
@@ -567,7 +578,7 @@ def combined_share_boundary(
 
     Parameters
     ----------
-    _s_incpt:
+    _s_intcpt:
         Merging-firms' combined share.
     bdry_dps
         Number of decimal places for rounding reported shares.
@@ -577,16 +588,16 @@ def combined_share_boundary(
         Array of share-pairs, area under boundary.
 
     """
-    _s_incpt = mpf(f"{_s_incpt}")
-    _s_mid = _s_incpt / 2
+    _s_intcpt = mpf(f"{_s_intcpt}")
+    _s_mid = _s_intcpt / 2
 
-    _s1_pts = (0, _s_mid, _s_incpt)
+    _s1_pts = (0, _s_mid, _s_intcpt)
     return (
         np.column_stack((
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
         )),
-        round(float(_s_incpt * _s_mid), bdry_dps),
+        round(float(_s_intcpt * _s_mid), bdry_dps),
     )
 
 
@@ -654,17 +665,17 @@ def shrratio_mgnsym_boundary_max(
     # of function call with other shrratio_mgnsym_boundary functions
     del _r_val
     _delta_star = mpf(f"{_delta_star}")
-    _s_incpt = _delta_star
+    _s_intcpt = _delta_star
     _s_mid = _delta_star / (1 + _delta_star)
 
-    _s1_pts = (0, _s_mid, _s_incpt)
+    _s1_pts = (0, _s_mid, _s_intcpt)
 
     return (
         np.column_stack((
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
         )),
-        round(float(_s_incpt * _s_mid), gbd_dps),  # simplified calculation
+        round(float(_s_intcpt * _s_mid), gbd_dps),  # simplified calculation
     )
 
 
@@ -714,7 +725,7 @@ def shrratio_mgnsym_boundary_min(
         )
 
     _delta_star = mpf(f"{_delta_star}")
-    _s_incpt = mpf("1.00")
+    _s_intcpt = mpf("1.00")
     _s_mid = _delta_star / (1 + _delta_star)
 
     if recapture_spec == "inside-out":
@@ -729,14 +740,14 @@ def shrratio_mgnsym_boundary_min(
                 _smin_nr / _guppi_bdry_env_dr,
                 _s_mid,
                 _smax_nr / _guppi_bdry_env_dr,
-                _s_incpt,
+                _s_intcpt,
             ),
             np.float64,
         )
 
         _gbd_area = (_smin_nr + (_smax_nr - _smin_nr) * _s_mid) / _guppi_bdry_env_dr
     else:
-        _s1_pts, _gbd_area = np.array((0, _s_mid, _s_incpt), np.float64), _s_mid
+        _s1_pts, _gbd_area = np.array((0, _s_mid, _s_intcpt), np.float64), _s_mid
 
     return np.column_stack((_s1_pts, _s1_pts[::-1])), round(float(_gbd_area), gbd_dps)
 
@@ -747,7 +758,7 @@ def shrratio_mgnsym_boundary_wtd_avg(
     /,
     *,
     avg_method: Literal["arithmetic", "geometric", "distance"] = "arithmetic",
-    wgtng_policy: Literal["own-share", "cross-product-share"] = "own-share",
+    wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
     recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
     gbd_dps: int = 5,
 ) -> tuple[NDArray[np.float64], float]:
@@ -819,9 +830,9 @@ def shrratio_mgnsym_boundary_wtd_avg(
     Parameters
     ----------
     _delta_star
-        GUPPI bound
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
     _r_val
-        Recapture ratio.
+        recapture ratio
     avg_method
         Whether "arithmetic", "geometric", or "distance".
     wgtng_policy
@@ -840,17 +851,18 @@ def shrratio_mgnsym_boundary_wtd_avg(
 
     if _delta_star > 1:
         raise ValueError(
-            "Invalid combination specified; "
-            "Margin-adjusted benchmark share ratio cannot exceed 1."
+            "Margin-adjusted benchmark share ratio, `_delta_star` cannot exceed 1."
         )
 
     _delta_star = mpf(f"{_delta_star}")
     _s_mid = _delta_star / (1 + _delta_star)
 
+    # initial conditions
     _gbdry_points = [(_s_mid, _s_mid)]
     _s_1_pre, _s_2_pre = _s_mid, _s_mid
     _s_2_oddval, _s_2_oddsum, _s_2_evnsum = True, 0, 0
 
+    # parameters for iteration
     _gbd_step_sz = mp.power(10, -gbd_dps)
     _theta = _gbd_step_sz * (10 if wgtng_policy == "cross-product-share" else 1)
     for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
@@ -871,8 +883,12 @@ def shrratio_mgnsym_boundary_wtd_avg(
                 else _s_1 / (1 - _s_2)
             )
 
-            _r = mp.fdiv(
-                _s_1 if wgtng_policy == "cross-product-share" else _s_2, _s_1 + _s_2
+            _r = (
+                mp.fdiv(
+                    _s_1 if wgtng_policy == "cross-product-share" else _s_2, _s_1 + _s_2
+                )
+                if wgtng_policy
+                else 0.5
             )
 
             match avg_method:
@@ -884,12 +900,12 @@ def shrratio_mgnsym_boundary_wtd_avg(
                     _delta_test = lerp(_de_1, _de_2, _r)
 
             if wgtng_policy == "cross-product-share":
-                test_flag, incr_decr = (_delta_test > _delta_star, -1)
+                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
             else:
-                test_flag, incr_decr = (_delta_test < _delta_star, 1)
+                _test_flag, _incr_decr = (_delta_test < _delta_star, 1)
 
-            if test_flag:
-                _s_2 += incr_decr * _gbd_step_sz
+            if _test_flag:
+                _s_2 += _incr_decr * _gbd_step_sz
             else:
                 break
 
@@ -917,13 +933,19 @@ def shrratio_mgnsym_boundary_wtd_avg(
     # Area under boundary
     _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
 
-    _gbdry_points = np.row_stack((
-        _gbdry_points,
-        (
-            mpf("0.0"),
-            _delta_star if wgtng_policy == "cross-product-share" else mpf("1.0"),
-        ),
-    )).astype(np.float64)
+    match wgtng_policy:
+        case "cross-product-share":
+            _s_intcpt = _delta_star
+        case "own-product-share":
+            _s_intcpt = mpf("1.0")
+        case None if avg_method == "distance":
+            _s_intcpt = _delta_star * mp.sqrt("2")
+        case _:
+            _s_intcpt = _s_2_pre
+
+    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
+        np.float64
+    )
     # Points defining boundary to point-of-symmetry
     return (
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
@@ -1010,13 +1032,13 @@ def shrratio_mgnsym_boundary_xact_avg(
     _gbdry_points_start = np.array([(_s_mid, _s_mid)])
     _s_1 = np.array(mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz), np.float64)
     if recapture_spec == "inside-out":
-        _s_incpt = mp.fdiv(
+        _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}"),
         )
-        _nr_t1 = 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)  # type: ignore
 
         _nr_sqrt_mdr = 4 * _delta_star * _r_val
         _nr_sqrt_mdr2 = _nr_sqrt_mdr * _r_val
@@ -1041,9 +1063,9 @@ def shrratio_mgnsym_boundary_xact_avg(
 
         _nr_t2_s1 = _nr_sqrt_s1sq + _nr_sqrt_s1 + _nr_sqrt_nos1
 
-        if not np.isclose(
-            np.einsum("i->", _nr_t2_mdr.astype(np.float64)),  # from mpf to float64
-            np.einsum("i->", _nr_t2_s1.astype(np.float64)),
+        if not np.isclose(  # type: ignore
+            np.einsum("i->", _nr_t2_mdr.astype(np.float64)),  # type: ignore from mpf to float64
+            np.einsum("i->", _nr_t2_s1.astype(np.float64)),  # type: ignore from mpf to float64
             rtol=0,
             atol=0.5 * gbd_dps,
         ):
@@ -1055,7 +1077,7 @@ def shrratio_mgnsym_boundary_xact_avg(
         _s_2 = (_nr_t1 - np.sqrt(_nr_t2_s1)) / (2 * _r_val)
 
     else:
-        _s_incpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
+        _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
         _s_2 = (
             (1 / 2)
             + _delta_star
@@ -1070,7 +1092,7 @@ def shrratio_mgnsym_boundary_xact_avg(
         )
 
     _gbdry_points_inner = np.column_stack((_s_1, _s_2))
-    _gbdry_points_end = np.array([(mpf("0.0"), _s_incpt)], np.float64)
+    _gbdry_points_end = np.array([(mpf("0.0"), _s_intcpt)], np.float64)
 
     _gbdry_points = np.row_stack((
         _gbdry_points_end,
@@ -1112,6 +1134,8 @@ def shrratio_mgnsym_boundary_avg(
     Share combinations along the average GUPPI boundary, with
     symmetric merging-firm margins.
 
+    Faster than calling shrratio_mgnsym_boundary_avg(wgtng_policy=None).
+
     Parameters
     ----------
     _delta_star
@@ -1119,7 +1143,7 @@ def shrratio_mgnsym_boundary_avg(
     _r_val
         Recapture ratio.
     avg_method
-        Whether "arithmetic", "geometric", or "root-mean-square".
+        Whether "arithmetic", "geometric", or "distance".
     recapture_spec
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
@@ -1138,7 +1162,7 @@ def shrratio_mgnsym_boundary_avg(
             "Margin-adjusted benchmark share ratio cannot exceed 1."
         )
 
-    if avg_method not in (_avgmthds := ("arithmetic", "geometric", "root-mean-square")):
+    if avg_method not in (_avgmthds := ("arithmetic", "geometric", "distance")):
         raise ValueError(
             f"Averarging method, {f'"{avg_method}"'} is invalid. "
             f"Must be one of, {_avgmthds!r}."
@@ -1152,18 +1176,21 @@ def shrratio_mgnsym_boundary_avg(
 
     _delta_star = mpf(f"{_delta_star}")
     _s_mid = _delta_star / (1 + _delta_star)
-    _gbd_step_sz = mp.power(10, -gbd_dps)
 
+    # initial conditions
     _s_2 = _s_mid
     _s_2_oddval = True
     _s_2_oddsum = 0
     _s_2_evnsum = 0
     _gbdry_points = [(_s_mid, _s_mid)]
+
+    # parameters for iteration
+    _gbd_step_sz = mp.power(10, -gbd_dps)
     for _s_1 in mp.arange(_s_mid, 0, -_gbd_step_sz):
         _s_1 -= _gbd_step_sz
         while True:
-            _shratio_12 = _s_2 / (1 - _s_1)
-            _shratio_21 = (
+            _delta_12 = _s_2 / (1 - _s_1)
+            _delta_21 = (
                 _s_1 / (1 - _s_2)
                 if recapture_spec == "proportional"
                 else _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
@@ -1171,13 +1198,21 @@ def shrratio_mgnsym_boundary_avg(
 
             match avg_method:
                 case "geometric":
-                    _small_d = mp.sqrt(_shratio_12 * _shratio_21)
+                    _delta_test = mp.sqrt(_delta_12 * _delta_21)
                 case "distance":
-                    _small_d = mp.sqrt(mp.fdiv((_shratio_12**2 + _shratio_21**2), "2"))
+                    # _delta_test = mp.sqrt(mp.fdiv((_delta_12**2 + _delta_21**2), "2"))
+                    _delta_test = mp.sqrt(
+                        mp.fdiv(
+                            mp.fsum(
+                                mp.power(f"{_g}", "2") for _g in (_delta_12, _delta_21)
+                            ),
+                            "2",
+                        )
+                    )
                 case _:
-                    _small_d = mp.fdiv(_shratio_12 + _shratio_21, "2")
+                    _delta_test = mp.fdiv(_delta_12 + _delta_21, "2")
 
-            if _small_d < _delta_star:
+            if _delta_test < _delta_star:
                 _s_2 += _gbd_step_sz
             else:
                 break
@@ -1190,12 +1225,12 @@ def shrratio_mgnsym_boundary_avg(
 
     # Starting at _s_id - _gbd_step_sz means _s_1 is not always
     # an even multiple of _gbd_step_sz
-    _s_incpt = _s_2
+    _s_intcpt = _s_2
 
     _gbd_prtlarea = 2 * _gbd_step_sz * (
         mp.fmul(4 / 3, _s_2_oddsum)
         + mp.fmul(2 / 3, _s_2_evnsum)
-        + mp.fmul(1 / 3, _s_mid + _s_incpt)
+        + mp.fmul(1 / 3, _s_mid + _s_intcpt)
     ) - mp.power(_s_mid, 2)
 
     _gbdry_points = np.array(_gbdry_points, np.float64)
@@ -1203,3 +1238,158 @@ def shrratio_mgnsym_boundary_avg(
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
         round(float(_gbd_prtlarea), gbd_dps),
     )
+
+
+def shrratio_mgnsym_boundary_distance(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    avg_method: Literal["arithmetic", "distance"] = "arithmetic",
+    wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+    gbd_dps: int = 5,
+) -> tuple[NDArray[np.float64], float]:
+    """
+    Share combinations for the GUPPI boundaries using various aggregators with symmetric merging-firm margins.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    avg_method
+        Whether "arithmetic", "geometric", or "distance".
+    wgtng_policy
+        Whether "own-share" or "cross-product-share".
+    recapture_spec
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+    gbd_dps
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    if _delta_star > 1:
+        raise ValueError(
+            "Margin-adjusted benchmark share ratio, `_delta_star` cannot exceed 1."
+        )
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+
+    # initial conditions
+    _gbdry_points = [(_s_mid, _s_mid)]
+    _s_1_pre, _s_2_pre = _s_mid, _s_mid
+    _s_2_oddval, _s_2_oddsum, _s_2_evnsum = True, 0, 0
+
+    # parameters for iteration
+    _weights_base = (mpf("0.5"),) * 2
+    _gbd_step_sz = mp.power(10, -gbd_dps)
+    _theta = _gbd_step_sz * (10 if wgtng_policy == "cross-product-share" else 1)
+    for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
+        # The wtd. avg. GUPPI is not always convex to the origin, so we
+        #   increment _s_2 after each iteration in which our algorithm
+        #   finds (s1, s2) on the boundary
+        _s_2 = _s_2_pre * (1 + _theta)
+
+        if (_s_1 + _s_2) > mpf("0.99875"):
+            # 1: # We lose accuracy at 3-9s and up
+            break
+
+        while True:
+            _de_1 = _s_2 / (1 - _s_1)
+            _de_2 = (
+                _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
+                if recapture_spec == "inside-out"
+                else _s_1 / (1 - _s_2)
+            )
+
+            _weights_i = (
+                (
+                    _w1 := mp.fdiv(
+                        _s_2 if wgtng_policy == "cross-product-share" else _s_1,
+                        _s_1 + _s_2,
+                    ),
+                    1 - _w1,
+                )
+                if wgtng_policy
+                else _weights_base
+            )
+
+            match avg_method:
+                case "arithmetic":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=1, w=_weights_i
+                    )
+                case "distance":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=2, w=_weights_i
+                    )
+
+            if wgtng_policy == "cross-product-share":
+                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
+            else:
+                _test_flag, _incr_decr = (_delta_test < _delta_star, 1)
+
+            if _test_flag:
+                _s_2 += _incr_decr * _gbd_step_sz
+            else:
+                break
+
+        # Build-up boundary points
+        _gbdry_points.append((_s_1, _s_2))
+
+        # Build up area terms
+        _s_2_oddsum += _s_2 if _s_2_oddval else 0
+        _s_2_evnsum += _s_2 if not _s_2_oddval else 0
+        _s_2_oddval = not _s_2_oddval
+
+        # Hold share points
+        _s_2_pre = _s_2
+        _s_1_pre = _s_1
+
+    _gbd_prtlarea = _gbd_step_sz * (
+        (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _delta_star) / 3
+        if wgtng_policy == "cross-product-share"
+        else (
+            (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
+            + _s_1_pre * (1 + _s_2_pre) / 2
+        )
+    )
+
+    # Area under boundary
+    _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
+
+    match wgtng_policy:
+        case "cross-product-share":
+            _s_intcpt = _delta_star
+        case "own-product-share":
+            _s_intcpt = mpf("1.0")
+        case None if avg_method == "distance":
+            _s_intcpt = _delta_star * mp.sqrt("2")
+        case None if avg_method == "arithmetic" and recapture_spec == "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}"),
+            )
+        case None if avg_method == "arithmetic":
+            _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
+        case _:
+            _s_intcpt = _s_2_pre
+
+    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
+        np.float64
+    )
+    # Points defining boundary to point-of-symmetry
+    return (
+        np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
+        round(float(_gbdry_area_total), gbd_dps),
+    )

mergeron/core/proportions_tests.py

@@ -21,12 +21,12 @@ from numpy.typing import NBitBase, NDArray
 from scipy.optimize import OptimizeResult, root  # type: ignore
 from scipy.stats import beta, chi2, norm  # type: ignore
 
-T = TypeVar("T", bound=NBitBase)
+TI = TypeVar("TI", bound=NBitBase)
 
 
 def propn_ci(
-    _npos: NDArray[np.integer[T]] | int = 4,
-    _nobs: NDArray[np.integer[T]] | int = 10,
+    _npos: NDArray[np.integer[TI]] | int = 4,
+    _nobs: NDArray[np.integer[TI]] | int = 10,
     /,
     *,
     alpha: float = 0.05,
@@ -41,7 +41,7 @@ def propn_ci(
 ]:
     """Returns point estimates and confidence interval for a proportion
 
-    Methods "Clopper-Pearson" and "Exact" are synoymous [2]_.  Similarly,
+    Methods "Clopper-Pearson" and "Exact" are synoymous [3]_.  Similarly,
     "Wilson" and "Score" are synonyms here.
 
     Parameters
@@ -66,7 +66,7 @@ def propn_ci(
     References
     ----------
 
-    .. [2] Alan Agresti & Brent A. Coull (1998) Approximate is Better
+    .. [3] Alan Agresti & Brent A. Coull (1998) Approximate is Better
        than “Exact” for Interval Estimation of Binomial Proportions,
        The American Statistician, 52:2, 119-126,
        https://doi.org/10.1080/00031305.1998.10480550
@@ -74,9 +74,9 @@ def propn_ci(
     """
 
     for _f in _npos, _nobs:
-        if not isinstance(_f, float | int | np.floating | np.integer):
+        if not isinstance(_f, int | np.integer):
             raise ValueError(
-                f"Count, {_f!r} must have type that is a subtype of np.floating or np.integer."
+                f"Count, {_f!r} must have type that is a subtype of np.integer."
             )
 
     if not _nobs:
@@ -131,7 +131,7 @@ def propn_ci(
 
 
 def propn_ci_multinomial(
-    _counts: NDArray[np.integer[T]],
+    _counts: NDArray[np.integer[TI]],
     /,
     *,
     alpha: float = 0.05,
@@ -200,9 +200,9 @@ def propn_diff_ci(
 ) -> tuple[float, float, float, float]:
     R"""Confidence intervals for differences in binomial proportions.
 
-    Methods available are Agresti-Caffo [3]_, Mee [4]_, Meitinen-Nurminen [4]_ [5]_
-    and Newcombe (aka, Score method) [4]_. See also, source code for the
-    R-language function BinomDiffCI, in the module StatsAndCIs [6]_.
+    Methods available are Agresti-Caffo [4]_, Mee [5]_, Meitinen-Nurminen [5]_ [6]_
+    and Newcombe (aka, Score method) [5]_. See also, source code for the
+    R-language function BinomDiffCI, in the module StatsAndCIs [7]_.
 
     Parameters
     ----------
@@ -222,19 +222,19 @@ def propn_diff_ci(
     References
     ----------
 
-    .. [3] Agresti, A., & Caffo, T. (2000). Simple and Effective
+    .. [4] Agresti, A., & Caffo, T. (2000). Simple and Effective
        Confidence Intervals for Proportions and Differences of Proportions
        Result from Adding Two Successes and Two Failures.
        The American Statistician, 54(4), 280--288. https://doi.org/10.2307/2685779
 
-    .. [4] Newcombe, R.G. (1998). Two-sided confidence intervals for
+    .. [5] Newcombe, R.G. (1998). Two-sided confidence intervals for
        the single proportion: comparison of seven methods. Statist. Med., 17: 857-872.
        https://doi.org/10.1002/(SICI)1097-0258(19980430)17:8%3C857::AID-SIM777%3E3.0.CO;2-E
 
-    .. [5] Miettinen, O. and Nurminen, M. (1985). Comparative analysis of two rates.
+    .. [6] Miettinen, O. and Nurminen, M. (1985). Comparative analysis of two rates.
         Statist. Med., 4: 213-226. https://doi.org/10.1002/sim.4780040211; Appendix I
 
-    .. [6] StatsAndCIs.r, function BinomDiffCI, method, "mn"
+    .. [7] StatsAndCIs.r, function BinomDiffCI, method, "mn"
        https://github.com/cran/DescTools/blob/master/R/StatsAndCIs.r
        (R source code is distributed under the CC-BY license.)
 
@@ -349,9 +349,9 @@ def _propn_diff_ci_mn(
 
     """
     for _f in _npos1, _nobs1, _npos1, _nobs2:
-        if not isinstance(_f, float | int | np.floating | np.integer):
+        if not isinstance(_f, int | np.integer):
             raise ValueError(
-                f"Count, {_f!r} must have type that is a subtype of np.floating or np.integer."
+                f"Count, {_f!r} must have type that is a subtype of np.integer."
             )
 
     _chi_sq_cr = chi2.ppf(1 - alpha, 1)
@@ -442,7 +442,7 @@ def _propn_diff_chisq_mn(
 
 
 def propn_ci_diff_multinomial(
-    _counts: NDArray[np.integer[T]], /, *, alpha: float = 0.05
+    _counts: NDArray[np.integer[TI]], /, *, alpha: float = 0.05
 ) -> NDArray[np.float64]:
     """Estimate confidence intervals of pair-wise differences in multinomial proportions
 
@@ -483,7 +483,7 @@ class MultinomialDiffTest(NamedTuple):
 
 
 def propn_diff_multinomial_chisq(
-    _counts: NDArray[np.integer[T]], /, *, alpha: float = 0.05
+    _counts: NDArray[np.integer[TI]], /, *, alpha: float = 0.05
 ) -> MultinomialDiffTest:
     """Chi-square test for homogeneity of differences in multinomial proportions.