mergeron 2024.739097.4__py3-none-any.whl → 2024.739099.1__py3-none-any.whl

mergeron/__init__.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 import enum
 from pathlib import Path
+from typing import TypeAlias, TypeVar
 
 import numpy as np
+from numpy.typing import NBitBase, NDArray
 
 _PKG_NAME: str = Path(__file__).parent.stem
 
-VERSION = "2024.739097.4"
+VERSION = "2024.739099.1"
 
 __version__ = VERSION
 
@@ -24,6 +26,18 @@ if not DATA_DIR.is_dir():
 np.set_printoptions(precision=18)
 
 
+TI = TypeVar("TI", bound=NBitBase)
+ArrayINT = NDArray[np.integer[TI]]
+TF = TypeVar("TF", bound=NBitBase)
+ArrayFloat = NDArray[np.floating[TF]]
+
+
+ArrayBoolean: TypeAlias = NDArray[np.bool_]
+
+ArrayDouble: TypeAlias = NDArray[np.float64]
+ArrayBIGINT: TypeAlias = NDArray[np.int64]
+
+
 @enum.unique
 class RECConstants(enum.StrEnum):
     """Recapture rate - derivation methods."""

mergeron/core/damodaran_margin_data.py

@@ -43,11 +43,10 @@ import msgpack  # type:ignore
 import numpy as np
 import urllib3
 from numpy.random import PCG64DXSM, Generator, SeedSequence
-from numpy.typing import NDArray
 from scipy import stats  # type: ignore
 from xlrd import open_workbook  # type: ignore
 
-from .. import _PKG_NAME, DATA_DIR, VERSION  # noqa: TID252
+from .. import _PKG_NAME, DATA_DIR, VERSION, ArrayDouble  # noqa: TID252
 
 __version__ = VERSION
 
@@ -137,7 +136,7 @@ def mgn_data_getter(  # noqa: PLR0912
 
 def mgn_data_builder(
     _mgn_tbl_dict: Mapping[str, Mapping[str, float | int]] | None = None, /
-) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:
+) -> tuple[ArrayDouble, ArrayDouble, ArrayDouble]:
     if _mgn_tbl_dict is None:
         _mgn_tbl_dict = mgn_data_getter()
 
@@ -190,7 +189,7 @@ def mgn_data_resampler(
     /,
     *,
     seed_sequence: SeedSequence | None = None,
-) -> NDArray[np.float64]:
+) -> ArrayDouble:
     """
     Generate draws from the empirical distribution bassed on Prof. Damodaran's margin data.
 

mergeron/core/ftc_merger_investigations_data.py

@@ -23,9 +23,8 @@ import re2 as re  # type: ignore
 import urllib3
 from bs4 import BeautifulSoup
 from numpy.testing import assert_array_equal
-from numpy.typing import NDArray
 
-from .. import _PKG_NAME, DATA_DIR, VERSION  # noqa: TID252
+from .. import _PKG_NAME, DATA_DIR, VERSION, ArrayBIGINT  # noqa: TID252
 
 __version__ = VERSION
 
@@ -93,7 +92,7 @@ CNT_FCOUNT_DICT = {
 class INVTableData(NamedTuple):
     industry_group: str
     additional_evidence: str
-    data_array: NDArray[np.int64]
+    data_array: ArrayBIGINT
 
 
 INVData: TypeAlias = Mapping[str, dict[str, dict[str, INVTableData]]]
@@ -585,12 +584,12 @@ def _identify_table_type(_tnstr: str = CONC_TABLE_ALL, /) -> tuple[str, int, str
 
 def _process_table_blks_conc_type(
     _table_blocks: Sequence[Sequence[str]], /
-) -> NDArray[np.int64]:
+) -> 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: NDArray[np.int64] = np.zeros(len(_col_titles_array), np.int64)
-    _invdata_array: NDArray[np.int64] = np.array(None)
+    _col_totals: ArrayBIGINT = np.zeros(len(_col_titles_array), np.int64)
+    _invdata_array: ArrayBIGINT = np.array(None)
 
     for _tbl_blk in _table_blocks:
         if _conc_row_pat.match(_blk_str := _tbl_blk[-3]):
@@ -642,13 +641,11 @@ def _process_table_blks_conc_type(
 
 def _process_table_blks_cnt_type(
     _table_blocks: Sequence[Sequence[str]], /
-) -> NDArray[np.int64]:
+) -> ArrayBIGINT:
     _cnt_row_pat = re.compile(r"(\d+ (?:to \d+|\+)|TOTAL)")
 
-    _invdata_array: NDArray[np.int64] = np.array(None)
-    _col_totals: NDArray[np.int64] = np.zeros(
-        3, np.int64
-    )  # "enforced", "closed", "total"
+    _invdata_array: ArrayBIGINT = np.array(None)
+    _col_totals: ArrayBIGINT = np.zeros(3, np.int64)  # "enforced", "closed", "total"
 
     for _tbl_blk in _table_blocks:
         if _cnt_row_pat.match(_blk_str := _tbl_blk[-3]):

mergeron/core/guidelines_boundaries.py

@@ -12,9 +12,8 @@ from typing import Literal, TypeAlias
 import numpy as np
 from attrs import Attribute, field, frozen, validators
 from mpmath import mp, mpf  # type: ignore
-from numpy.typing import NDArray
 
-from .. import VERSION, RECConstants, UPPAggrSelector  # noqa: TID252
+from .. import VERSION, ArrayDouble, RECConstants, UPPAggrSelector  # noqa: TID252
 from . import guidelines_boundary_functions as gbfn
 
 __version__ = VERSION
@@ -191,7 +190,7 @@ class ConcentrationBoundary:
         validator=(validators.instance_of(str), _concentration_measure_name_validator),
     )
 
-    coordinates: NDArray[np.float64] = field(init=False, kw_only=True)
+    coordinates: ArrayDouble = field(init=False, kw_only=True)
     """Market-share pairs as Cartesian coordinates of points on the concentration boundary."""
 
     area: float = field(init=False, kw_only=True)
@@ -321,7 +320,7 @@ class DiversionRatioBoundary:
 
     """
 
-    coordinates: NDArray[np.float64] = field(init=False, kw_only=True)
+    coordinates: ArrayDouble = field(init=False, kw_only=True)
     """Market-share pairs as Cartesian coordinates of points on the diversion ratio boundary."""
 
     area: float = field(init=False, kw_only=True)

mergeron/core/guidelines_boundary_functions.py

@@ -4,9 +4,8 @@ from typing import Any, Literal, TypedDict
 
 import numpy as np
 from mpmath import mp, mpf  # type: ignore
-from numpy.typing import NDArray
 
-from .. import VERSION  # noqa: TID252
+from .. import VERSION, ArrayBIGINT, ArrayDouble  # noqa: TID252
 
 __version__ = VERSION
 
@@ -27,7 +26,7 @@ class ShareRatioBoundaryKeywords(TypedDict, total=False):
 class GuidelinesBoundary:
     """Output of a Guidelines boundary function."""
 
-    coordinates: NDArray[np.float64]
+    coordinates: ArrayDouble
     """Market-share pairs as Cartesian coordinates of points on the boundary."""
 
     area: float
@@ -718,11 +717,11 @@ def _shrratio_boundary_intcpt(
 
 
 def lerp(
-    _x1: int | float | mpf | NDArray[np.float64 | np.int64] = 3,
-    _x2: int | float | mpf | NDArray[np.float64 | np.int64] = 1,
+    _x1: int | float | mpf | ArrayDouble | ArrayBIGINT = 3,
+    _x2: int | float | mpf | ArrayDouble | ArrayBIGINT = 1,
     _r: float | mpf = 0.25,
     /,
-) -> float | mpf | NDArray[np.float64]:
+) -> float | mpf | ArrayDouble:
     """
     From the function of the same name in the C++ standard [2]_
 

mergeron/core/guidelines_boundary_functions_extra.py

@@ -13,11 +13,10 @@ from typing import Literal
 
 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  # type: ignore
 from sympy import lambdify, simplify, solve, symbols  # type: ignore
 
-from .. import VERSION  # noqa: TID252
+from .. import VERSION, ArrayDouble  # noqa: TID252
 from .guidelines_boundary_functions import (
     GuidelinesBoundary,
     _shrratio_boundary_intcpt,
@@ -33,7 +32,7 @@ mp.trap_complex = True
 
 @dataclass(slots=True, frozen=True)
 class GuidelinesBoundaryCallable:
-    boundary_function: Callable[[NDArray[np.float64]], NDArray[np.float64]]
+    boundary_function: Callable[[ArrayDouble], ArrayDouble]
     area: float
     s_naught: float = 0
 

mergeron/core/pseudorandom_numbers.py

@@ -13,9 +13,8 @@ from typing import Literal
 
 import numpy as np
 from numpy.random import PCG64DXSM, Generator, SeedSequence
-from numpy.typing import NDArray
 
-from .. import VERSION  # noqa: TID252
+from .. import VERSION, ArrayDouble  # noqa: TID252
 
 __version__ = VERSION
 
@@ -134,13 +133,13 @@ class MultithreadedRNG:
 
     def __init__(
         self,
-        _out_array: NDArray[np.float64],
+        _out_array: ArrayDouble,
         /,
         *,
         dist_type: Literal[
             "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
         ] = "Uniform",
-        dist_parms: NDArray[np.float64] | None = DIST_PARMS_DEFAULT,
+        dist_parms: ArrayDouble | None = DIST_PARMS_DEFAULT,
         seed_sequence: SeedSequence | None = None,
         nthreads: int = NTHREADS,
     ):
@@ -206,8 +205,8 @@ class MultithreadedRNG:
         def _fill(
             _rng: np.random.Generator,
             _dist_type: str,
-            _dist_parms: NDArray[np.float64],
-            _out: NDArray[np.float64],
+            _dist_parms: ArrayDouble,
+            _out: ArrayDouble,
             _first: int,
             _last: int,
             /,

mergeron/gen/__init__.py

@@ -11,9 +11,15 @@ from typing import ClassVar, Protocol
 
 import numpy as np
 from attrs import Attribute, cmp_using, define, field, frozen, validators
-from numpy.typing import NDArray
 
-from .. import VERSION, RECConstants, UPPAggrSelector  # noqa: TID252
+from .. import (  # noqa: TID252
+    VERSION,
+    ArrayBIGINT,
+    ArrayBoolean,
+    ArrayDouble,
+    RECConstants,
+    UPPAggrSelector,
+)
 from ..core.pseudorandom_numbers import DIST_PARMS_DEFAULT  # noqa: TID252
 
 __version__ = VERSION
@@ -128,7 +134,7 @@ class ShareSpec:
     dist_type: SHRConstants
     """See :class:`SHRConstants`"""
 
-    dist_parms: NDArray[np.float64] | None = field(
+    dist_parms: ArrayDouble | None = field(
         default=None, eq=cmp_using(eq=np.array_equal)
     )
     """Parameters for tailoring market-share distribution
@@ -139,9 +145,9 @@ class ShareSpec:
     type of Dirichlet-distribution specified.
 
     """
-    firm_counts_weights: NDArray[np.float64 | np.int64] | None = field(
-        default=None, eq=cmp_using(eq=np.array_equal)
-    )
+    firm_counts_weights: (
+        ArrayDouble | ArrayBIGINT | ArrayDouble | ArrayBIGINT | None
+    ) = field(default=None, eq=cmp_using(eq=np.array_equal))
     """Relative or absolute frequencies of firm counts
 
 
@@ -193,7 +199,7 @@ class PCMSpec:
     dist_type: PCMConstants
     """See :class:`PCMConstants`"""
 
-    dist_parms: NDArray[np.float64] | None
+    dist_parms: ArrayDouble | None
     """Parameter specification for tailoring PCM distribution
 
     For Uniform distribution, bounds of the distribution; defaults to `(0, 1)`;
@@ -356,39 +362,39 @@ class MarketSpec:
 class MarketDataSample:
     """Container for generated markets data sample."""
 
-    frmshr_array: NDArray[np.float64]
+    frmshr_array: ArrayDouble
     """Merging-firm shares (with two merging firms)"""
 
-    pcm_array: NDArray[np.float64]
+    pcm_array: ArrayDouble
     """Merging-firms' prices (normalized to 1, in default specification)"""
 
-    price_array: NDArray[np.float64]
+    price_array: ArrayDouble
     """Merging-firms' price-cost margins (PCM)"""
 
-    fcounts: NDArray[np.int64]
+    fcounts: ArrayBIGINT
     """Number of firms in market"""
 
-    aggregate_purchase_prob: NDArray[np.float64]
+    aggregate_purchase_prob: ArrayDouble
     """
     One (1) minus probability that the outside good is chosen
 
     Converts market shares to choice probabilities by multiplication.
     """
 
-    nth_firm_share: NDArray[np.float64]
+    nth_firm_share: ArrayDouble
     """Market-share of n-th firm
 
     Relevant for testing for draws the do or
     do not meet HSR filing thresholds.
     """
 
-    divr_array: NDArray[np.float64]
+    divr_array: ArrayDouble
     """Diversion ratio between the merging firms"""
 
-    hhi_post: NDArray[np.float64]
+    hhi_post: ArrayDouble
     """Post-merger change in Herfindahl-Hirschmann Index (HHI)"""
 
-    hhi_delta: NDArray[np.float64]
+    hhi_delta: ArrayDouble
     """Change in HHI from combination of merging firms"""
 
 
@@ -400,16 +406,16 @@ class ShareDataSample:
     and aggregate purchase probability.
     """
 
-    mktshr_array: NDArray[np.float64]
+    mktshr_array: ArrayDouble
     """All-firm shares (with two merging firms)"""
 
-    fcounts: NDArray[np.int64]
+    fcounts: ArrayBIGINT
     """All-firm-count for each draw"""
 
-    nth_firm_share: NDArray[np.float64]
+    nth_firm_share: ArrayDouble
     """Market-share of n-th firm"""
 
-    aggregate_purchase_prob: NDArray[np.float64]
+    aggregate_purchase_prob: ArrayDouble
     """Converts market shares to choice probabilities by multiplication."""
 
 
@@ -417,10 +423,10 @@ class ShareDataSample:
 class PriceDataSample:
     """Container for generated price array, and related."""
 
-    price_array: NDArray[np.float64]
+    price_array: ArrayDouble
     """Merging-firms' prices"""
 
-    hsr_filing_test: NDArray[np.bool_]
+    hsr_filing_test: ArrayBoolean
     """Flags draws as meeting HSR filing thresholds or not"""
 
 
@@ -428,10 +434,10 @@ class PriceDataSample:
 class MarginDataSample:
     """Container for generated margin array and related MNL test array."""
 
-    pcm_array: NDArray[np.float64]
+    pcm_array: ArrayDouble
     """Merging-firms' PCMs"""
 
-    mnl_test_array: NDArray[np.bool_]
+    mnl_test_array: ArrayBoolean
     """Flags infeasible observations as False and rest as True
 
     Applying restrictions from Bertrand-Nash oligopoly
@@ -476,18 +482,18 @@ class UPPTestsRaw:
     :func:`enforcement_stats.gen_upp_arrays`.
     """
 
-    guppi_test_simple: NDArray[np.bool_]
+    guppi_test_simple: ArrayBoolean
     """True if GUPPI estimate meets criterion"""
 
-    guppi_test_compound: NDArray[np.bool_]
+    guppi_test_compound: ArrayBoolean
     """True if both GUPPI estimate and diversion ratio estimate
     meet criterion
     """
 
-    cmcr_test: NDArray[np.bool_]
+    cmcr_test: ArrayBoolean
     """True if CMCR estimate meets criterion"""
 
-    ipr_test: NDArray[np.bool_]
+    ipr_test: ArrayBoolean
     """True if IPR (partial price-simulation) estimate meets criterion"""
 
 
@@ -498,9 +504,9 @@ class UPPTestsCounts:
     Resolution may be either :attr:`INVResolution.ENFT` or :attr:`INVResolution.CLRN`.
     """
 
-    by_firm_count: NDArray[np.int64]
-    by_delta: NDArray[np.int64]
-    by_conczone: NDArray[np.int64]
+    by_firm_count: ArrayBIGINT
+    by_delta: ArrayBIGINT
+    by_conczone: ArrayBIGINT
     """Zones are "unoncentrated", "moderately concentrated", and "highly concentrated"
     """
 

mergeron/gen/_data_generation_functions.py

@@ -9,9 +9,8 @@ from typing import Literal
 import numpy as np
 from attrs import evolve
 from numpy.random import SeedSequence
-from numpy.typing import NDArray
 
-from .. import VERSION, RECConstants  # noqa: TID252
+from .. import VERSION, ArrayBIGINT, ArrayDouble, RECConstants  # noqa: TID252
 from ..core.damodaran_margin_data import mgn_data_resampler  # noqa: TID252
 from ..core.pseudorandom_numbers import (  # noqa: TID252
     DIST_PARMS_DEFAULT,
@@ -112,7 +111,7 @@ def _gen_share_data(
 
 def _gen_market_shares_uniform(
     _s_size: int = 10**6,
-    _dist_parms_mktshr: NDArray[np.float64] | None = DIST_PARMS_DEFAULT,
+    _dist_parms_mktshr: ArrayDouble | None = DIST_PARMS_DEFAULT,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
     _nthreads: int = 16,
     /,
@@ -137,7 +136,7 @@ def _gen_market_shares_uniform(
     """
 
     _frmshr_array = np.empty((_s_size, 2), dtype=np.float64)
-    _dist_parms_mktshr: NDArray[np.float64] = (
+    _dist_parms_mktshr: ArrayDouble = (
         DIST_PARMS_DEFAULT if _dist_parms_mktshr is None else _dist_parms_mktshr
     )
     _mrng = MultithreadedRNG(
@@ -163,7 +162,7 @@ def _gen_market_shares_uniform(
         _frmshr_array, ((0, 0), (0, 1)), "constant", constant_values=np.nan
     )
 
-    _fcounts: NDArray[np.int64] = np.ones((_s_size, 1), np.int64) * np.nan  # type: ignore
+    _fcounts: ArrayBIGINT = np.ones((_s_size, 1), np.int64) * np.nan  # type: ignore
     _nth_firm_share, _aggregate_purchase_prob = (
         np.nan * np.ones((_s_size, 1), np.float64) for _ in range(2)
     )
@@ -177,8 +176,8 @@ def _gen_market_shares_dirichlet_multisample(
     _s_size: int = 10**6,
     _recapture_form: RECConstants = RECConstants.INOUT,
     _dist_type_dir: SHRConstants = SHRConstants.DIR_FLAT,
-    _dist_parms_dir: NDArray[np.float64] | None = None,
-    _firm_count_wts: NDArray[np.float64] | None = None,
+    _dist_parms_dir: ArrayDouble | None = None,
+    _firm_count_wts: ArrayDouble | None = None,
     _fcount_rng_seed_seq: SeedSequence | None = None,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
     _nthreads: int = 16,
@@ -216,7 +215,7 @@ def _gen_market_shares_dirichlet_multisample(
 
     """
 
-    _firm_count_wts: NDArray[np.float64] = (
+    _firm_count_wts: ArrayDouble = (
         FCOUNT_WTS_DEFAULT if _firm_count_wts is None else _firm_count_wts
     )
 
@@ -243,7 +242,7 @@ def _gen_market_shares_dirichlet_multisample(
 
     if _dist_type_dir == SHRConstants.DIR_COND:
 
-        def _gen_dir_alphas(_fcv: int) -> NDArray[np.float64]:
+        def _gen_dir_alphas(_fcv: int) -> ArrayDouble:
             _dat = [2.5] * 2
             if _fcv > len(_dat):
                 _dat += [1.0 / (_fcv - 2)] * (_fcv - 2)
@@ -251,7 +250,7 @@ def _gen_market_shares_dirichlet_multisample(
 
     else:
 
-        def _gen_dir_alphas(_fcv: int) -> NDArray[np.float64]:
+        def _gen_dir_alphas(_fcv: int) -> ArrayDouble:
             return np.array(_dir_alphas_full[:_fcv], dtype=np.float64)  # type: ignore
 
     _fcounts = prng(_fcount_rng_seed_seq).choice(
@@ -312,7 +311,7 @@ def _gen_market_shares_dirichlet_multisample(
 
 
 def _gen_market_shares_dirichlet(
-    _dir_alphas: NDArray[np.float64],
+    _dir_alphas: ArrayDouble,
     _s_size: int = 10**6,
     _recapture_form: RECConstants = RECConstants.INOUT,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
@@ -394,9 +393,9 @@ def _gen_market_shares_dirichlet(
 
 
 def _gen_margin_price_data(
-    _frmshr_array: NDArray[np.float64],
-    _nth_firm_share: NDArray[np.float64],
-    _aggregate_purchase_prob: NDArray[np.float64],
+    _frmshr_array: ArrayDouble,
+    _nth_firm_share: ArrayDouble,
+    _aggregate_purchase_prob: ArrayDouble,
     _pcm_spec: PCMSpec,
     _price_spec: PriceConstants,
     _hsr_filing_test_type: SSZConstants,
@@ -543,8 +542,8 @@ def _gen_margin_price_data(
 
 # marked for deletion
 def _gen_price_data(
-    _frmshr_array: NDArray[np.float64],
-    _nth_firm_share: NDArray[np.float64],
+    _frmshr_array: ArrayDouble,
+    _nth_firm_share: ArrayDouble,
     _price_spec: PriceConstants,
     _hsr_filing_test_type: SSZConstants,
     _seed_seq: SeedSequence | None = None,
@@ -630,9 +629,9 @@ def _gen_price_data(
 
 
 def _gen_margin_data(
-    _frmshr_array: NDArray[np.float64],
-    _price_array: NDArray[np.float64],
-    _aggregate_purchase_prob: NDArray[np.float64],
+    _frmshr_array: ArrayDouble,
+    _price_array: ArrayDouble,
+    _aggregate_purchase_prob: ArrayDouble,
     _pcm_spec: PCMSpec,
     _pcm_rng_seed_seq: SeedSequence,
     _nthreads: int = 16,
@@ -719,8 +718,8 @@ def _gen_margin_data(
 
 
 def _beta_located(
-    _mu: float | NDArray[np.float64], _sigma: float | NDArray[np.float64], /
-) -> NDArray[np.float64]:
+    _mu: float | ArrayDouble, _sigma: float | ArrayDouble, /
+) -> ArrayDouble:
     """
     Given mean and stddev, return shape parameters for corresponding Beta distribution
 
@@ -743,7 +742,7 @@ def _beta_located(
     return np.array([_mu * _mul, (1 - _mu) * _mul], dtype=np.float64)
 
 
-def beta_located_bound(_dist_parms: NDArray[np.float64], /) -> NDArray[np.float64]:
+def beta_located_bound(_dist_parms: ArrayDouble, /) -> ArrayDouble:
     R"""
     Return shape parameters for a non-standard beta, given the mean, stddev, range
 

mergeron/gen/data_generation.py

@@ -10,9 +10,8 @@ from typing import NamedTuple
 
 import numpy as np
 from numpy.random import SeedSequence
-from numpy.typing import NDArray
 
-from .. import VERSION, RECConstants  # noqa: TID252
+from .. import VERSION, ArrayDouble, RECConstants  # noqa: TID252
 from . import (
     EMPTY_ARRAY_DEFAULT,
     FM2Constants,
@@ -227,10 +226,10 @@ def parse_seed_seq_list(
 def gen_divr_array(
     _recapture_form: RECConstants,
     _recapture_rate: float | None,
-    _frmshr_array: NDArray[np.float64],
-    _aggregate_purchase_prob: NDArray[np.float64] = EMPTY_ARRAY_DEFAULT,
+    _frmshr_array: ArrayDouble,
+    _aggregate_purchase_prob: ArrayDouble = EMPTY_ARRAY_DEFAULT,
     /,
-) -> NDArray[np.float64]:
+) -> ArrayDouble:
     """
     Given merging-firm shares and related parameters, return diverion ratios.
 
@@ -259,7 +258,7 @@ def gen_divr_array(
 
     """
 
-    _divr_array: NDArray[np.float64]
+    _divr_array: ArrayDouble
     if _recapture_form == RECConstants.FIXED:
         _divr_array = _recapture_rate * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore