code/TSDecompose/src/tsdecomp/methods/std.py

from __future__ import annotations

from time import perf_counter
from typing import Any, Dict, Optional

import numpy as np

from .._native import invoke_native
from ..backends import finalize_result, resolve_backend, result_from_native_payload, split_runtime_params
from ..core import DecompResult
from ..registry import MethodRegistry


def _infer_period(y: np.ndarray, max_period_search: int = 128) -> int:
    y_arr = np.asarray(y, dtype=float).ravel()
    n = y_arr.size
    if n < 4:
        return max(1, n)

    centered = y_arr - float(np.mean(y_arr))
    spectrum = np.abs(np.fft.rfft(centered))
    freqs = np.fft.rfftfreq(n)
    if spectrum.size <= 1:
        return max(2, min(max_period_search, max(2, n // 4)))

    spectrum[0] = 0.0
    peak_idx = int(np.argmax(spectrum))
    if peak_idx <= 0 or freqs[peak_idx] <= 1e-12:
        return max(2, min(max_period_search, max(2, n // 4)))

    period = int(round(1.0 / freqs[peak_idx]))
    return max(2, min(period, max_period_search, n))


def compute_std_components(
    y: np.ndarray,
    period: Optional[int] = None,
    *,
    variant: str = "STD",
    max_period_search: int = 128,
    eps: float = 1e-12,
) -> Dict[str, Any]:
    y_arr = np.asarray(y, dtype=float).ravel()
    n = y_arr.size
    if n == 0:
        zeros = np.zeros(0, dtype=float)
        return {
            "trend": zeros,
            "season": zeros,
            "residual": zeros,
            "dispersion": zeros,
            "seasonal_shape": zeros,
            "period": 0,
            "variant": variant.upper(),
            "n_cycles": 0,
            "incomplete_cycle": False,
        }

    variant_norm = str(variant).upper()
    resolved_period = int(period) if period not in (None, 0) else _infer_period(y_arr, max_period_search=max_period_search)
    resolved_period = max(1, min(resolved_period, n))

    trend = np.zeros(n, dtype=float)
    dispersion = np.zeros(n, dtype=float)
    seasonal_shape = np.zeros(n, dtype=float)
    season = np.zeros(n, dtype=float)

    block_shapes = []
    block_slices = []
    for start in range(0, n, resolved_period):
        stop = min(start + resolved_period, n)
        sl = slice(start, stop)
        block = y_arr[sl]
        block_mean = float(np.mean(block))
        centered = block - block_mean
        block_diversity = float(np.linalg.norm(centered))
        if block_diversity <= eps:
            shape = np.zeros_like(block)
            block_diversity = 0.0
        else:
            shape = centered / block_diversity

        trend[sl] = block_mean
        dispersion[sl] = block_diversity
        seasonal_shape[sl] = shape
        season[sl] = block_diversity * shape

        block_shapes.append(shape)
        block_slices.append(sl)

    average_seasonal_shape = None
    if variant_norm == "STDR":
        average_seasonal_shape = np.zeros(resolved_period, dtype=float)
        counts = np.zeros(resolved_period, dtype=float)
        for shape in block_shapes:
            average_seasonal_shape[: shape.size] += shape
            counts[: shape.size] += 1.0
        valid = counts > 0
        average_seasonal_shape[valid] /= counts[valid]

        season = np.zeros_like(y_arr)
        seasonal_shape = np.zeros_like(y_arr)
        for sl in block_slices:
            avg_shape = average_seasonal_shape[: sl.stop - sl.start]
            seasonal_shape[sl] = avg_shape
            season[sl] = dispersion[sl] * avg_shape

    residual = y_arr - trend - season
    return {
        "trend": trend,
        "season": season,
        "residual": residual,
        "dispersion": dispersion,
        "seasonal_shape": seasonal_shape,
        "average_seasonal_shape": average_seasonal_shape,
        "period": resolved_period,
        "variant": variant_norm,
        "n_cycles": len(block_slices),
        "incomplete_cycle": bool(n % resolved_period),
    }


def _wrap_std_result(result: Dict[str, Any]) -> DecompResult:
    components = {
        "dispersion": np.asarray(result["dispersion"], dtype=float),
        "seasonal_shape": np.asarray(result["seasonal_shape"], dtype=float),
    }
    if result.get("average_seasonal_shape") is not None:
        components["average_seasonal_shape"] = np.asarray(result["average_seasonal_shape"], dtype=float)

    return DecompResult(
        trend=np.asarray(result["trend"], dtype=float),
        season=np.asarray(result["season"], dtype=float),
        residual=np.asarray(result["residual"], dtype=float),
        components=components,
        meta={
            "method": result["variant"],
            "period": int(result["period"]),
            "n_cycles": int(result["n_cycles"]),
            "incomplete_cycle": bool(result["incomplete_cycle"]),
        },
    )


def _single_channel_std(
    y: np.ndarray,
    *,
    cfg: Dict[str, Any],
    variant: str,
    backend: str,
) -> DecompResult:
    period = cfg.get("period", cfg.get("primary_period"))
    max_period_search = int(cfg.get("max_period_search", 128))
    eps = float(cfg.get("eps", 1e-12))

    if backend == "native":
        payload = invoke_native(
            "std_decompose",
            np.asarray(y, dtype=float),
            period=period,
            variant=variant,
            max_period_search=max_period_search,
            eps=eps,
        )
        return result_from_native_payload(payload, method=variant)

    result = compute_std_components(
        y,
        period=period,
        variant=variant,
        max_period_search=max_period_search,
        eps=eps,
    )
    return _wrap_std_result(result)


def _stack_channelwise_results(results: list[DecompResult], variant: str) -> DecompResult:
    trend = np.column_stack([np.asarray(result.trend, dtype=float) for result in results])
    season = np.column_stack([np.asarray(result.season, dtype=float) for result in results])
    residual = np.column_stack([np.asarray(result.residual, dtype=float) for result in results])

    components: Dict[str, np.ndarray] = {}
    for key in ("dispersion", "seasonal_shape"):
        components[key] = np.column_stack(
            [np.asarray(result.components[key], dtype=float) for result in results]
        )

    avg_shapes = [
        np.asarray(result.components["average_seasonal_shape"], dtype=float)
        for result in results
        if "average_seasonal_shape" in result.components
    ]
    if avg_shapes:
        max_len = max(shape.size for shape in avg_shapes)
        avg_matrix = np.full((max_len, len(results)), np.nan, dtype=float)
        for idx, result in enumerate(results):
            if "average_seasonal_shape" not in result.components:
                continue
            shape = np.asarray(result.components["average_seasonal_shape"], dtype=float)
            avg_matrix[: shape.size, idx] = shape
        components["average_seasonal_shape"] = avg_matrix

    periods = [int(result.meta.get("period", 0)) for result in results]
    meta: Dict[str, Any] = {
        "method": variant,
        "periods": periods,
        "n_channels": len(results),
        "decomposition_mode": "channelwise",
    }
    if periods and all(period == periods[0] for period in periods):
        meta["period"] = periods[0]

    return DecompResult(
        trend=trend,
        season=season,
        residual=residual,
        components=components,
        meta=meta,
    )


def _std_dispatch(y: np.ndarray, params: Dict[str, Any], *, variant: str) -> DecompResult:
    started_at = perf_counter()
    cfg, runtime = split_runtime_params(params)
    backend = resolve_backend(variant, runtime, native_methods=("std_decompose",))

    y_arr = np.asarray(y, dtype=float)
    if y_arr.ndim == 1:
        result = _single_channel_std(y_arr, cfg=cfg, variant=variant, backend=backend)
    elif y_arr.ndim == 2:
        results = [
            _single_channel_std(y_arr[:, idx], cfg=cfg, variant=variant, backend=backend)
            for idx in range(y_arr.shape[1])
        ]
        result = _stack_channelwise_results(results, variant)
    else:
        raise ValueError(f"{variant} expects a 1D series or a 2D (T, C) array.")

    return finalize_result(
        result,
        method=variant,
        runtime=runtime,
        backend_used=backend,
        started_at=started_at,
    )


@MethodRegistry.register("STD", input_mode="channelwise")
def std_decompose(
    y: np.ndarray,
    params: Dict[str, Any],
) -> DecompResult:
    return _std_dispatch(y, params, variant="STD")


@MethodRegistry.register("STDR", input_mode="channelwise")
def stdr_decompose(
    y: np.ndarray,
    params: Dict[str, Any],
) -> DecompResult:
    return _std_dispatch(y, params, variant="STDR")