fastmoda 2026.10.16__py3-none-any.whl

fastmoda/__init__.py

@@ -0,0 +1,38 @@
+"""FastMODA: Efficient signal decomposition with FFT + changepoint detection
+
+Includes GPU acceleration support via PyTorch/CUDA when available.
+"""
+
+__version__ = "2026.10.16"
+from fastmoda.fastmoda import (
+    load_signal, sliding_fft, compute_band_powers, detect_changepoints,
+    extract_instantaneous_frequency, extract_band_frequencies,
+    fit_sine_segments, detect_periodicity_changes
+)
+
+# Try to import GPU utilities (optional)
+try:
+    from fastmoda.gpu_utils import (
+        sliding_fft_gpu, compute_band_powers_gpu, batch_sliding_fft_gpu,
+        is_gpu_available, get_gpu_info, get_device,
+        to_tensor, to_numpy, benchmark_gpu_vs_cpu
+    )
+    GPU_AVAILABLE = True
+except ImportError:
+    GPU_AVAILABLE = False
+
+__all__ = [
+    # Core CPU functions
+    'load_signal', 'sliding_fft', 'compute_band_powers', 'detect_changepoints',
+    'extract_instantaneous_frequency', 'extract_band_frequencies',
+    'fit_sine_segments', 'detect_periodicity_changes',
+]
+
+# Add GPU functions to __all__ if available
+if GPU_AVAILABLE:
+    __all__.extend([
+        'sliding_fft_gpu', 'compute_band_powers_gpu', 'batch_sliding_fft_gpu',
+        'is_gpu_available', 'get_gpu_info', 'get_device',
+        'to_tensor', 'to_numpy', 'benchmark_gpu_vs_cpu', 'GPU_AVAILABLE'
+    ])
+

fastmoda/analysis_gpu.py

@@ -0,0 +1,467 @@
+"""GPU-optimized analysis functions for FastMODA
+
+Implements various signal analysis methods with GPU acceleration:
+- Phase Analysis (Hilbert transform, instantaneous phase)
+- Windowed FFT (STFT)
+- Wavelet Transform
+- Coherence Analysis
+- Bispectrum Analysis
+"""
+
+import numpy as np
+from typing import Tuple, Optional, Dict, List
+import warnings
+
+# Try to import GPU libraries
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    # torch is optional (the [gpu] extra): note it in the log, not on import
+    import logging
+    logging.getLogger(__name__).info("PyTorch not available. GPU acceleration disabled for analysis.")
+
+try:
+    import cupy as cp
+    CUPY_AVAILABLE = True
+except ImportError:
+    CUPY_AVAILABLE = False
+
+
+def is_gpu_available() -> bool:
+    """Check if GPU is available for computation"""
+    if TORCH_AVAILABLE:
+        return torch.cuda.is_available()
+    elif CUPY_AVAILABLE:
+        try:
+            cp.cuda.Device(0).compute_capability
+            return True
+        except:
+            return False
+    return False
+
+
+# ==================== Phase Analysis ====================
+
+def hilbert_transform_gpu(x: np.ndarray) -> np.ndarray:
+    """
+    GPU-accelerated Hilbert transform for instantaneous phase/amplitude
+
+    Args:
+        x: Input signal (1D array)
+
+    Returns:
+        Analytic signal (complex array)
+    """
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        # Use PyTorch GPU
+        x_gpu = torch.from_numpy(x).cuda()
+
+        # FFT-based Hilbert transform
+        X = torch.fft.fft(x_gpu)
+        N = len(x)
+        h = torch.zeros(N, device='cuda')
+        if N % 2 == 0:
+            h[0] = h[N // 2] = 1
+            h[1:N // 2] = 2
+        else:
+            h[0] = 1
+            h[1:(N + 1) // 2] = 2
+
+        analytic = torch.fft.ifft(X * h)
+        return analytic.cpu().numpy()
+    else:
+        # CPU fallback
+        from scipy.signal import hilbert
+        return hilbert(x)
+
+
+def compute_instantaneous_phase_gpu(x: np.ndarray, fs: float = 1.0) -> Dict:
+    """
+    Compute instantaneous phase and frequency using GPU
+
+    Args:
+        x: Input signal
+        fs: Sampling frequency
+
+    Returns:
+        Dictionary with phase, frequency, amplitude
+    """
+    analytic = hilbert_transform_gpu(x)
+
+    # Instantaneous amplitude and phase
+    amplitude = np.abs(analytic)
+    phase = np.angle(analytic)
+
+    # Instantaneous frequency (derivative of phase)
+    inst_freq = np.diff(np.unwrap(phase)) * fs / (2 * np.pi)
+    inst_freq = np.concatenate([[inst_freq[0]], inst_freq])  # Pad to match length
+
+    return {
+        'amplitude': amplitude,
+        'phase': phase,
+        'frequency': inst_freq,
+        'analytic': analytic
+    }
+
+
+def phase_coherence_gpu(x1: np.ndarray, x2: np.ndarray,
+                        fs: float = 1.0,
+                        window_size: int = 100) -> Dict:
+    """
+    Compute phase coherence between two signals using GPU
+
+    Args:
+        x1, x2: Input signals
+        fs: Sampling frequency
+        window_size: Window for computing coherence
+
+    Returns:
+        Dictionary with coherence metrics
+    """
+    # Get instantaneous phases
+    phase1 = compute_instantaneous_phase_gpu(x1, fs)['phase']
+    phase2 = compute_instantaneous_phase_gpu(x2, fs)['phase']
+
+    # Phase difference
+    phase_diff = phase1 - phase2
+
+    # Phase locking value (PLV) — vectorised sliding window via stride trick
+    hop  = window_size // 2
+    pd   = np.asarray(phase_diff)
+    n_w  = (len(pd) - window_size) // hop
+    # Build [n_windows, window_size] view without copying
+    shape   = (n_w, window_size)
+    strides = (pd.strides[0] * hop, pd.strides[0])
+    windows = np.lib.stride_tricks.as_strided(pd, shape=shape, strides=strides)
+    plv   = np.abs(np.mean(np.exp(1j * windows), axis=1))
+    times = (np.arange(n_w) * hop + window_size / 2) / fs
+
+    return {
+        'phase_diff': phase_diff,
+        'plv': np.array(plv),
+        'times': np.array(times),
+        'phase1': phase1,
+        'phase2': phase2
+    }
+
+
+# ==================== Windowed FFT (STFT) ====================
+
+def stft_gpu(x: np.ndarray, fs: float = 1.0,
+             window_size: int = 256,
+             hop_size: int = 128,
+             window: str = 'hann') -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    GPU-accelerated Short-Time Fourier Transform
+
+    Args:
+        x: Input signal
+        fs: Sampling frequency
+        window_size: Size of the window
+        hop_size: Hop size between windows
+        window: Window type ('hann', 'hamming', 'blackman')
+
+    Returns:
+        frequencies, times, STFT magnitude
+    """
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        # Use PyTorch GPU
+        x_gpu = torch.from_numpy(x.astype(np.float32)).cuda()
+
+        # Create window
+        if window == 'hann':
+            win = torch.hann_window(window_size, device='cuda')
+        elif window == 'hamming':
+            win = torch.hamming_window(window_size, device='cuda')
+        elif window == 'blackman':
+            win = torch.blackman_window(window_size, device='cuda')
+        else:
+            win = torch.ones(window_size, device='cuda')
+
+        # Compute STFT
+        stft_result = torch.stft(
+            x_gpu,
+            n_fft=window_size,
+            hop_length=hop_size,
+            win_length=window_size,
+            window=win,
+            return_complex=True
+        )
+
+        # Get magnitude
+        magnitude = torch.abs(stft_result).cpu().numpy()
+
+        # Frequency and time axes
+        freqs = np.fft.rfftfreq(window_size, 1/fs)
+        times = np.arange(magnitude.shape[1]) * hop_size / fs
+
+        return freqs, times, magnitude
+    else:
+        # CPU fallback using scipy
+        from scipy.signal import stft as scipy_stft
+        freqs, times, Zxx = scipy_stft(x, fs, window=window,
+                                        nperseg=window_size,
+                                        noverlap=window_size - hop_size)
+        return freqs, times, np.abs(Zxx)
+
+
+# ==================== Wavelet Transform ====================
+
+def morlet_wavelet_gpu(t: np.ndarray, f: float, sigma: float = 5.0) -> np.ndarray:
+    """
+    Generate Morlet wavelet on GPU
+
+    Args:
+        t: Time array
+        f: Frequency
+        sigma: Width parameter
+
+    Returns:
+        Complex Morlet wavelet
+    """
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        t_gpu = torch.from_numpy(t.astype(np.float32)).cuda()
+        f_gpu = torch.tensor(f, device='cuda')
+        sigma_gpu = torch.tensor(sigma, device='cuda')
+
+        wavelet = (torch.pi ** -0.25) * torch.exp(2j * torch.pi * f_gpu * t_gpu) * \
+                  torch.exp(-(t_gpu ** 2) / (2 * sigma_gpu ** 2))
+        return wavelet.cpu().numpy()
+    else:
+        # CPU fallback
+        return (np.pi ** -0.25) * np.exp(2j * np.pi * f * t) * \
+               np.exp(-(t ** 2) / (2 * sigma ** 2))
+
+
+def cwt_gpu(x: np.ndarray, fs: float = 1.0,
+            freq_range: Tuple[float, float] = (0.5, 50),
+            n_freqs: int = 50) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    GPU-accelerated Continuous Wavelet Transform
+
+    Args:
+        x: Input signal
+        fs: Sampling frequency
+        freq_range: (min_freq, max_freq)
+        n_freqs: Number of frequency bins
+
+    Returns:
+        frequencies, times, CWT coefficients (magnitude)
+    """
+    freqs = np.logspace(np.log10(freq_range[0]), np.log10(freq_range[1]), n_freqs)
+    times = np.arange(len(x)) / fs
+
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        x_gpu = torch.from_numpy(x.astype(np.complex64)).cuda()
+        cwt_matrix = torch.zeros((n_freqs, len(x)), dtype=torch.complex64, device='cuda')
+
+        for i, freq in enumerate(freqs):
+            # Create wavelet
+            scale = 1.0 / freq
+            t_wavelet = np.arange(-4 * scale, 4 * scale, 1/fs)
+            wavelet = morlet_wavelet_gpu(t_wavelet, freq)
+            wavelet_gpu = torch.from_numpy(wavelet.astype(np.complex64)).cuda()
+
+            # Convolve with signal (using FFT convolution)
+            if len(wavelet_gpu) < len(x_gpu):
+                # Pad wavelet
+                padded_wavelet = torch.zeros(len(x_gpu), dtype=torch.complex64, device='cuda')
+                start = len(x_gpu) // 2 - len(wavelet_gpu) // 2
+                padded_wavelet[start:start + len(wavelet_gpu)] = wavelet_gpu
+
+                # FFT convolution
+                X = torch.fft.fft(x_gpu)
+                W = torch.fft.fft(padded_wavelet)
+                cwt_matrix[i, :] = torch.fft.ifft(X * torch.conj(W))
+
+        magnitude = torch.abs(cwt_matrix).cpu().numpy()
+        return freqs, times, magnitude
+    else:
+        # CPU fallback using scipy
+        try:
+            from scipy import signal
+            widths = fs / freqs
+            cwt_matrix = signal.cwt(x, signal.morlet2, widths)
+            return freqs, times, np.abs(cwt_matrix)
+        except:
+            # Simple fallback
+            cwt_matrix = np.zeros((n_freqs, len(x)))
+            for i, freq in enumerate(freqs):
+                scale = 1.0 / freq
+                t_wavelet = np.arange(-4 * scale, 4 * scale, 1/fs)
+                wavelet = morlet_wavelet_gpu(t_wavelet, freq)
+
+                # Simple convolution
+                if len(wavelet) < len(x):
+                    cwt_matrix[i, :] = np.abs(np.convolve(x, wavelet, mode='same'))
+
+            return freqs, times, cwt_matrix
+
+
+# ==================== Coherence Analysis ====================
+
+def wavelet_coherence_gpu(x1: np.ndarray, x2: np.ndarray,
+                          fs: float = 1.0,
+                          freq_range: Tuple[float, float] = (0.5, 50),
+                          n_freqs: int = 50) -> Dict:
+    """
+    GPU-accelerated Wavelet Coherence between two signals
+
+    Args:
+        x1, x2: Input signals
+        fs: Sampling frequency
+        freq_range: (min_freq, max_freq)
+        n_freqs: Number of frequency bins
+
+    Returns:
+        Dictionary with coherence, phase difference, frequencies, times
+    """
+    # Compute CWT for both signals
+    freqs1, times1, cwt1_mag = cwt_gpu(x1, fs, freq_range, n_freqs)
+    freqs2, times2, cwt2_mag = cwt_gpu(x2, fs, freq_range, n_freqs)
+
+    # For coherence, we need complex coefficients
+    # Re-compute with phase information
+    # (Simplified version - full implementation would preserve complex values)
+
+    # Cross-spectrum (simplified)
+    cross_spec = cwt1_mag * cwt2_mag
+
+    # Auto-spectra
+    auto_spec1 = cwt1_mag ** 2
+    auto_spec2 = cwt2_mag ** 2
+
+    # Coherence
+    coherence = cross_spec / np.sqrt(auto_spec1 * auto_spec2 + 1e-10)
+
+    return {
+        'coherence': coherence,
+        'frequencies': freqs1,
+        'times': times1,
+        'cwt1': cwt1_mag,
+        'cwt2': cwt2_mag
+    }
+
+
+# ==================== Bispectrum Analysis ====================
+
+def bispectrum_gpu(x: np.ndarray, fs: float = 1.0,
+                   nfft: int = 256,
+                   overlap: float = 0.5) -> Dict:
+    """
+    GPU-accelerated Bispectrum analysis
+
+    The bispectrum detects quadratic phase coupling between frequency components
+
+    Args:
+        x: Input signal
+        fs: Sampling frequency
+        nfft: FFT size
+        overlap: Overlap fraction
+
+    Returns:
+        Dictionary with bispectrum, bicoherence, frequencies
+    """
+    # Segment the signal
+    hop = int(nfft * (1 - overlap))
+    n_segments = (len(x) - nfft) // hop + 1
+
+    n_freq = nfft // 2 + 1
+
+    # Precompute f3 index matrix and in-range mask (shared by GPU and CPU paths)
+    f_idx  = np.arange(n_freq)
+    f3_mat = f_idx[:, None] + f_idx[None, :]          # [F, F]  f3 = f1 + f2
+    valid  = f3_mat < n_freq                            # [F, F]  in-range pairs
+    f3_safe = np.clip(f3_mat, 0, n_freq - 1)           # safe gather index
+
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        x_gpu    = torch.from_numpy(x.astype(np.float32)).cuda()
+        hann_win = torch.hann_window(nfft, device='cuda')
+        valid_t  = torch.from_numpy(valid).cuda()
+        f3_t     = torch.from_numpy(f3_safe).cuda()    # [F, F]
+
+        # Batch all segment FFTs in one call — unfold extracts [S, nfft] without copying
+        # Memory: [S, F, F] complex64.  For S=100, nfft=512 → ~53 MB.
+        frames  = x_gpu.unfold(0, nfft, hop)                        # [S, nfft]
+        X_all   = torch.fft.rfft(frames * hann_win, dim=1)          # [S, F]
+
+        # Triple product over all segments and frequency pairs at once:
+        #   contrib[s, f1, f2] = X[s,f1] * X[s,f2] * conj(X[s, f3(f1,f2)])
+        contrib_all = (X_all[:, :, None] * X_all[:, None, :]        # [S, F, F]
+                       * torch.conj(X_all[:, f3_t]))
+        bispectrum = (contrib_all
+                      .masked_fill(~valid_t.unsqueeze(0), 0.0)
+                      .sum(dim=0) / n_segments)                      # [F, F]
+
+        # Bicoherence: |B(f1,f2)| / (|B(f1,f1)| * |B(f2,f2)|)
+        biamp = torch.abs(bispectrum)
+        diag  = biamp.diagonal()                                     # [F]
+        bicoherence = (biamp / (diag.unsqueeze(1) * diag.unsqueeze(0) + 1e-10)).masked_fill(~valid_t, 0.0)
+
+        freqs = np.fft.rfftfreq(nfft, 1 / fs)
+        return {
+            'bispectrum': bispectrum.cpu().numpy(),
+            'bicoherence': bicoherence.cpu().numpy(),
+            'frequencies': freqs
+        }
+    else:
+        # CPU fallback — same pattern with numpy stride_tricks + vectorised rfft
+        # Memory: [S, F, F] float32.  Scale with nfft and n_segments.
+        shape   = (n_segments, nfft)
+        strides = (x.strides[0] * hop, x.strides[0])
+        frames  = np.lib.stride_tricks.as_strided(x, shape=shape, strides=strides)
+        X_all   = np.fft.rfft(frames * np.hanning(nfft), axis=1)    # [S, F]
+
+        contrib_all = X_all[:, :, None] * X_all[:, None, :] * np.conj(X_all[:, f3_safe])  # [S, F, F]
+        bispectrum  = np.where(valid[None], contrib_all, 0.0).sum(axis=0) / n_segments
+
+        biamp = np.abs(bispectrum)
+        diag  = np.diag(biamp)
+        bicoherence = np.where(
+            valid,
+            biamp / (diag[:, None] * diag[None, :] + 1e-10),
+            0.0
+        )
+
+        freqs = np.fft.rfftfreq(nfft, 1 / fs)
+        return {
+            'bispectrum': bispectrum,
+            'bicoherence': bicoherence,
+            'frequencies': freqs
+        }
+
+
+# ==================== Summary Statistics ====================
+
+def compute_analysis_summary(results: Dict) -> Dict:
+    """
+    Compute summary statistics from various analyses
+
+    Args:
+        results: Dictionary containing results from different analyses
+
+    Returns:
+        Summary statistics for neural network input
+    """
+    summary = {
+        'timestamp': [],
+        'features': []
+    }
+
+    # This will be expanded later with neural network integration
+    # For now, just extract key metrics
+
+    if 'phase' in results:
+        phase_data = results['phase']
+        summary['mean_frequency'] = np.mean(phase_data.get('frequency', []))
+        summary['std_frequency'] = np.std(phase_data.get('frequency', []))
+        summary['mean_amplitude'] = np.mean(phase_data.get('amplitude', []))
+
+    if 'stft' in results:
+        stft_data = results['stft']
+        # Dominant frequency over time
+        # ... more features
+
+    return summary

fastmoda/audio_capture.py

@@ -0,0 +1,134 @@
+"""Real-time microphone capture with FFT; broadcasts frames to SSE subscribers."""
+import threading
+import queue
+import time
+import numpy as np
+from typing import List, Optional
+
+SAMPLE_RATE  = 44100
+FFT_SIZE     = 2048
+HOP_SIZE     = 1024   # blocksize → ~43 candidate frames/s from sounddevice
+TARGET_FPS   = 15     # actual frames sent per second
+MAX_FREQ_HZ  = 8000   # upper display limit
+
+_lock: threading.Lock = threading.Lock()
+_subscribers: List[queue.Queue] = []
+_thread: Optional[threading.Thread] = None
+_running: bool = False
+
+_FREQS: Optional[np.ndarray] = None
+_FREQ_MASK: Optional[np.ndarray] = None
+
+
+def _freq_axis():
+    global _FREQS, _FREQ_MASK
+    if _FREQS is None:
+        all_freqs  = np.fft.rfftfreq(FFT_SIZE, 1.0 / SAMPLE_RATE)
+        _FREQ_MASK = all_freqs <= MAX_FREQ_HZ
+        _FREQS     = all_freqs[_FREQ_MASK]
+    return _FREQS, _FREQ_MASK
+
+
+# ── public API ────────────────────────────────────────────────────────────────
+
+def is_available() -> bool:
+    try:
+        import sounddevice  # noqa: F401
+        return True
+    except (ImportError, OSError):
+        return False
+
+
+def subscribe() -> queue.Queue:
+    """Return a frame queue; starts capture thread on first call."""
+    q: queue.Queue = queue.Queue(maxsize=30)
+    with _lock:
+        _subscribers.append(q)
+        if not _running:
+            _start()
+    return q
+
+
+def unsubscribe(q: queue.Queue) -> None:
+    with _lock:
+        try:
+            _subscribers.remove(q)
+        except ValueError:
+            pass
+
+
+def status() -> dict:
+    return {"available": is_available(), "running": _running,
+            "subscribers": len(_subscribers),
+            "sample_rate": SAMPLE_RATE, "fft_size": FFT_SIZE,
+            "max_freq_hz": MAX_FREQ_HZ}
+
+
+# ── internals ─────────────────────────────────────────────────────────────────
+
+def _start() -> None:
+    global _thread, _running
+    _running = True
+    _thread  = threading.Thread(target=_capture_loop, daemon=True,
+                                 name="audio-capture")
+    _thread.start()
+
+
+def _broadcast(frame: dict) -> None:
+    with _lock:
+        dead = []
+        for q in _subscribers:
+            try:
+                q.put_nowait(frame)
+            except queue.Full:
+                dead.append(q)
+        for q in dead:
+            _subscribers.remove(q)
+
+
+def _build_frame(samples: np.ndarray) -> dict:
+    freqs, mask = _freq_axis()
+    window  = np.hanning(len(samples))
+    spec    = np.fft.rfft(samples * window, n=FFT_SIZE)
+    mags_db = 20.0 * np.log10(np.abs(spec)[mask] + 1e-10)
+    rms_db  = float(20.0 * np.log10(np.sqrt(np.mean(samples ** 2)) + 1e-10))
+    return {
+        "frequencies":   freqs.tolist(),
+        "magnitudes_db": mags_db.tolist(),
+        "rms_db":        round(rms_db, 1),
+        "peak_db":       round(float(np.max(mags_db)), 1),
+        "timestamp":     time.time(),
+    }
+
+
+def _capture_loop() -> None:
+    global _running
+    try:
+        import sounddevice as sd
+    except ImportError:
+        _running = False
+        return
+
+    frame_interval = 1.0 / TARGET_FPS
+    buf     = np.zeros(FFT_SIZE, dtype=np.float32)
+    last_tx = 0.0
+
+    def _cb(indata, frames, _t, _status):
+        nonlocal buf, last_tx
+        chunk             = indata[:, 0]
+        buf               = np.roll(buf, -len(chunk))
+        buf[-len(chunk):] = chunk
+        now = time.time()
+        if now - last_tx >= frame_interval:
+            last_tx = now
+            _broadcast(_build_frame(buf.copy()))
+
+    try:
+        with sd.InputStream(samplerate=SAMPLE_RATE, channels=1, dtype="float32",
+                             blocksize=HOP_SIZE, callback=_cb):
+            while _running:
+                time.sleep(0.05)
+    except Exception as exc:
+        print(f"[audio_capture] error: {exc}")
+    finally:
+        _running = False

fastmoda/baseline.py

@@ -0,0 +1,37 @@
+"""Per-patient baseline deviation computation.
+
+Welford running mean/variance updates live in fastmoda.storage; this module
+turns a feature vector + baseline stats into per-feature z-score deviations,
+which are both the classifier input and the human-readable explanation
+("phase coherence is 2.3 std below your normal").
+"""
+
+import numpy as np
+
+EPS = 1e-8
+
+
+def compute_deviation(feature_vector, feature_names, baseline_stats):
+    """Return a z-score deviation vector for feature_vector against baseline_stats.
+
+    Args:
+        feature_vector: 1D array of raw feature values
+        feature_names: list of feature names, same order as feature_vector
+        baseline_stats: dict shaped like {'features': {name: {'mean', 'std'}}},
+            as returned by fastmoda.storage.get_baseline() or the global
+            feature stats produced during condition-model training. Features
+            missing from baseline_stats deviate as 0 (no information yet).
+
+    Returns:
+        1D numpy array of per-feature z-score deviations, same length/order
+        as feature_vector.
+    """
+    features = (baseline_stats or {}).get('features', {})
+    deviation = np.zeros(len(feature_names), dtype=np.float64)
+    for i, (name, value) in enumerate(zip(feature_names, feature_vector)):
+        stats = features.get(name)
+        if not stats:
+            continue
+        std = max(float(stats.get('std', 0.0)), EPS)
+        deviation[i] = (float(value) - float(stats.get('mean', 0.0))) / std
+    return deviation