PyMetaAnalysis 0.1.0__py3-none-any.whl

meta_analyze/effect_sizes/binary.py

@@ -0,0 +1,412 @@
+"""Effect sizes and validation for two-group binary outcomes.
+
+OR, RR, and RD equations follow the publicly documented Review Manager 5
+statistical algorithms by Deeks and Higgins (2010).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from numbers import Real
+from typing import Literal, TypeAlias, cast
+
+import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
+
+from ..data import (
+    ColumnOrArray,
+    MissingPolicy,
+    _resolve_vector,
+    _study_labels,
+)
+from ..exceptions import InvalidStudyDataError, UnsupportedMethodError
+
+CorrectionScope: TypeAlias = Literal[
+    "only_zero_studies", "all_studies", "if_any_zero", "none"
+]
+RDZeroVariancePolicy: TypeAlias = Literal["correct", "exclude"]
+
+
+@dataclass(frozen=True, slots=True)
+class BinaryStudies:
+    """Validated raw counts and row-level inclusion metadata."""
+
+    row_id: NDArray[np.int64]
+    study: NDArray[np.object_]
+    event_treat: NDArray[np.float64]
+    n_treat: NDArray[np.float64]
+    event_control: NDArray[np.float64]
+    n_control: NDArray[np.float64]
+    included: NDArray[np.bool_]
+    exclusion_reason: NDArray[np.object_]
+
+
+@dataclass(frozen=True, slots=True)
+class BinaryEffectData:
+    """Binary study effects on the model scale."""
+
+    studies: BinaryStudies
+    effect: NDArray[np.float64]
+    variance: NDArray[np.float64]
+    corrected: NDArray[np.bool_]
+    rd_zero_variance: NDArray[np.bool_]
+    measure: str
+    effect_scale: str
+    display_scale: str
+
+    @property
+    def included_effect(self) -> NDArray[np.float64]:
+        return self.effect[self.studies.included]
+
+    @property
+    def included_variance(self) -> NDArray[np.float64]:
+        return self.variance[self.studies.included]
+
+
+def normalize_correction_scope(scope: str) -> CorrectionScope:
+    normalized = scope.lower().replace("-", "_")
+    aliases = {
+        "only0": "only_zero_studies",
+        "only_zero_cells": "only_zero_studies",
+        "all": "all_studies",
+        "if0all": "if_any_zero",
+    }
+    normalized = aliases.get(normalized, normalized)
+    allowed = {"only_zero_studies", "all_studies", "if_any_zero", "none"}
+    if normalized not in allowed:
+        raise UnsupportedMethodError(
+            "correction_scope must be 'only_zero_studies', 'all_studies', "
+            "'if_any_zero', or 'none'."
+        )
+    return cast(CorrectionScope, normalized)
+
+
+def normalize_rd_zero_variance(policy: str) -> RDZeroVariancePolicy:
+    """Normalize the policy for RD studies with zero raw sampling variance."""
+
+    if not isinstance(policy, str):
+        raise UnsupportedMethodError("rd_zero_variance must be 'correct' or 'exclude'.")
+    normalized = policy.lower().replace("-", "_")
+    if normalized not in {"correct", "exclude"}:
+        raise UnsupportedMethodError("rd_zero_variance must be 'correct' or 'exclude'.")
+    return cast(RDZeroVariancePolicy, normalized)
+
+
+def validate_correction(value: float | None, *, name: str) -> float:
+    if value is None:
+        return 0.0
+    if isinstance(value, bool) or not isinstance(value, Real):
+        raise InvalidStudyDataError(f"{name} must be a non-negative number or None.")
+    numeric = float(value)
+    if not np.isfinite(numeric) or numeric < 0.0:
+        raise InvalidStudyDataError(f"{name} must be finite and non-negative.")
+    return numeric
+
+
+def _missing_reason(names: list[str]) -> str:
+    return "missing " + ", ".join(names)
+
+
+def normalize_binary_studies(
+    *,
+    data: pd.DataFrame | None,
+    event_treat: ColumnOrArray,
+    n_treat: ColumnOrArray,
+    event_control: ColumnOrArray,
+    n_control: ColumnOrArray,
+    study: ColumnOrArray | None,
+    missing: MissingPolicy,
+) -> BinaryStudies:
+    """Resolve and validate two-group binary study counts."""
+
+    if data is not None and not isinstance(data, pd.DataFrame):
+        raise InvalidStudyDataError("data must be a pandas DataFrame or None.")
+    if missing not in {"raise", "drop"}:
+        raise InvalidStudyDataError("missing must be either 'raise' or 'drop'.")
+
+    arguments = {
+        "event_treat": event_treat,
+        "n_treat": n_treat,
+        "event_control": event_control,
+        "n_control": n_control,
+    }
+    raw = {
+        name: _resolve_vector(value, data=data, name=name)
+        for name, value in arguments.items()
+    }
+    lengths = {len(values) for values in raw.values()}
+    if len(lengths) != 1:
+        detail = ", ".join(f"{name}={len(values)}" for name, values in raw.items())
+        raise InvalidStudyDataError(
+            f"Binary count inputs must have equal lengths; {detail}."
+        )
+    length = lengths.pop()
+    if data is not None and len(data) != length:
+        raise InvalidStudyDataError(
+            "Array-like binary inputs used with data must have exactly one value "
+            "per DataFrame row."
+        )
+    labels = _study_labels(study, data=data, length=length)
+
+    try:
+        values = {
+            name: np.asarray(vector, dtype=np.float64) for name, vector in raw.items()
+        }
+    except (TypeError, ValueError) as error:
+        raise InvalidStudyDataError(
+            "Binary counts must contain numeric values."
+        ) from error
+
+    missing_by_name = {name: pd.isna(vector) for name, vector in values.items()}
+    any_missing = np.logical_or.reduce(tuple(missing_by_name.values()))
+    if np.any(any_missing) and missing == "raise":
+        rows = np.flatnonzero(any_missing).tolist()
+        raise InvalidStudyDataError(
+            f"Missing binary counts at row positions {rows}; use missing='drop' "
+            "to exclude them explicitly."
+        )
+
+    for name, vector in values.items():
+        present = ~missing_by_name[name]
+        invalid_finite = present & ~np.isfinite(vector)
+        if np.any(invalid_finite):
+            rows = np.flatnonzero(invalid_finite).tolist()
+            raise InvalidStudyDataError(f"{name} must be finite; invalid rows: {rows}.")
+        noninteger = present & (vector != np.floor(vector))
+        if np.any(noninteger):
+            rows = np.flatnonzero(noninteger).tolist()
+            raise InvalidStudyDataError(
+                f"{name} must contain whole-number counts; invalid rows: {rows}."
+            )
+
+    active = ~any_missing
+    for total_name in ("n_treat", "n_control"):
+        invalid = active & (values[total_name] <= 0.0)
+        if np.any(invalid):
+            rows = np.flatnonzero(invalid).tolist()
+            raise InvalidStudyDataError(
+                f"{total_name} must be strictly positive; invalid rows: {rows}."
+            )
+    for event_name, total_name in (
+        ("event_treat", "n_treat"),
+        ("event_control", "n_control"),
+    ):
+        invalid = active & (
+            (values[event_name] < 0.0) | (values[event_name] > values[total_name])
+        )
+        if np.any(invalid):
+            rows = np.flatnonzero(invalid).tolist()
+            raise InvalidStudyDataError(
+                f"{event_name} must be between 0 and {total_name}; "
+                f"invalid rows: {rows}."
+            )
+
+    reasons = np.full(length, None, dtype=object)
+    for index in np.flatnonzero(any_missing):
+        names = [name for name, mask in missing_by_name.items() if mask[index]]
+        reasons[index] = _missing_reason(names)
+    if not np.any(active):
+        raise InvalidStudyDataError(
+            "No studies remain after applying the missing-value policy."
+        )
+
+    return BinaryStudies(
+        row_id=np.arange(length, dtype=np.int64),
+        study=labels,
+        event_treat=values["event_treat"],
+        n_treat=values["n_treat"],
+        event_control=values["event_control"],
+        n_control=values["n_control"],
+        included=active,
+        exclusion_reason=reasons,
+    )
+
+
+def correction_mask(
+    a: NDArray[np.float64],
+    b: NDArray[np.float64],
+    c: NDArray[np.float64],
+    d: NDArray[np.float64],
+    *,
+    included: NDArray[np.bool_],
+    scope: CorrectionScope,
+) -> NDArray[np.bool_]:
+    zero_study: NDArray[np.bool_] = np.asarray(
+        (a == 0.0) | (b == 0.0) | (c == 0.0) | (d == 0.0),
+        dtype=np.bool_,
+    )
+    if scope == "only_zero_studies":
+        return included & zero_study
+    if scope == "all_studies":
+        return included.copy()
+    if scope == "if_any_zero":
+        return (
+            included.copy()
+            if np.any(included & zero_study)
+            else np.zeros_like(included)
+        )
+    return np.zeros_like(included)
+
+
+def adjusted_tables(
+    studies: BinaryStudies,
+    *,
+    correction: float,
+    scope: CorrectionScope,
+) -> tuple[
+    NDArray[np.float64],
+    NDArray[np.float64],
+    NDArray[np.float64],
+    NDArray[np.float64],
+    NDArray[np.bool_],
+]:
+    a = studies.event_treat.copy()
+    b = studies.n_treat - studies.event_treat
+    c = studies.event_control.copy()
+    d = studies.n_control - studies.event_control
+    corrected = correction_mask(a, b, c, d, included=studies.included, scope=scope) & (
+        correction > 0.0
+    )
+    if np.any(corrected):
+        for cell in (a, b, c, d):
+            cell[corrected] += correction
+    return a, b, c, d, corrected
+
+
+def calculate_binary_effects(
+    studies: BinaryStudies,
+    *,
+    measure: str,
+    continuity_correction: float,
+    correction_scope: CorrectionScope,
+    rd_zero_variance: str = "correct",
+) -> BinaryEffectData:
+    """Calculate OR, RR, or RD effects and sampling variances."""
+
+    normalized_measure = measure.upper()
+    if normalized_measure not in {"OR", "RR", "RD"}:
+        raise UnsupportedMethodError("measure must be 'OR', 'RR', or 'RD'.")
+    rd_policy = normalize_rd_zero_variance(rd_zero_variance)
+    if normalized_measure != "RD" and rd_policy != "correct":
+        raise UnsupportedMethodError(
+            "rd_zero_variance is only configurable when measure='RD'."
+        )
+
+    included = studies.included.copy()
+    reasons = studies.exclusion_reason.copy()
+    rd_zero_variance_mask = np.zeros_like(included)
+    if normalized_measure == "RD":
+        raw_rd_variance = (
+            studies.event_treat
+            * (studies.n_treat - studies.event_treat)
+            / studies.n_treat**3
+            + studies.event_control
+            * (studies.n_control - studies.event_control)
+            / studies.n_control**3
+        )
+        rd_zero_variance_mask = np.asarray(
+            included & (raw_rd_variance == 0.0), dtype=np.bool_
+        )
+        if rd_policy == "exclude":
+            included[rd_zero_variance_mask] = False
+            for index in np.flatnonzero(rd_zero_variance_mask):
+                reasons[index] = "zero uncorrected risk-difference variance"
+
+    if normalized_measure in {"OR", "RR"}:
+        double_zero = (studies.event_treat == 0.0) & (studies.event_control == 0.0)
+        double_all = (studies.event_treat == studies.n_treat) & (
+            studies.event_control == studies.n_control
+        )
+        uninformative = included & (double_zero | double_all)
+        included[uninformative] = False
+        for index in np.flatnonzero(uninformative):
+            reasons[index] = (
+                "no events in either group"
+                if double_zero[index]
+                else "all participants have events in both groups"
+            )
+
+    working_studies = BinaryStudies(
+        row_id=studies.row_id,
+        study=studies.study,
+        event_treat=studies.event_treat,
+        n_treat=studies.n_treat,
+        event_control=studies.event_control,
+        n_control=studies.n_control,
+        included=included,
+        exclusion_reason=reasons,
+    )
+    if not np.any(included):
+        raise InvalidStudyDataError(
+            f"No informative studies remain for measure={normalized_measure!r}."
+        )
+
+    a, b, c, d, corrected = adjusted_tables(
+        working_studies,
+        correction=continuity_correction,
+        scope=correction_scope,
+    )
+    zero_after_correction = included & (
+        (a == 0.0) | (b == 0.0) | (c == 0.0) | (d == 0.0)
+    )
+    if normalized_measure in {"OR", "RR"} and np.any(zero_after_correction):
+        rows = np.flatnonzero(zero_after_correction).tolist()
+        raise InvalidStudyDataError(
+            "OR/RR study effects are undefined with remaining zero cells at row "
+            f"positions {rows}; use a positive continuity_correction."
+        )
+
+    effect = np.full(len(included), np.nan, dtype=np.float64)
+    variance = np.full(len(included), np.nan, dtype=np.float64)
+    active = included
+    if normalized_measure == "OR":
+        effect[active] = np.log((a[active] * d[active]) / (b[active] * c[active]))
+        variance[active] = (
+            1.0 / a[active] + 1.0 / b[active] + 1.0 / c[active] + 1.0 / d[active]
+        )
+        effect_scale = "log"
+        display_scale = "exp"
+    elif normalized_measure == "RR":
+        n1 = a + b
+        n2 = c + d
+        effect[active] = np.log((a[active] / n1[active]) / (c[active] / n2[active]))
+        variance[active] = (
+            1.0 / a[active] - 1.0 / n1[active] + 1.0 / c[active] - 1.0 / n2[active]
+        )
+        effect_scale = "log"
+        display_scale = "exp"
+    else:
+        # RD remains on the uncorrected natural scale. Corrected counts are used
+        # only for its sampling variance when zero cells would make it degenerate.
+        effect[active] = (
+            studies.event_treat[active] / studies.n_treat[active]
+            - studies.event_control[active] / studies.n_control[active]
+        )
+        n1 = a + b
+        n2 = c + d
+        variance[active] = (
+            a[active] * b[active] / n1[active] ** 3
+            + c[active] * d[active] / n2[active] ** 3
+        )
+        effect_scale = "identity"
+        display_scale = "identity"
+
+    invalid_variance = active & (~np.isfinite(variance) | (variance <= 0.0))
+    if np.any(invalid_variance):
+        rows = np.flatnonzero(invalid_variance).tolist()
+        raise InvalidStudyDataError(
+            f"Non-positive binary sampling variance at row positions {rows}; "
+            "use an appropriate positive continuity_correction."
+        )
+
+    return BinaryEffectData(
+        studies=working_studies,
+        effect=effect,
+        variance=variance,
+        corrected=corrected,
+        rd_zero_variance=rd_zero_variance_mask,
+        measure=normalized_measure,
+        effect_scale=effect_scale,
+        display_scale=display_scale,
+    )

meta_analyze/effect_sizes/continuous.py

@@ -0,0 +1,271 @@
+"""Effect sizes and validation for two independent continuous groups.
+
+The standardized mean difference follows ``metafor::escalc(measure="SMD")``:
+the group mean difference is divided by the pooled standard deviation, then
+multiplied by the exact Hedges correction. Its default ``LS`` sampling
+variance is the large-sample approximation from Hedges (1982).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
+from scipy.special import gammaln
+
+from ..data import ColumnOrArray, MissingPolicy, _resolve_vector, _study_labels
+from ..exceptions import InvalidStudyDataError, UnsupportedMethodError
+
+
+@dataclass(frozen=True, slots=True)
+class ContinuousStudies:
+    """Validated two-group summary statistics and inclusion metadata."""
+
+    row_id: NDArray[np.int64]
+    study: NDArray[np.object_]
+    mean_treat: NDArray[np.float64]
+    sd_treat: NDArray[np.float64]
+    n_treat: NDArray[np.float64]
+    mean_control: NDArray[np.float64]
+    sd_control: NDArray[np.float64]
+    n_control: NDArray[np.float64]
+    included: NDArray[np.bool_]
+    exclusion_reason: NDArray[np.object_]
+
+
+@dataclass(frozen=True, slots=True)
+class ContinuousEffectData:
+    """Continuous study effects on their model scale."""
+
+    studies: ContinuousStudies
+    effect: NDArray[np.float64]
+    variance: NDArray[np.float64]
+    pooled_sd: NDArray[np.float64]
+    cohen_d: NDArray[np.float64]
+    correction_factor: NDArray[np.float64]
+    measure: str
+    effect_scale: str = "identity"
+    display_scale: str = "identity"
+
+    @property
+    def included_effect(self) -> NDArray[np.float64]:
+        return self.effect[self.studies.included]
+
+    @property
+    def included_variance(self) -> NDArray[np.float64]:
+        return self.variance[self.studies.included]
+
+
+def _missing_reason(names: list[str]) -> str:
+    return "missing " + ", ".join(names)
+
+
+def normalize_continuous_studies(
+    *,
+    data: pd.DataFrame | None,
+    mean_treat: ColumnOrArray,
+    sd_treat: ColumnOrArray,
+    n_treat: ColumnOrArray,
+    mean_control: ColumnOrArray,
+    sd_control: ColumnOrArray,
+    n_control: ColumnOrArray,
+    study: ColumnOrArray | None,
+    missing: MissingPolicy,
+) -> ContinuousStudies:
+    """Resolve and validate two-group continuous summary statistics."""
+
+    if data is not None and not isinstance(data, pd.DataFrame):
+        raise InvalidStudyDataError("data must be a pandas DataFrame or None.")
+    if missing not in {"raise", "drop"}:
+        raise InvalidStudyDataError("missing must be either 'raise' or 'drop'.")
+
+    arguments = {
+        "mean_treat": mean_treat,
+        "sd_treat": sd_treat,
+        "n_treat": n_treat,
+        "mean_control": mean_control,
+        "sd_control": sd_control,
+        "n_control": n_control,
+    }
+    raw = {
+        name: _resolve_vector(value, data=data, name=name)
+        for name, value in arguments.items()
+    }
+    lengths = {len(values) for values in raw.values()}
+    if len(lengths) != 1:
+        detail = ", ".join(f"{name}={len(values)}" for name, values in raw.items())
+        raise InvalidStudyDataError(
+            f"Continuous inputs must have equal lengths; {detail}."
+        )
+    length = lengths.pop()
+    if data is not None and len(data) != length:
+        raise InvalidStudyDataError(
+            "Array-like continuous inputs used with data must have exactly one "
+            "value per DataFrame row."
+        )
+    labels = _study_labels(study, data=data, length=length)
+
+    try:
+        values = {
+            name: np.asarray(vector, dtype=np.float64) for name, vector in raw.items()
+        }
+    except (TypeError, ValueError) as error:
+        raise InvalidStudyDataError(
+            "Continuous inputs must contain numeric values."
+        ) from error
+
+    missing_by_name = {name: pd.isna(vector) for name, vector in values.items()}
+    any_missing = np.logical_or.reduce(tuple(missing_by_name.values()))
+    if np.any(any_missing) and missing == "raise":
+        rows = np.flatnonzero(any_missing).tolist()
+        raise InvalidStudyDataError(
+            f"Missing continuous inputs at row positions {rows}; use "
+            "missing='drop' to exclude them explicitly."
+        )
+
+    for name, vector in values.items():
+        present = ~missing_by_name[name]
+        invalid = present & ~np.isfinite(vector)
+        if np.any(invalid):
+            rows = np.flatnonzero(invalid).tolist()
+            raise InvalidStudyDataError(f"{name} must be finite; invalid rows: {rows}.")
+
+    active = ~any_missing
+    for name in ("n_treat", "n_control"):
+        vector = values[name]
+        noninteger = active & (vector != np.floor(vector))
+        if np.any(noninteger):
+            rows = np.flatnonzero(noninteger).tolist()
+            raise InvalidStudyDataError(
+                f"{name} must contain whole-number sample sizes; invalid rows: {rows}."
+            )
+        too_small = active & (vector < 2.0)
+        if np.any(too_small):
+            rows = np.flatnonzero(too_small).tolist()
+            raise InvalidStudyDataError(
+                f"{name} must be at least 2 when a sample SD is supplied; "
+                f"invalid rows: {rows}."
+            )
+
+    for name in ("sd_treat", "sd_control"):
+        invalid = active & (values[name] < 0.0)
+        if np.any(invalid):
+            rows = np.flatnonzero(invalid).tolist()
+            raise InvalidStudyDataError(
+                f"{name} must be non-negative; invalid rows: {rows}."
+            )
+
+    reasons = np.full(length, None, dtype=object)
+    for index in np.flatnonzero(any_missing):
+        names = [name for name, mask in missing_by_name.items() if mask[index]]
+        reasons[index] = _missing_reason(names)
+    if not np.any(active):
+        raise InvalidStudyDataError(
+            "No studies remain after applying the missing-value policy."
+        )
+
+    return ContinuousStudies(
+        row_id=np.arange(length, dtype=np.int64),
+        study=labels,
+        mean_treat=values["mean_treat"],
+        sd_treat=values["sd_treat"],
+        n_treat=values["n_treat"],
+        mean_control=values["mean_control"],
+        sd_control=values["sd_control"],
+        n_control=values["n_control"],
+        included=active,
+        exclusion_reason=reasons,
+    )
+
+
+def _exact_hedges_correction(df: NDArray[np.float64]) -> NDArray[np.float64]:
+    """Return the exact gamma-function correction J(df)."""
+
+    return np.exp(
+        gammaln(df / 2.0) - 0.5 * np.log(df / 2.0) - gammaln((df - 1.0) / 2.0)
+    )
+
+
+def calculate_continuous_effects(
+    studies: ContinuousStudies,
+    *,
+    measure: str,
+    smd_variance: str = "LS",
+) -> ContinuousEffectData:
+    """Calculate mean differences or exact-corrected Hedges' g values."""
+
+    normalized_measure = measure.upper()
+    if normalized_measure not in {"MD", "SMD"}:
+        raise UnsupportedMethodError("measure must be 'MD' or 'SMD'.")
+    normalized_variance = smd_variance.upper().replace("-", "_")
+    if normalized_variance in {"LARGE_SAMPLE", "HEDGES_1982"}:
+        normalized_variance = "LS"
+    if normalized_measure == "SMD" and normalized_variance != "LS":
+        raise UnsupportedMethodError(
+            "smd_variance currently supports only 'LS' (the Hedges 1982 "
+            "large-sample approximation)."
+        )
+
+    included = studies.included
+    row_count = len(included)
+    effect = np.full(row_count, np.nan, dtype=np.float64)
+    variance = np.full(row_count, np.nan, dtype=np.float64)
+    pooled_sd = np.full(row_count, np.nan, dtype=np.float64)
+    cohen_d = np.full(row_count, np.nan, dtype=np.float64)
+    correction_factor = np.full(row_count, np.nan, dtype=np.float64)
+
+    difference = studies.mean_treat - studies.mean_control
+    if normalized_measure == "MD":
+        effect[included] = difference[included]
+        variance[included] = (
+            studies.sd_treat[included] ** 2 / studies.n_treat[included]
+            + studies.sd_control[included] ** 2 / studies.n_control[included]
+        )
+    else:
+        degrees_freedom = studies.n_treat + studies.n_control - 2.0
+        pooled_variance = (
+            (studies.n_treat - 1.0) * studies.sd_treat**2
+            + (studies.n_control - 1.0) * studies.sd_control**2
+        ) / degrees_freedom
+        invalid_pooled = included & (
+            ~np.isfinite(pooled_variance) | (pooled_variance <= 0.0)
+        )
+        if np.any(invalid_pooled):
+            rows = np.flatnonzero(invalid_pooled).tolist()
+            raise InvalidStudyDataError(
+                "SMD requires a finite, strictly positive pooled SD; invalid "
+                f"rows: {rows}."
+            )
+
+        pooled_sd[included] = np.sqrt(pooled_variance[included])
+        cohen_d[included] = difference[included] / pooled_sd[included]
+        correction_factor[included] = _exact_hedges_correction(
+            degrees_freedom[included]
+        )
+        effect[included] = correction_factor[included] * cohen_d[included]
+        total_n = studies.n_treat + studies.n_control
+        variance[included] = (
+            1.0 / studies.n_treat[included]
+            + 1.0 / studies.n_control[included]
+            + effect[included] ** 2 / (2.0 * total_n[included])
+        )
+
+    invalid_variance = included & (~np.isfinite(variance) | (variance <= 0.0))
+    if np.any(invalid_variance):
+        rows = np.flatnonzero(invalid_variance).tolist()
+        raise InvalidStudyDataError(
+            "Continuous sampling variances must be finite and strictly positive; "
+            f"invalid rows: {rows}."
+        )
+
+    return ContinuousEffectData(
+        studies=studies,
+        effect=effect,
+        variance=variance,
+        pooled_sd=pooled_sd,
+        cohen_d=cohen_d,
+        correction_factor=correction_factor,
+        measure=normalized_measure,
+    )

meta_analyze/estimators/__init__.py

@@ -0,0 +1,14 @@
+"""Numerical estimators used by the public meta-analysis API."""
+
+from .inverse_variance import InverseVarianceFit, fit_inverse_variance
+from .mantel_haenszel import MantelHaenszelFit, fit_mantel_haenszel
+from .tau2 import Tau2Estimate, estimate_tau2
+
+__all__ = [
+    "InverseVarianceFit",
+    "MantelHaenszelFit",
+    "Tau2Estimate",
+    "estimate_tau2",
+    "fit_inverse_variance",
+    "fit_mantel_haenszel",
+]