hestia-earth-models 0.73.1__py3-none-any.whl → 0.73.2__py3-none-any.whl

hestia_earth/models/utils/stats.py

@@ -1,429 +0,0 @@
-from functools import reduce
-from numpy import abs, array, concatenate, exp, float64, inf, pi, prod, random, sign, sqrt
-from numpy.typing import NDArray
-from typing import Union
-
-
-def calc_z_critical(
-    confidence_interval: float,
-    n_sided: int = 2
-) -> float64:
-    """
-    Calculate the z-critical value from the confidence interval.
-
-    Parameters
-    ----------
-    confidence_interval : float
-        The confidence interval as a percentage between 0 and 100%.
-    n_sided : int, optional
-        The number of tails (default value = `2`).
-
-    Returns
-    -------
-    float64
-        The z-critical value as a floating point between 0 and infinity.
-    """
-    alpha = 1 - confidence_interval / 100
-    return _normal_ppf(1 - alpha / n_sided)
-
-
-def _normal_ppf(q: float64, tol: float64 = 1e-10) -> float64:
-    """
-    Calculates the percent point function (PPF), also known as the inverse cumulative distribution function (CDF), of a
-    standard normal distribution using the Newton-Raphson method.
-
-    Parameters
-    ----------
-    q : float64
-        The quantile at which to evaluate the PPF.
-    tol : float64, optional
-        The tolerance for the Newton-Raphson method. Defaults to 1e-10.
-
-    Returns
-    -------
-    float64
-        The PPF value at the given quantile.
-    """
-    INITIAL_GUESS = 0
-    MAX_ITER = 100
-
-    def step(x):
-        """Perform one step of the Newton-Raphson method."""
-        x_new = x - (_normal_cdf(x) - q) / _normal_pdf(x)
-        return x_new if abs(x_new - x) >= tol else x
-
-    return (
-        inf if q == 1 else
-        -inf if q == 0 else
-        reduce(lambda x, _: step(x), range(MAX_ITER), INITIAL_GUESS)
-    )
-
-
-def _normal_cdf(x: float64) -> float64:
-    """
-    Calculates the cumulative distribution function (CDF) of a standard normal distribution for a single value using a
-    custom error function (erf).
-
-    Parameters
-    ----------
-    x : float64
-        The point at which to evaluate the CDF.
-
-    Returns
-    -------
-    float64
-        The CDF value at the given point.
-    """
-    return 0.5 * (1 + _erf(x / sqrt(2)))
-
-
-def _erf(x: float64) -> float64:
-    """
-    Approximates the error function of a standard normal distribution using a numerical approximation based on
-    Abramowitz and Stegun formula 7.1.26.
-
-    Parameters
-    ----------
-    x : float64
-        The input value.
-
-    Returns
-    -------
-    float64
-        The approximated value of the error function.
-    """
-    # constants
-    A_1 = 0.254829592
-    A_2 = -0.284496736
-    A_3 = 1.421413741
-    A_4 = -1.453152027
-    A_5 = 1.061405429
-    P = 0.3275911
-
-    # Save the sign of x
-    sign_ = sign(x)
-    x_ = abs(x)
-
-    # A&S formula 7.1.26
-    t = 1.0 / (1.0 + P * x_)
-    y = 1.0 - (((((A_5 * t + A_4) * t) + A_3) * t + A_2) * t + A_1) * t * exp(-x_ * x_)
-
-    return sign_ * y
-
-
-def _normal_pdf(x: float64) -> float64:
-    """
-    Calculates the probability density function (PDF) of a standard normal distribution for a single value.
-
-    Parameters
-    ----------
-    x : float64
-        The point at which to evaluate the PDF.
-
-    Returns
-    -------
-    float64
-        The PDF value at the given point.
-    """
-    return 1 / sqrt(2 * pi) * exp(-0.5 * x**2)
-
-
-def _calc_confidence_level(
-    z_critical: float64,
-    n_sided: int = 2
-) -> float64:
-    """
-    Calculate the confidence interval from the z-critical value.
-
-    Parameters
-    ----------
-    z_critical_value : np.float64
-        The confidence interval as a floating point number between 0 and infinity.
-    n_sided : int, optional
-        The number of tails (default value = `2`).
-
-    Returns
-    -------
-    np.float64
-        The confidence interval as a percentage between 0 and 100%.
-    """
-    alpha = (1 - _normal_cdf(z_critical)) * n_sided
-    return (1 - alpha) * 100
-
-
-def calc_required_iterations_monte_carlo(
-    confidence_level: float,
-    precision: float,
-    sd: float
-) -> int:
-    """
-    Calculate the number of iterations required for a Monte Carlo simulation to have a desired precision, subject to a
-    given confidence level.
-
-    Parameters
-    ----------
-    confidence_level : float
-        The confidence level, as a percentage out of 100, that the precision should be subject too (i.e., we are x%
-        sure that the sample mean deviates from the true populatation mean by less than the desired precision).
-    precision : float
-        The desired precision as a floating point value (i.e., if the Monte Carlo simulation will be used to estimate
-        `organicCarbonPerHa` to a precision of 100 kg C ha-1 this value should be 100).
-    sd : float
-        The standard deviation of the sample. This can be estimated by running the model 500 times (a number that does
-        not take too much time to run but is large enough for the sample standard deviation to converge reasonably
-        well).
-
-    Returns
-    -------
-    int
-        The required number of iterations.
-    """
-    z_critical_value = calc_z_critical(confidence_level)
-    return round(((sd * z_critical_value) / precision) ** 2)
-
-
-def calc_confidence_level_monte_carlo(
-    n_iterations: int,
-    precision: float,
-    sd: float
-) -> float:
-    """
-    Calculate the confidence level that the sample mean calculated by the Monte Carlo simulation deviates from the
-    true population mean by less than the desired precision.
-
-    Parameters
-    ----------
-    n_iterations : int
-        The number of iterations that the Monte Carlo simulation was run for.
-    precision : float
-        The desired precision as a floating point value (i.e., if the Monte Carlo simulation will be used to estimate
-        `organicCarbonPerHa` to a precision of 100 kg C ha-1 this value should be 100).
-    sd : float
-        The standard deviation of the sample.
-
-    Returns
-    -------
-    float
-        The confidence level, as a percentage out of 100, that the precision should be subject too (i.e., we are x%
-        sure that the sample mean deviates from the true populatation mean by less than the desired precision).
-    """
-    return _calc_confidence_level(precision*sqrt(n_iterations)/sd)
-
-
-def calc_precision_monte_carlo(
-    confidence_level: float,
-    n_iterations: int,
-    sd: float
-) -> float:
-    """
-    Calculate the +/- precision of a Monte Carlo simulation for a desired confidence level.
-
-    Parameters
-    ----------
-    confidence_level : float
-        The confidence level, as a percentage out of 100, that the precision should be subject too (i.e., we are x%
-        sure that the sample mean deviates from the true populatation mean by less than the desired precision).
-    n_iterations : int
-        The number of iterations that the Monte Carlo simulation was run for.
-    sd : float
-        The standard deviation of the sample.
-
-    Returns
-    -------
-    float
-        The precision of the sample mean estimated by the Monte Carlo model as a floating point value with the same
-        units as the estimated mean.
-    """
-    z_critical = calc_z_critical(confidence_level)
-    return (sd*z_critical)/sqrt(n_iterations)
-
-
-def truncnorm_rvs(
-    a: float,
-    b: float,
-    loc: float,
-    scale: float,
-    shape: Union[int, tuple[int, ...]],
-    seed: Union[int, random.Generator, None] = None
-) -> NDArray:
-    """
-    Generate random samples from a truncated normal distribution. Unlike the `scipy` equivalent, the `a` and `b` values
-    are the abscissae at which we wish to truncate the distribution (as opposed to the number of standard deviations
-    from `loc`).
-
-    Parameters
-    ----------
-    a : float
-        The lower bound of the distribution.
-    b : float
-        The upper bound of the distribution.
-    loc : float
-        Mean ("centre") of the distribution.
-    scale : float
-        Standard deviation (spread or "width") of the distribution. Must be non-negative.
-    size : int | tuple[int, ...]
-        Output shape. If the given shape is, e.g., (m, n, k), then m * n * k samples are drawn.
-    seed : int | Generator | None, optional
-        A seed to initialize the BitGenerator. If passed a Generator, it will be returned unaltered. If `None`, then
-        fresh, unpredictable entropy will be pulled from the OS.
-
-    Returns
-    -------
-    NDArray
-        Array of samples.
-    """
-    size = prod(shape)
-    samples = array([])
-    rng = random.default_rng(seed)
-
-    while samples.size < size:
-        samples_temp = rng.normal(loc, scale, (size - samples.size) * 2)
-        valid_samples = samples_temp[(a <= samples_temp) & (samples_temp <= b)]
-        samples = concatenate([samples, valid_samples])
-
-    return samples[:size].reshape(shape)
-
-
-def add_normal_distributions(
-    mu_1: float, sigma_1: float, mu_2: float, sigma_2: float, rho: float = 0
-) -> tuple[float, float]:
-    """
-    Add together two normal distributions, with optional correlation.
-
-    Given two normal distributions **X<sub>1</sub> ~ N(mu<sub>1</sub>, sigma<sub>1</sub><sup>2</sup>)** and
-    **X<sub>2</sub> ~ N(mu<sub>2</sub>, sigma<sub>2</sub><sup>2</sup>)**, this function calculates the resulting mean
-    and standard deviation of the sum **Z = X<sub>1</sub> + X<sub>2</sub>**, taking into account the correlation
-    between them.
-
-    n.b. Positive correlations (`rho` > `0`) increase the standard deviation of **Z** because positively correlated
-    variables tend to move together, increasing combined uncertainty. Negative correlations (`rho` < `0`) reduces the
-    standard deviation since the variables move in opposite directions, cancelling out some of the variability.
-    Independant variables (`rho` = `0`) result in an intermediate level of uncertainty.
-
-    Parameters
-    ----------
-    mu_1 : float
-        Mean of the first normal distribution (X<sub>1</sub>).
-    sigma_1 : float
-        Standard deviation of the first normal distribution (X<sub>1</sub>).
-    mu_2 : float
-        Mean of the second normal distribution (X<sub>2</sub>).
-    sigma_2 : float
-        Standard deviation of the second normal distribution (X<sub>2</sub>).
-    rho : float, optional
-        Correlation coefficient between **X<sub>1</sub>** and **X<sub>2</sub>**. `rho` must be a value between -1
-        (perfectly negative correlation) and 1 (perfectly positive correlation). Default is 0 (independent variables).
-
-    Returns
-    -------
-    tuple[float, float]
-        A tuple in the shape `(mu_sum, sigma_sum)` containing the mean and standard deviation of the distribution
-        **Z = X<sub>1</sub> + X<sub>2</sub>**.
-    """
-    mu_sum = mu_1 + mu_2
-    sigma_sum = sqrt(
-        sigma_1 ** 2
-        + sigma_2 ** 2
-        + 2 * rho * sigma_1 * sigma_2
-    )
-    return mu_sum, sigma_sum
-
-
-def subtract_normal_distributions(
-    mu_1: float, sigma_1: float, mu_2: float, sigma_2: float, rho: float = 0
-) -> tuple[float, float]:
-    """
-    Subtract a normal distribution from another, with optional correlation.
-
-    Given two normal distributions **X<sub>1</sub> ~ N(mu<sub>1</sub>, sigma<sub>1</sub><sup>2</sup>)** and
-    **X<sub>2</sub> ~ N(mu<sub>2</sub>, sigma<sub>2</sub><sup>2</sup>)**, this function calculates the resulting mean
-    and standard deviation of the difference **Z = X<sub>1</sub> - X<sub>2</sub>**, taking into account the correlation
-    between them.
-
-    n.b. Positive correlations (`rho` > `0`) reduce the standard deviation of **Z** because positively correlated
-    variables tend to move together, cancelling out some of the variability when subtracted. Negative correlations
-    (`rho` < `0`) increase the standard deviation since the variables move in opposite directions, amplifying the
-    variability when subtracted. Independant variables (`rho` = `0`) result in an intermediate level of uncertainty.
-
-    Parameters
-    ----------
-    mu_1 : float
-        Mean of the first normal distribution (X<sub>1</sub>).
-    sigma_1 : float
-        Standard deviation of the first normal distribution (X<sub>1</sub>).
-    mu_2 : float
-        Mean of the second normal distribution (X<sub>2</sub>).
-    sigma_2 : float
-        Standard deviation of the second normal distribution (X<sub>2</sub>).
-    rho : float, optional
-        Correlation coefficient between **X<sub>1</sub>** and **X<sub>2</sub>**. `rho` must be a value between -1
-        (perfectly negative correlation) and 1 (perfectly positive correlation). Default is 0 (independent variables).
-
-    Returns
-    -------
-    tuple[float, float]
-        A tuple in the shape `(mu_diff, sigma_diff)` containing the mean and standard deviation of the distribution
-        **Z = X<sub>1</sub> - X<sub>2</sub>**.
-    """
-    mu_sum = mu_1 - mu_2
-    sigma_sum = sqrt(
-        sigma_1 ** 2
-        + sigma_2 ** 2
-        - 2 * rho * sigma_1 * sigma_2
-    )
-    return mu_sum, sigma_sum
-
-
-def lerp_normal_distributions(
-    mu_1: float,
-    sigma_1: float,
-    mu_2: float,
-    sigma_2: float,
-    alpha: float,
-    rho: float = 0
-) -> tuple[float, float]:
-    """
-    Linearly interpolate between two normal distributions, with optional correlation.
-
-    Given two normal distributions **X<sub>1</sub> ~ N(mu<sub>1</sub>, sigma<sub>1</sub><sup>2</sup>)** and
-    **X<sub>2</sub> ~ N(mu<sub>2</sub>, sigma<sub>2</sub><sup>2</sup>)**, this function calculates the resulting mean
-    and standard deviation of the interpolated distribution **Z = (1 - alpha) * X<sub>1</sub> + alpha * X<sub>2</sub>**,
-    taking into account the correlation between them.
-
-    n.b. Positive correlations (`rho` > `0`) increase the standard deviation of **Z** because positively correlated
-    variables tend to move together, increasing combined uncertainty. Negative correlations (`rho` < `0`) reduces the
-    standard deviation since the variables move in opposite directions, cancelling out some of the variability.
-    Independant variables (`rho` = `0`) result in an intermediate level of uncertainty.
-
-    Parameters
-    ----------
-    mu_1 : float
-        Mean of the first normal distribution (X<sub>1</sub>).
-    sigma_1 : float
-        Standard deviation of the first normal distribution (X<sub>1</sub>).
-    mu_2 : float
-        Mean of the second normal distribution (X<sub>2</sub>).
-    sigma_2 : float
-        Standard deviation of the second normal distribution (X<sub>2</sub>).
-    alpha : float
-        Interpolation factor (0 <= alpha <= 1). A value of 0 results in X1, a value of 1 results in X2, and values
-        between 0 and 1 interpolate between the two. Values of below 0 and above 1 will extrapolate beyond the
-        X<sub>1</sub> and X<sub>2</sub> respectively.
-    rho : float, optional
-        Correlation coefficient between **X<sub>1</sub>** and **X<sub>2</sub>**. `rho` must be a value between -1
-        (perfectly negative correlation) and 1 (perfectly positive correlation). Default is 0 (independent variables).
-
-    Returns
-    -------
-    tuple[float, float]
-        A tuple in the shape `(mu_Z sigma_Z)` containing the mean and standard deviation of the distribution
-        **Z = (1 - alpha) * X<sub>1</sub> + alpha * X<sub>2</sub>**.
-    """
-    mu_Z = (1 - alpha) * mu_1 + alpha * mu_2
-    var_Z = (
-        ((1 - alpha) ** 2) * sigma_1 ** 2
-        + (alpha ** 2) * sigma_2 ** 2
-        + 2 * alpha * (1 - alpha) * rho * sigma_1 * sigma_2
-    )
-    sigma_Z = sqrt(var_Z)
-    return mu_Z, sigma_Z

tests/models/utils/test_descriptive_stats.py

@@ -1,50 +0,0 @@
-from numpy import array
-from pytest import mark
-
-from hestia_earth.schema import MeasurementStatsDefinition
-
-from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
-
-EXPECTED_FLATTENED = {
-    "value": [5],
-    "sd": [2.581989],
-    "min": [1],
-    "max": [9],
-    "statsDefinition": "simulated",
-    "observations": [9]
-}
-
-EXPECTED_COLUMNWISE = {
-    "value": [4, 5, 6],
-    "sd": [2.44949, 2.44949, 2.44949],
-    "min": [1, 2, 3],
-    "max": [7, 8, 9],
-    "statsDefinition": "simulated",
-    "observations": [3, 3, 3]
-}
-
-EXPECTED_ROWWISE = {
-    "value": [2, 5, 8],
-    "sd": [0.816497, 0.816497, 0.816497],
-    "min": [1, 4, 7],
-    "max": [3, 6, 9],
-    "statsDefinition": "simulated",
-    "observations": [3, 3, 3]
-}
-
-
-@mark.parametrize(
-    "axis, expected",
-    [(None, EXPECTED_FLATTENED), (0, EXPECTED_COLUMNWISE), (1, EXPECTED_ROWWISE)],
-    ids=["flattened", "columnwise", "rowwise"]
-)
-@mark.parametrize("stats_definition", [MeasurementStatsDefinition.SIMULATED, "simulated"], ids=["Enum", "str"])
-def test_calc_descriptive_stats(stats_definition, axis, expected):
-    ARR = array([
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9]
-    ])
-
-    result = calc_descriptive_stats(ARR, stats_definition, axis=axis)
-    assert result == expected

tests/models/utils/test_stats.py

@@ -1,186 +0,0 @@
-from numpy import inf, sqrt
-from numpy.testing import assert_almost_equal
-from pytest import mark
-
-from hestia_earth.models.utils.stats import (
-    _calc_confidence_level, add_normal_distributions, calc_confidence_level_monte_carlo, calc_precision_monte_carlo,
-    calc_required_iterations_monte_carlo, calc_z_critical, lerp_normal_distributions, subtract_normal_distributions
-)
-
-
-# confidence_level, n_sided, z_critical
-CONFIDENCE_INTERVAL_PARAMS = [
-    # 1 sided
-    (0, 1, -inf),
-    (50, 1, 0),
-    (80, 1, 0.8416),
-    (90, 1, 1.2816),
-    (95, 1, 1.6449),
-    (99, 1, 2.3263),
-    (100, 1, inf),
-    # 2 sided
-    (0, 2, 0),
-    (50, 2, 0.6745),
-    (80, 2, 1.2816),
-    (90, 2, 1.6449),
-    (95, 2, 1.9600),
-    (99, 2, 2.5758),
-    (100, 2, inf)
-]
-
-
-@mark.parametrize(
-    "confidence_level, n_sided, z_critical",
-    CONFIDENCE_INTERVAL_PARAMS,
-    ids=[f"z={z}, n={n}" for _, n, z in CONFIDENCE_INTERVAL_PARAMS]
-)
-def test_calc_confidence_level(confidence_level, n_sided, z_critical):
-    result = _calc_confidence_level(z_critical, n_sided=n_sided)
-    assert_almost_equal(result, confidence_level, decimal=2)
-
-
-@mark.parametrize(
-    "confidence_level, n_sided, z_critical",
-    CONFIDENCE_INTERVAL_PARAMS,
-    ids=[f"conf={conf}, n={n}" for conf, n, _ in CONFIDENCE_INTERVAL_PARAMS]
-)
-def test_calc_z_critical(confidence_level, n_sided, z_critical):
-    result = calc_z_critical(confidence_level, n_sided=n_sided)
-    assert_almost_equal(result, z_critical, decimal=4)
-
-
-# confidence_level, n_iterations, precision, sd
-MONTE_CARLO_PARAMS = [
-    (95, 80767, 0.01, 1.45),
-    (95, 1110, 0.01, 0.17),
-    (99, 1917, 0.01, 0.17),
-    (50, 102, 100.18, 1500)
-]
-
-
-@mark.parametrize(
-    "confidence_level, n_iterations, precision, sd",
-    MONTE_CARLO_PARAMS,
-    ids=[f"n={n}, prec={prec}, sd={sd}" for _, n, prec, sd in MONTE_CARLO_PARAMS]
-)
-def test_calc_confidence_level_monte_carlo(confidence_level, n_iterations, precision, sd):
-    result = calc_confidence_level_monte_carlo(n_iterations, precision, sd,)
-    assert_almost_equal(result, confidence_level, decimal=2)
-
-
-@mark.parametrize(
-    "confidence_level, n_iterations, precision, sd",
-    MONTE_CARLO_PARAMS,
-    ids=[f"conf={conf}, prec={prec}, sd={sd}" for conf, _, prec, sd in MONTE_CARLO_PARAMS]
-)
-def test_calc_required_iterations_monte_carlo(confidence_level, n_iterations, precision, sd):
-    result = calc_required_iterations_monte_carlo(confidence_level, precision, sd)
-    assert result == n_iterations
-
-
-@mark.parametrize(
-    "confidence_level, n_iterations, precision, sd",
-    MONTE_CARLO_PARAMS,
-    ids=[f"conf={conf}, n={n}, sd={sd}" for conf, n, _, sd in MONTE_CARLO_PARAMS]
-)
-def test_calc_precision_monte_carlo(confidence_level, n_iterations, precision, sd):
-    result = calc_precision_monte_carlo(confidence_level, n_iterations, sd)
-    assert_almost_equal(result, precision, decimal=2)
-
-
-# mu_1, sigma_1, mu_2, sigma_2, rho, sum_mean, sum_sigma, diff_mean, diff_sigma
-PARAMS_NORMAL_DIST = [
-    # 2 standard normal distributions, perfectly negative correlation
-    (0, 1, 0, 1, -1, 0, 0, 0, 2),
-    # 2 standard normal distributions, negative correlation
-    (0, 1, 0, 1, -0.5, 0, 1, 0, sqrt(3)),
-    # 2 standard normal distributions, no correlation
-    (0, 1, 0, 1, 0, 0, sqrt(2), 0, sqrt(2)),
-    # 2 standard normal distributions, positive correlation
-    (0, 1, 0, 1, 0.5, 0, sqrt(3), 0, 1),
-    # 2 standard normal distributions, perfectly positive correlation
-    (0, 1, 0, 1, 1, 0, 2, 0, 0),
-    # different normal distributions, perfectly negative correlation
-    (50000, 3000, 45000, 9000, -1, 95000, 6000, 5000, 12000),
-    # different normal distributions, no correlation
-    (50000, 3000, 45000, 9000, 0, 95000, sqrt(90000000), 5000, sqrt(90000000)),
-    # different normal distributions, perfectly positive correlation
-    (50000, 3000, 45000, 9000, 1, 95000, 12000, 5000, 6000)
-]
-IDS_ADD_NORMAL_DIST = [
-    f"N({mu_1}, {sigma_1}^2) + N({mu_2}, {sigma_2}^2), rho: {rho}"
-    for mu_1, sigma_1, mu_2, sigma_2, rho, *_ in PARAMS_NORMAL_DIST
-]
-IDS_SUBTRACT_DIST = [
-    f"N({mu_1}, {sigma_1}^2) - N({mu_2}, {sigma_2}^2), rho: {rho}"
-    for mu_1, sigma_1, mu_2, sigma_2, rho, *_ in PARAMS_NORMAL_DIST
-]
-
-
-@mark.parametrize(
-    "mu_1, sigma_1, mu_2, sigma_2, rho, sum_mean, sum_sigma, _diff_mean, _diff_sigma",
-    PARAMS_NORMAL_DIST,
-    ids=IDS_ADD_NORMAL_DIST
-)
-def test_add_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, rho, sum_mean, sum_sigma, _diff_mean, _diff_sigma):
-    result = add_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, rho)
-    assert result == (sum_mean, sum_sigma)
-
-
-@mark.parametrize(
-    "mu_1, sigma_1, mu_2, sigma_2, rho, _sum_mean, _sum_sigma, diff_mean, diff_sigma",
-    PARAMS_NORMAL_DIST,
-    ids=IDS_SUBTRACT_DIST
-)
-def test_subtract_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, rho, _sum_mean, _sum_sigma, diff_mean, diff_sigma):
-    result = subtract_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, rho)
-    assert result == (diff_mean, diff_sigma)
-
-
-# mu_1, sigma_1, mu_2, sigma_2, alpha, rho, Z_mean, Z_sigma
-PARAMS_LERP_NORMAL_DIST = [
-    # 2 standard normal distributions, perfectly negative correlation
-    (0, 1, 0, 1, 0, -1, 0, 1),
-    (0, 1, 0, 1, 0.5, -1, 0, 0),
-    (0, 1, 0, 1, 1, -1, 0, 1),
-    # 2 standard normal distributions, no correlation
-    (0, 1, 0, 1, 0, 0, 0, 1),
-    (0, 1, 0, 1, 0.5, 0, 0, sqrt(0.5)),
-    (0, 1, 0, 1, 1, 0, 0, 1),
-    # 2 standard normal distributions, perfectly positive correlation
-    (0, 1, 0, 1, 0, 1, 0, 1),
-    (0, 1, 0, 1, 0.5, 1, 0, 1),
-    (0, 1, 0, 1, 1, 1, 0, 1),
-    # different normal distributions, perfectly negative correlation
-    (10000, 3000, 5000, 2500, -0.5, -1, 12500, 5750),
-    (10000, 3000, 5000, 2500, 0, -1, 10000, 3000),
-    (10000, 3000, 5000, 2500, 0.5, -1, 7500, 250),
-    (10000, 3000, 5000, 2500, 1, -1, 5000, 2500),
-    (10000, 3000, 5000, 2500, 1.5, -1, 2500, 5250),
-    # different normal distributions, no correlation
-    (10000, 3000, 5000, 2500, -0.5, 0, 12500, sqrt(21812500)),
-    (10000, 3000, 5000, 2500, 0, 0, 10000, 3000),
-    (10000, 3000, 5000, 2500, 0.5, 0, 7500, sqrt(3812500)),
-    (10000, 3000, 5000, 2500, 1, 0, 5000, 2500),
-    (10000, 3000, 5000, 2500, 1.5, 0, 2500, sqrt(16312500)),
-    # different normal distributions, perfectly positive correlation
-    (10000, 3000, 5000, 2500, -0.5, 1, 12500, 3250),
-    (10000, 3000, 5000, 2500, 0, 1, 10000, 3000),
-    (10000, 3000, 5000, 2500, 0.5, 1, 7500, 2750.0),
-    (10000, 3000, 5000, 2500, 1, 1, 5000, 2500),
-    (10000, 3000, 5000, 2500, 1.5, 1, 2500, 2250)
-]
-IDS_LERP_NORMAL_DIST = [
-    f"N({mu_1}, {sigma_1}^2) - N({mu_2}, {sigma_2}^2), alpha: {alpha}, rho: {rho}"
-    for mu_1, sigma_1, mu_2, sigma_2, alpha, rho, *_ in PARAMS_LERP_NORMAL_DIST
-]
-
-
-@mark.parametrize(
-    "mu_1, sigma_1, mu_2, sigma_2, alpha, rho, Z_mean, Z_sigma",
-    PARAMS_LERP_NORMAL_DIST,
-    ids=IDS_LERP_NORMAL_DIST
-)
-def test_lerp_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, alpha, rho, Z_mean, Z_sigma):
-    result = lerp_normal_distributions(mu_1, sigma_1, mu_2, sigma_2, alpha, rho)
-    assert result == (Z_mean, Z_sigma)