hestia-earth-models 0.64.4__py3-none-any.whl → 0.64.5__py3-none-any.whl

tests/models/utils/test_blank_node.py

@@ -1,12 +1,15 @@
+import os
+import json
 from datetime import datetime
 import pytest
 from pytest import mark
 from unittest.mock import patch
+from tests.utils import fixtures_path
 
 from hestia_earth.schema import SiteSiteType
 from hestia_earth.utils.tools import parse
-
 from hestia_earth.models.utils.blank_node import (
+    condense_nodes,
     _calc_datetime_range_intersection_duration,
     _gapfill_datestr,
     _get_datestr_format,
@@ -19,11 +22,172 @@ from hestia_earth.models.utils.blank_node import (
     group_nodes_by_year,
     group_nodes_by_year_and_month,
     GroupNodesByYearMode,
-    split_node_by_dates
+    split_node_by_dates,
+    _most_recent_nodes,
+    _shallowest_node
 )
 
 
 class_path = "hestia_earth.models.utils.blank_node"
+measurement_fixtures_folder = f"{fixtures_path}/utils/measurement"
+
+fixtures_path = os.path.join(fixtures_path, 'utils', 'blank_node')
+
+
+def test_condense_nodes():
+    with open(f"{fixtures_path}/condense-nodes/original.jsonld", encoding='utf-8') as f:
+        original = json.load(f)
+    with open(f"{fixtures_path}/condense-nodes/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = condense_nodes(original)
+    assert value == expected
+
+
+@pytest.mark.parametrize(
+    "test_name,input_nodes,expected_output_nodes",
+    [
+        (
+            "No match",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [2]},
+            ],
+        ),
+        (
+            "No continuity",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+        ),
+        (
+            "No continuity (multiple values differ)",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 30]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 30]},
+            ],
+        ),
+        (
+            "2-1 condense (YYYY dates)",
+            [
+                {"startDate": "2001", "endDate": "2001", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2002", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]}
+            ],
+        ),
+        (
+            "4-2 condense (YYYY-MM dates)",
+            [
+                {"startDate": "2001-01", "endDate": "2002-01", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2002-01", "endDate": "2002-03", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001-01", "endDate": "2002-03", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]}
+            ],
+        ),
+        (
+            "2-1 condense (YYYY-MM-DD dates)",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2002-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]}
+            ],
+        ),
+        (
+            "3-1-condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-01-01", "endDate": "2002-10-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-11-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]}
+            ],
+        ),
+        (
+            "3-2-partial-condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+            ],
+        ),
+        (
+            "7-2-multi-condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2001-12-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2002-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2013-01-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2012-02-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]}
+            ],
+        ),
+    ]
+)
+def test_condense_nodes_(test_name, input_nodes, expected_output_nodes):
+    assert condense_nodes(input_nodes) == expected_output_nodes
 
 
 def test_run_required():
@@ -978,11 +1142,11 @@ PARAMS_SPLIT_NODE = [
     )
 ]
 IDS_SPLIT_NODE = [
-    "no split -> empty node",
-    "no split -> not enough dates",  # len(value) and len(dates) MUST match
-    "no split -> startDate & endDate",
-    "no split -> non-iterable value",  # i.e., on a Management or Animal node.
-    "no split -> null value",  # i.e., on a Animal node where value is not required.
+    "no split - empty node",
+    "no split - not enough dates",  # len(value) and len(dates) MUST match
+    "no split - startDate & endDate",
+    "no split - non-iterable value",  # i.e., on a Management or Animal node.
+    "no split - null value",  # i.e., on a Animal node where value is not required.
     "value & dates",
     "descriptive statistics",
     "descriptive statistics w/ bad key"  # if descriptive statistic keys have wrong length, don't split them
@@ -992,3 +1156,23 @@ IDS_SPLIT_NODE = [
 @mark.parametrize("node, expected", PARAMS_SPLIT_NODE, ids=IDS_SPLIT_NODE)
 def test_split_node_by_dates(node, expected):
     assert split_node_by_dates(node) == expected
+
+
+def test_most_recent_measurements():
+    with open(f"{measurement_fixtures_folder}/measurements.jsonld", encoding='utf-8') as f:
+        measurements = json.load(f)
+
+    with open(f"{measurement_fixtures_folder}/most-recent/measurements.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    assert _most_recent_nodes(measurements, '2011') == expected
+
+
+def test_shallowest_measurement():
+    with open(f"{measurement_fixtures_folder}/most-recent/measurements.jsonld", encoding='utf-8') as f:
+        measurements = json.load(f)
+
+    with open(f"{measurement_fixtures_folder}/shallowest/measurement.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    assert _shallowest_node(measurements) == expected

tests/models/utils/test_descriptive_stats.py

@@ -1,93 +1,9 @@
-from numpy import array, inf
-from numpy.testing import assert_almost_equal
+from numpy import array
 from pytest import mark
 
 from hestia_earth.schema import MeasurementStatsDefinition
 
-from hestia_earth.models.utils.descriptive_stats import (
-    _calc_confidence_level, calc_confidence_level_monte_carlo, calc_descriptive_stats, calc_precision_monte_carlo,
-    calc_required_iterations_monte_carlo, calc_z_critical
-)
-
-# 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)
-
+from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
 
 EXPECTED_FLATTENED = {
     "value": [5],

tests/models/utils/test_measurement.py

@@ -7,8 +7,7 @@ from hestia_earth.schema import MeasurementMethodClassification
 from tests.utils import fixtures_path, TERM
 
 from hestia_earth.models.utils.measurement import (
-    _new_measurement, most_relevant_measurement_value, _most_recent_measurements, _shallowest_measurement,
-    min_measurement_method_classification
+    _new_measurement, most_relevant_measurement_value, min_measurement_method_classification
 )
 
 class_path = 'hestia_earth.models.utils.measurement'
@@ -70,26 +69,6 @@ def test_most_relevant_measurement_value_by_year_month_day():
     assert most_relevant_measurement_value(measurements, 'soilPh', '2030-01-07') == 2030
 
 
-def test_most_recent_measurements():
-    with open(f"{fixtures_folder}/measurements.jsonld", encoding='utf-8') as f:
-        measurements = json.load(f)
-
-    with open(f"{fixtures_folder}/most-recent/measurements.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    assert _most_recent_measurements(measurements, '2011') == expected
-
-
-def test_shallowest_measurement():
-    with open(f"{fixtures_folder}/most-recent/measurements.jsonld", encoding='utf-8') as f:
-        measurements = json.load(f)
-
-    with open(f"{fixtures_folder}/shallowest/measurement.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    assert _shallowest_measurement(measurements) == expected
-
-
 @mark.parametrize(
     "input, expected",
     [

tests/models/utils/test_stats.py

@@ -0,0 +1,186 @@
+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)

tests/models/utils/test_time_series.py

@@ -0,0 +1,88 @@
+from numpy import array, e, inf
+from numpy.typing import NDArray
+from numpy.testing import assert_almost_equal
+from hestia_earth.utils.date import YEAR
+from hestia_earth.models.utils.time_series import (
+    calc_tau, compute_time_series_correlation_matrix, exponential_decay
+)
+
+from pytest import mark
+
+
+SEED = 0
+N_ITERATIONS = 10000
+
+
+# datestrs, half_life, expected
+PARAMS_COMPUTE_CORRELATION_MATRIX = [
+    (
+        ['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04', '2000-01-05'],
+        1,
+        array([
+            [1.0, 0.5, 0.25, 0.125, 0.0625],
+            [0.5, 1.0, 0.5, 0.25, 0.125],
+            [0.25, 0.5, 1.0, 0.5, 0.25],
+            [0.125, 0.25, 0.5, 1.0, 0.5],
+            [0.0625, 0.125, 0.25, 0.5, 1.0]
+        ])
+    ),
+    (
+        ['2000-01-01', '2001-01-01', '2002-01-01', '2003-01-01'],
+        20*YEAR,
+        array([
+            [1.0, 0.965867, 0.932987, 0.901227],
+            [0.965867, 1.0, 0.965959, 0.933076],
+            [0.932987, 0.965959, 1.0, 0.965959],
+            [0.901227, 0.933076, 0.965959, 1.0]
+        ])
+    )
+]
+IDS_COMPUTE_CORRELATION_MATRIX = [
+    "dt: 1d, half-life: 1d",
+    "dt: 1y, half-life: 20y"
+]
+
+
+@mark.parametrize(
+    "datestrs, half_life, expected",
+    PARAMS_COMPUTE_CORRELATION_MATRIX,
+    ids=IDS_COMPUTE_CORRELATION_MATRIX
+)
+def test_compute_time_series_correlation_matrix(datestrs: list[str], half_life: float, expected: NDArray):
+    tau = calc_tau(half_life)
+    result = compute_time_series_correlation_matrix(
+        datestrs,
+        decay_fn=lambda dt: exponential_decay(dt, tau=tau)
+    )
+
+    assert_almost_equal(result, expected, decimal=6)
+
+
+# half_life, expected
+PARAMS_CALC_TAU = [(0.693147, 1), (1, 1.442695), (20, 28.853901), (YEAR, 526.933543)]
+IDS_CALC_TAU = [half_life for half_life, *_ in PARAMS_CALC_TAU]
+
+
+@mark.parametrize("half_life, expected", PARAMS_CALC_TAU, ids=IDS_CALC_TAU)
+def test_calc_tau(half_life: float, expected: float):
+    result = calc_tau(half_life)
+    assert_almost_equal(result, expected, decimal=6)
+
+
+PARAMS_EXPONENTIAL_DECAY = [
+    (0, 1, 1, 0, 1),
+    (1, 1, 1, 0, e ** -1),
+    (inf, 1, 1, 0, 0),
+    (YEAR, calc_tau(YEAR), 1.5, -3, -0.75)  # 1 year w/ half-life = 1 year and custom min/max
+]
+IDS_EXPONENTIAL_DECAY = [f"t: {t:0.2f}, tau: {tau:0.2f}" for t, tau, *_ in PARAMS_EXPONENTIAL_DECAY]
+
+
+@mark.parametrize(
+    "t, tau, initial_value, final_value, expected",
+    PARAMS_EXPONENTIAL_DECAY,
+    ids=IDS_EXPONENTIAL_DECAY
+)
+def test_exponential_decay(t: float, tau: float, initial_value: float, final_value: float, expected: float):
+    result = exponential_decay(t, tau, initial_value, final_value)
+    assert_almost_equal(result, expected, decimal=6)