prpy 0.3.2__tar.gz → 0.3.4__tar.gz

{prpy-0.3.2/prpy.egg-info → prpy-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prpy
-Version: 0.3.2
+Version: 0.3.4
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License

{prpy-0.3.2 → prpy-0.3.4}/prpy/numpy/image.py

@@ -22,7 +22,6 @@ import imghdr
 import math
 import numpy as np
 import os
-from PIL import Image
 import logging
 from typing import Union, Tuple
 
@@ -244,6 +243,7 @@ def probe_image_inputs(
         # Image
         if not allow_image:
           raise ValueError(f"allow_image={allow_image}, but received a path to an image file.")
+        from PIL import Image
         with Image.open(inputs) as img:
           width, height = img.size
           channels = len(img.getbands())
@@ -363,6 +363,7 @@ def parse_image_inputs(
         if not allow_image:
           raise ValueError(f"allow_image={allow_image}, but received a path to an image file.")
         try:
+          from PIL import Image
           inputs = np.asarray(Image.open(open(inputs, 'rb')))
         except Exception as e:
           raise ValueError(f"Problem reading image from {inputs}: {e}")

{prpy-0.3.2 → prpy-0.3.4}/prpy/numpy/metric.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Philipp Rouast
+# Copyright (c) 2025 Philipp Rouast
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,15 @@ import numpy as np
 from scipy import signal
 from typing import Union
 
-def mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
+def _masked_sum(x, mask, axis, *, keepdims=False):
+  return np.where(mask, x, 0.0).sum(axis=axis, keepdims=keepdims)
+
+def _safe_mean(x, mask, axis):
+  n_valid = mask.sum(axis=axis, keepdims=True)
+  n_safe  = np.where(n_valid == 0, 1, n_valid)
+  return _masked_sum(x, mask, axis, keepdims=True) / n_safe
+
+def _mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
   """
   Magnitude to decibels element-wise.
 
@@ -37,7 +45,9 @@ def mag2db(mag: Union[np.ndarray, np.float64]) -> np.ndarray:
 def mae(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Mean absolute error
@@ -46,6 +56,7 @@ def mae(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     mae: The mean absolute error. Shape (..., dim_n)
   """
@@ -53,15 +64,23 @@ def mae(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.mean(np.abs(y_true - y_pred), axis=axis)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      return np.mean(np.abs(y_true - y_pred), axis=axis)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  err  = np.abs(y_true - y_pred)
+  n_valid = mask.sum(axis=axis)
+  err_sum = _masked_sum(err, mask, axis)
+  return np.where(n_valid > 0, err_sum / n_valid, np.nan)
 
 def mse(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Mean squared error
@@ -70,6 +89,7 @@ def mse(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     mse: The mean squared error. Shape (..., dim_n)
   """
@@ -77,15 +97,23 @@ def mse(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.mean(np.square(y_true - y_pred), axis=axis)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      return np.mean(np.square(y_true - y_pred), axis=axis)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  sq = (y_true - y_pred) ** 2
+  n_valid = mask.sum(axis=axis)
+  sq_sum = _masked_sum(sq, mask, axis)
+  return np.where(n_valid > 0, sq_sum / n_valid, np.nan)
 
 def rmse(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False
   ) -> np.ndarray:
   """
   Root mean squared error
@@ -94,22 +122,18 @@ def rmse(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which the means are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     rmse: The root mean squared error. Shape (..., dim_n)
   """
-  assert axis is None or isinstance(axis, int)
-  y_true = np.asarray(y_true)
-  y_pred = np.asarray(y_pred)
-  assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    return np.sqrt(np.mean(np.square(y_true - y_pred), axis=axis))
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  return np.sqrt(mse(y_true, y_pred, axis=axis, ignore_nan=ignore_nan))
 
 def cor(
     y_true: np.ndarray,
     y_pred: np.ndarray,
-    axis: Union[int, None] = -1
+    axis: Union[int, None] = -1,
+    *,
+    ignore_nan: bool = False,
   ) -> np.ndarray:
   """
   Pearson's correlation coefficient
@@ -118,6 +142,7 @@ def cor(
     y_true: True values. Shape (..., dim_n, dim_axis)
     y_pred: Predicted values. Shape (..., dim_n, dim_axis)
     axis: Axis along which correlations are computed
+    ignore_nan: If true, metric is computed on non-NaN elements only.
   Returns:
     cor: The correlation coefficients. Shape (..., dim_n)
   """
@@ -125,17 +150,29 @@ def cor(
   y_true = np.asarray(y_true)
   y_pred = np.asarray(y_pred)
   assert y_true.shape == y_pred.shape
-  if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
-    res_true = y_true - np.mean(y_true, axis=axis, keepdims=True)
-    res_pred = y_pred - np.mean(y_pred, axis=axis, keepdims=True)
-    cov = np.mean(res_true * res_pred, axis=axis)
-    var_true = np.mean(res_true**2, axis=axis)
-    var_pred = np.mean(res_pred**2, axis=axis)
-    sigma_true = np.sqrt(var_true)
-    sigma_pred = np.sqrt(var_pred)
-    return cov / (sigma_true * sigma_pred)
-  else:
-    return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  if not ignore_nan:
+    if np.all(np.isfinite(y_true)) and np.all(np.isfinite(y_pred)):
+      res_true = y_true - np.mean(y_true, axis=axis, keepdims=True)
+      res_pred = y_pred - np.mean(y_pred, axis=axis, keepdims=True)
+      cov = np.mean(res_true * res_pred, axis=axis)
+      var_true = np.mean(res_true**2, axis=axis)
+      var_pred = np.mean(res_pred**2, axis=axis)
+      sigma_true = np.sqrt(var_true)
+      sigma_pred = np.sqrt(var_pred)
+      return cov / (sigma_true * sigma_pred)
+    else:
+      return np.full(y_true.shape[:axis], fill_value=np.nan, dtype=y_true.dtype)
+  mask = np.isfinite(y_true) & np.isfinite(y_pred)
+  mean_t = _safe_mean(y_true, mask, axis)
+  mean_p = _safe_mean(y_pred, mask, axis)
+  r_true = np.where(mask, y_true - mean_t, 0.0)
+  r_pred = np.where(mask, y_pred - mean_p, 0.0)
+  n_valid = mask.sum(axis=axis)
+  cov = (r_true * r_pred).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  var_t = (r_true ** 2).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  var_p = (r_pred ** 2).sum(axis=axis) / np.where(n_valid == 0, 1, n_valid)
+  corr = cov / (np.sqrt(var_t) * np.sqrt(var_p))
+  return np.where(n_valid > 0, corr, np.nan)
 
 def snr(
     f_true: np.ndarray,
@@ -186,7 +223,7 @@ def snr(
     s_power = np.sum(pxx * gt_mask, axis=-1)
     f_mask = (f >= f_min) & (f <= f_max)
     all_power = np.sum(pxx * f_mask, axis=-1)
-    snr = mag2db(s_power / (all_power - s_power))
+    snr = _mag2db(s_power / (all_power - s_power))
     return np.squeeze(snr)
   else:
     return np.full(y_pred.shape[:-1], fill_value=np.nan, dtype=y_pred.dtype)

{prpy-0.3.2 → prpy-0.3.4}/prpy/numpy/physio.py

@@ -20,6 +20,7 @@
 
 from enum import IntEnum
 import numpy as np
+from scipy.signal import welch
 from typing import Tuple, Optional, List, Callable, Union
 
 from prpy.constants import SECONDS_PER_MINUTE, MILLIS_PER_SECOND
@@ -37,6 +38,14 @@ HR_MIN = 40               # 1/min
 HR_MAX = 240              # 1/min
 HRV_SDNN_MIN = 1          # ms
 HRV_SDNN_MAX = 200        # ms
+HRV_RMSSD_MIN = 1         # ms
+HRV_RMSSD_MAX = 200       # ms
+HRV_LF_MIN = 0            # ms^2
+HRV_LF_MAX = 5000         # ms^2
+HRV_HF_MIN = 0            # ms^2
+HRV_HF_MAX = 5000         # ms^2
+HRV_LF_HF_MIN = 0         # unitless
+HRV_LF_HF_MAX = 10        # unitless
 PTT_MIN = 100             # ms
 PTT_MAX = 400             # ms
 IDX_MIN = 0.              # unitless
@@ -50,8 +59,12 @@ SPO2_MAX = 100            # %
 
 CALC_HR_MIN_T = 5         # seconds
 CALC_HR_MAX_T = 10        # seconds
-CALC_HRV_SDNN_MIN_T = 10  # seconds
+CALC_HRV_SDNN_MIN_T = 20  # seconds
 CALC_HRV_SDNN_MAX_T = 60  # seconds
+CALC_HRV_RMSSD_MIN_T = 20 # seconds
+CALC_HRV_RMSSD_MAX_T = 60 # seconds
+CALC_HRV_LF_HF_MIN_T = 55 # seconds
+CALC_HRV_LF_HF_MAX_T = 60 # seconds
 CALC_RR_MIN_T = 10        # seconds
 CALC_RR_MAX_T = 30        # seconds
 
@@ -70,6 +83,14 @@ class EWindowUnit(IntEnum):
   DETECTIONS = 0
   SECONDS = 1
 
+class HRVMetric(IntEnum):
+  """Metric for heart rate variability."""
+  SDNN = 0
+  RMSSD = 1
+  LF = 2
+  HF = 3
+  LF_HF = 4
+
 def estimate_rate_from_signal(
     signal: np.ndarray,
     f_s: float,
@@ -523,8 +544,56 @@ def estimate_rr_from_signal(
     **kw
   )
 
-def estimate_hrv_sdnn_from_signal(
+def _get_hrv_function(
+    metric: HRVMetric,
+    f_s: float,
+    correct_quant_error: bool = False
+  ) -> Callable:
+  var_e = 1. / (12 * f_s**2) if correct_quant_error else 0.0
+  # SDNN implementation
+  def _sdnn_core(diffs: np.ndarray) -> float:
+    sd = np.sqrt(np.nanvar(diffs) - var_e) * MILLIS_PER_SECOND
+    sd = np.clip(sd, HRV_SDNN_MIN, HRV_SDNN_MAX)
+    return sd
+  # RMSSD implementation
+  def _rmssd_core(diffs: np.ndarray) -> float:
+    deltas = np.diff(diffs)
+    rmssd = np.sqrt(np.nanmean(deltas**2) - 2*var_e) * MILLIS_PER_SECOND
+    rmssd = np.clip(rmssd, HRV_RMSSD_MIN, HRV_RMSSD_MAX)
+    return rmssd
+  # LF/HF implementation
+  def _lf_hf_core(diffs: np.ndarray) -> float:
+    t = np.cumsum(diffs, dtype=np.float64)
+    t_u = np.arange(0, t[-1], 1 / f_s)
+    rr_u = np.interp(t_u, t, diffs)
+    freqs, psd = welch(rr_u - rr_u.mean(), fs=f_s, nperseg=256, detrend='linear')
+    lf_mask = (freqs >= 0.04) & (freqs < 0.15)
+    lf = np.trapz(psd[lf_mask], freqs[lf_mask])
+    lf = np.clip(lf, HRV_LF_MIN, HRV_LF_MAX)
+    hf_mask = (freqs >= 0.15) & (freqs <= 0.40)
+    hf = np.trapz(psd[hf_mask], freqs[hf_mask])
+    hf = np.clip(hf, HRV_HF_MIN, HRV_HF_MAX)
+    return lf, hf
+
+  if metric == HRVMetric.SDNN:
+    return _sdnn_core
+  elif metric == HRVMetric.RMSSD:
+    return _rmssd_core
+  elif metric == HRVMetric.LF:
+    return lambda diffs: _lf_hf_core(diffs)[0]
+  elif metric == HRVMetric.HF:
+    return lambda diffs: _lf_hf_core(diffs)[1]
+  elif metric == HRVMetric.LF_HF:
+    def _lf_hf_ratio(diffs: np.ndarray) -> float:
+      lf, hf = _lf_hf_core(diffs)
+      if hf == 0 or np.isnan(hf):
+        return np.nan
+      return np.clip(lf / hf, HRV_LF_HF_MIN, HRV_LF_HF_MAX)
+    return _lf_hf_ratio
+
+def estimate_hrv_from_signal(
     signal: np.ndarray,
+    metric: HRVMetric,
     f_s: float,
     min_window_size: float,
     max_window_size: float,
@@ -545,6 +614,7 @@ def estimate_hrv_sdnn_from_signal(
   
   Args:
     signal: The raw sensor signal. Shape (n,)
+    metric: The `HRVMetric` to use.
     f_s: Sampling frequency [Hz].
     f_range: Tuple (min, max) of plausible frequency range [Hz].
     scope: GLOBAL for scalar hrv or ROLLING for hrv trace shape (n,).
@@ -597,8 +667,9 @@ def estimate_hrv_sdnn_from_signal(
      sdnn = np.nan if scope is EScope.GLOBAL else np.full(signal.shape, np.nan)
      return sdnn, 0.
   # Continue using the detections
-  sdnn = estimate_hrv_sdnn_from_detection_sequences(
+  sdnn = estimate_hrv_from_detection_sequences(
     seqs=det_idxs,
+    metric=metric,
     f_s=f_s,
     scope=scope,
     min_window_size=min_window_size,
@@ -612,8 +683,9 @@ def estimate_hrv_sdnn_from_signal(
   )
   return sdnn, sdnn_conf
 
-def estimate_hrv_sdnn_from_detections(
+def estimate_hrv_from_detections(
     det_idxs: np.ndarray,
+    metric: HRVMetric,
     *,
     f_s: Optional[float] = None,
     t: Optional[np.ndarray] = None,
@@ -633,6 +705,7 @@ def estimate_hrv_sdnn_from_detections(
   
   Args:
     det_idxs: The detection indices. Shape (n_dets,)
+    metric: The `HRVMetric` to use.
     f_s: The sampling rate. Required when `t` is not given.
     t: The timestamps of the original signal. Required for scope.ROLLING. Shape (n,)
     scope: GLOBAL for scalar rate or ROLLING for rate trace shape (n,).
@@ -650,6 +723,7 @@ def estimate_hrv_sdnn_from_detections(
       - For Scope.ROLLING: Shape (n,)
   """
   if f_s is None: f_s = t.shape[0]/(t[-1]-t[0])
+  hrv_fn = _get_hrv_function(metric=metric, f_s=f_s, correct_quant_error=correct_quantization_error)
   def _rate_from_ts(det_t: np.ndarray) -> float:
     """Convert a 1-D array of detection times to hrv sdnn [ms]"""
     diffs = np.diff(det_t)
@@ -658,10 +732,7 @@ def estimate_hrv_sdnn_from_detections(
     if diffs.size - 1 < min_dets or det_t[-1] - det_t[0] < min_t or np.any(diffs == 0):
       # Signal not sufficient for estimation
       return np.nan
-    var_e = 1./(12*f_s**2) if correct_quantization_error else 0
-    hrv_sdnn = np.sqrt(np.nanvar(diffs) - var_e) * MILLIS_PER_SECOND
-    if hrv_sdnn > HRV_SDNN_MAX: return HRV_SDNN_MAX
-    return hrv_sdnn
+    return hrv_fn(diffs)
   def _rate_from_dets(dets: np.ndarray) -> float:
     """Convert a 1-D array of detection indices to hrv sdnn [ms]"""
     dets = np.asarray(dets)
@@ -682,8 +753,9 @@ def estimate_hrv_sdnn_from_detections(
     pad_val=pad_val
   )
 
-def estimate_hrv_sdnn_from_detection_sequences(
+def estimate_hrv_from_detection_sequences(
     seqs: List[np.ndarray],
+    metric: HRVMetric,
     *,
     f_s: Optional[float] = None,
     t: Optional[np.ndarray] = None,
@@ -703,6 +775,7 @@ def estimate_hrv_sdnn_from_detection_sequences(
   
   Args:
     seqs: List of np.ndarray sequences of detections.
+    metric: The `HRVMetric` to use.
     f_s: The sampling rate. Required when `t` is not given.
     t: The timestamps of the original signal. Required for scope.ROLLING. Shape (n,)
     scope: GLOBAL for scalar rate or ROLLING for rate trace shape (n,).
@@ -720,6 +793,7 @@ def estimate_hrv_sdnn_from_detection_sequences(
       - For Scope.ROLLING: Shape (n,)
   """
   if f_s is None: f_s = t.shape[0]/(t[-1]-t[0])
+  hrv_fn = _get_hrv_function(metric=metric, f_s=f_s, correct_quant_error=correct_quantization_error)
   def _rate_from_ts(det_t: np.ndarray) -> float:
     """Convert a 1-D array of detection times to hrv sdnn [ms]"""
     diffs = np.diff(det_t)
@@ -728,10 +802,7 @@ def estimate_hrv_sdnn_from_detection_sequences(
     if diffs.size + 1 < min_dets or det_t[-1] - det_t[0] < min_t or np.any(diffs == 0):
       # Signal not sufficient for estimation
       return np.nan
-    var_e = 1./(12*f_s**2) if correct_quantization_error else 0
-    hrv_sdnn = np.sqrt(np.nanvar(diffs) - var_e) * MILLIS_PER_SECOND
-    if hrv_sdnn > HRV_SDNN_MAX: return HRV_SDNN_MAX
-    return hrv_sdnn
+    return hrv_fn(diffs)
   def _rate_from_dets(dets: np.ndarray) -> float:
     """Convert a 1-D array of detection indices to hrv sdnn [ms]"""
     dets = np.asarray(dets)

{prpy-0.3.2 → prpy-0.3.4/prpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prpy
-Version: 0.3.2
+Version: 0.3.4
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License

{prpy-0.3.2 → prpy-0.3.4}/tests/test_numpy_metric.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Philipp Rouast
+# Copyright (c) 2025 Philipp Rouast
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -24,13 +24,31 @@ sys.path.append('../prpy')
 import numpy as np
 import pytest
 
-from prpy.numpy.metric import mag2db, mae, mse, rmse, cor, snr
+from prpy.numpy.metric import _mag2db, mae, mse, rmse, cor, snr
+
+def _make_pair(shape, seed=0, nan_ratio=0.25):
+  rng = np.random.default_rng(seed)
+  y_true = rng.normal(size=shape)
+  y_pred = rng.normal(size=shape)
+  nan_mask = rng.random(size=shape) < nan_ratio
+  y_true[nan_mask] = np.nan
+  y_pred[nan_mask & (rng.random(size=shape) < 0.5)] = np.nan
+  return y_true, y_pred
+
+nanmean_abs = lambda a, b, ax: np.nanmean(np.abs(a - b), axis=ax)
+nanmean_sq = lambda a, b, ax: np.nanmean((a - b) ** 2, axis=ax)
+
+def nan_corr_1d(a, b):
+  m = np.isfinite(a) & np.isfinite(b)
+  if m.sum() < 2: return np.nan
+  a, b = a[m] - a[m].mean(), b[m] - b[m].mean()
+  return (a * b).mean() / (a.std() * b.std())
 
 @pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
 def test_mag2db(shape):
   x = np.zeros(shape=shape)
   x_copy = x.copy()
-  out = mag2db(x)
+  out = _mag2db(x)
   assert out.shape == shape
   np.testing.assert_equal(x, x_copy)
 
@@ -45,14 +63,14 @@ def test_mae(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
-@pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
-def test_mse(shape):
-  y_true = np.zeros(shape=shape)
-  y_pred = np.zeros(shape=shape)
-  y_true_copy = y_true.copy()
-  y_pred_copy = y_pred.copy()
-  out = mse(y_true=y_true, y_pred=y_pred, axis=-1)
-  assert out.shape == shape[:-1]
+@pytest.mark.parametrize("shape", [(4,), (2, 4), (2, 3, 4)])
+def test_mae_ignore_nan(shape):
+  y_true, y_pred = _make_pair(shape)
+  y_true_copy, y_pred_copy = y_true.copy(), y_pred.copy()
+  legacy = mae(y_true, y_pred, axis=-1)
+  assert np.isnan(legacy).any()
+  ref = nanmean_abs(y_true, y_pred, -1)
+  np.testing.assert_allclose(mae(y_true, y_pred, ignore_nan=True), ref, equal_nan=True)
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
@@ -67,6 +85,13 @@ def test_rmse(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
+@pytest.mark.parametrize("shape", [(4,), (2,4), (2,3,4)])
+def test_mse_rmse_ignore_nan(shape):
+  y_t, y_p = _make_pair(shape, seed=1)
+  ref_mse  = nanmean_sq(y_t, y_p, -1)
+  np.testing.assert_allclose(mse(y_t, y_p, ignore_nan=True),  ref_mse,  equal_nan=True)
+  np.testing.assert_allclose(rmse(y_t, y_p, ignore_nan=True), np.sqrt(ref_mse), equal_nan=True)
+
 @pytest.mark.parametrize("shape", [(3,), (2, 3), (2, 3, 5)])
 def test_cor(shape):
   y_true = np.random.uniform(size=shape)
@@ -80,6 +105,14 @@ def test_cor(shape):
   np.testing.assert_equal(y_true, y_true_copy)
   np.testing.assert_equal(y_pred, y_pred_copy)
 
+@pytest.mark.parametrize("shape", [(5,), (3,5), (2,3,5)])
+def test_cor_ignore_nan(shape):
+  y_t, y_p = _make_pair(shape, seed=2)
+  ref = np.array([nan_corr_1d(a, b)
+                  for a, b in zip(y_t.reshape(-1, shape[-1]),
+                                  y_p.reshape(-1, shape[-1]))]).reshape(shape[:-1])
+  np.testing.assert_allclose(cor(y_t, y_p, ignore_nan=True), ref, equal_nan=True)
+
 @pytest.mark.parametrize("shape", [(6,), (10, 6)])
 @pytest.mark.parametrize("f_s", [5., 5])
 @pytest.mark.parametrize("tol", [.2, 1])

{prpy-0.3.2 → prpy-0.3.4}/tests/test_numpy_physio.py

@@ -24,13 +24,13 @@ sys.path.append('../prpy')
 from prpy.constants import SECONDS_PER_MINUTE
 from prpy.numpy.filters import moving_average, detrend, detrend_frequency_response
 from prpy.numpy.freq import estimate_freq
-from prpy.numpy.physio import EMethod, EScope, EWindowUnit, HR_MIN, HR_MAX
+from prpy.numpy.physio import EMethod, EScope, EWindowUnit, HR_MIN, HR_MAX, HRVMetric
 from prpy.numpy.physio import estimate_rate_from_signal
 from prpy.numpy.physio import estimate_rate_from_detections
 from prpy.numpy.physio import estimate_rate_from_detection_sequences
-from prpy.numpy.physio import estimate_hrv_sdnn_from_signal
-from prpy.numpy.physio import estimate_hrv_sdnn_from_detections
-from prpy.numpy.physio import estimate_hrv_sdnn_from_detection_sequences
+from prpy.numpy.physio import estimate_hrv_from_signal
+from prpy.numpy.physio import estimate_hrv_from_detections
+from prpy.numpy.physio import estimate_hrv_from_detection_sequences
 from prpy.numpy.physio import moving_average_size_for_hr_response, moving_average_size_for_rr_response
 from prpy.numpy.physio import detrend_lambda_for_hr_response, detrend_lambda_for_rr_response
 
@@ -296,15 +296,16 @@ def test_estimate_rate_from_detection_sequences_rolling_dynamic_seconds():
 
 def test_estimate_hrv_sdnn_from_detections_global():
   det_idxs = np.asarray([202, 392, 601, 799, 1201, 1403, 1610, 1839])
-  actual = estimate_hrv_sdnn_from_detections(det_idxs, f_s=30, interp_skipped=True, min_dets=5, min_t=1.)
+  actual = estimate_hrv_from_detections(det_idxs, metric=HRVMetric.SDNN, f_s=30, interp_skipped=True, min_dets=5, min_t=1.)
   np.testing.assert_allclose(200, actual, atol=0.1)
 
 @pytest.mark.parametrize("correct_quantization_error", [False, True])
 def test_estimate_hrv_sdnn_from_detection_sequences_global(correct_quantization_error):
   idxs_list = [[202, 392, 612, 799], [1201, 1403, 1610, 1839]]
   t = np.linspace(0, 8, 2000)
-  out = estimate_hrv_sdnn_from_detection_sequences(seqs=idxs_list,
+  out = estimate_hrv_from_detection_sequences(seqs=idxs_list,
                                                    t=t,
+                                                   metric=HRVMetric.SDNN,
                                                    correct_quantization_error=correct_quantization_error,
                                                    scope=EScope.GLOBAL,
                                                    min_dets=2,
@@ -318,8 +319,9 @@ def test_estimate_hrv_sdnn_from_detection_sequences_global(correct_quantization_
 def test_estimate_hrv_sdnn_from_detection_sequences_rolling(correct_quantization_error):
   idxs_list = [[202, 392, 612, 799], [1201, 1403, 1610, 1839]]
   t = np.linspace(0, 8, 2000)
-  out = estimate_hrv_sdnn_from_detection_sequences(seqs=idxs_list,
+  out = estimate_hrv_from_detection_sequences(seqs=idxs_list,
                                                    t=t,
+                                                   metric=HRVMetric.SDNN,
                                                    correct_quantization_error=correct_quantization_error,
                                                    min_window_size=2,
                                                    max_window_size=4,
@@ -431,8 +433,9 @@ def test_estimate_hrv_sdnn_from_signal_with_confidence(scenario):
   signal, conf, f_s, conf_threshold, expected, exp_conf = scenario
   signal = np.asarray(signal)
   conf = np.asarray(conf)
-  actual, conf = estimate_hrv_sdnn_from_signal(
+  actual, conf = estimate_hrv_from_signal(
     signal=signal,
+    metric=HRVMetric.SDNN,
     f_s=f_s,
     min_window_size=27,
     max_window_size=27,