scitex 2.8.1__py3-none-any.whl → 2.10.0__py3-none-any.whl

scitex/stats/descriptive/_circular.py

@@ -1,63 +1,69 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-09-20 17:17:21 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/stats/desc/_circular.py
-# ----------------------------------------
+# Timestamp: "2025-12-27 (refactored)"
+# File: scitex/stats/descriptive/_circular.py
+"""
+Circular statistics for angular data.
+
+Uses torch when available (preserves tensor type), falls back to numpy.
+"""
+
 from __future__ import annotations
+
 import os
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
 
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
 
-from typing import List, Optional, Tuple, Union
+# Optional torch support
+try:
+    import torch
 
-"""
-Functionalities:
-- Computes circular mean of angles with histogram values
-- Calculates circular concentration (mean resultant length)
-- Computes circular skewness for asymmetry measurement
-- Calculates circular kurtosis for tail behavior analysis
-- Warns if input appears to be in degrees instead of radians
-- Demonstrates circular statistics with synthetic data
-- Saves visualization and statistical results
-
-Dependencies:
-- packages:
-  - torch
-  - numpy
-  - scitex
-  - matplotlib
-
-IO:
-- input-files:
-  - angles in radians as torch.Tensor
-  - histogram values as torch.Tensor
-- output-files:
-  - ./circular_stats_demo.jpg
-  - ./circular_statistics.pkl
-"""
+    HAS_TORCH = True
+except ImportError:
+    torch = None
+    HAS_TORCH = False
 
-"""Imports"""
-import argparse
 
-import numpy as np
-import scitex as stx
-import torch
-from scitex import logging
+def _is_torch_tensor(x):
+    """Check if x is a torch tensor."""
+    return HAS_TORCH and isinstance(x, torch.Tensor)
+
 
-from scitex.decorators import batch_fn, torch_fn
+def _normalize_axis(axis, dim):
+    """Normalize axis/dim parameter."""
+    return dim if dim is not None else axis
 
-logger = logging.getLogger(__name__)
 
-"""Functions & Classes"""
+def _ensure_more_than_2d(data) -> None:
+    """Ensure data has at least 2 dimensions."""
+    ndim = data.ndim if hasattr(data, "ndim") else np.asarray(data).ndim
+    assert ndim >= 2, (
+        f"Input must be at least 2 dimensional with batch dimension as first axis, got {ndim}"
+    )
+
+
+def _check_angle_units(angles) -> None:
+    """Check if angles might be in degrees and warn user."""
+    if _is_torch_tensor(angles):
+        max_val = torch.max(torch.abs(angles)).item()
+    else:
+        max_val = np.max(np.abs(angles))
+
+    if max_val > 2 * np.pi:
+        warnings.warn(
+            f"Maximum angle value is {max_val:.2f} (>2π). "
+            f"Consider using radians or angle wrapping.",
+            UserWarning,
+        )
 
 
-# @batch_fn
-@torch_fn
 def describe_circular(
-    angles: torch.Tensor,
-    values: torch.Tensor,
+    angles,
+    values,
     axis: int = -1,
     dim: Optional[Union[int, Tuple[int, ...]]] = None,
     keepdims: bool = False,
@@ -67,16 +73,16 @@ def describe_circular(
         "circular_skewness",
         "circular_kurtosis",
     ],
-    device: Optional[torch.device] = None,
+    device=None,
     batch_size: int = -1,
-) -> Tuple[torch.Tensor, List[str]]:
-    """Computes various circular descriptive statistics.
+) -> Tuple[np.ndarray, List[str]]:
+    """Compute various circular descriptive statistics.
 
     Parameters
     ----------
-    angles : torch.Tensor
+    angles : array-like
         Input angles in radians with batch dimension as first axis
-    values : torch.Tensor
+    values : array-like
         Histogram values for each angle (must match angles shape)
     axis : int, default=-1
         Deprecated. Use dim instead
@@ -86,18 +92,18 @@ def describe_circular(
         Whether to keep reduced dimensions
     funcs : list of str or "all"
         Circular statistical functions to compute
-    device : torch.device, optional
-        Device to use for computation
+    device : optional
+        Device for torch tensors (ignored for numpy)
     batch_size : int, default=-1
-        Batch size for processing (handled by decorator)
+        Batch size for processing (currently unused)
 
     Returns
     -------
-    Tuple[torch.Tensor, List[str]]
+    Tuple[ndarray or Tensor, List[str]]
         Computed circular statistics and their names
     """
-    dim = axis if dim is None else dim
-    dim = (dim,) if isinstance(dim, int) else tuple(dim)
+    dim = _normalize_axis(axis, dim)
+    dim = (dim,) if isinstance(dim, int) else tuple(dim) if dim is not None else None
 
     func_names = funcs
     func_candidates = {
@@ -115,425 +121,280 @@ def describe_circular(
 
     calculated = [ff(angles, values, dim=dim, keepdims=keepdims) for ff in _funcs]
 
-    return torch.stack(calculated, dim=-1), func_names
-
-
-def _ensure_more_than_2d(data: torch.Tensor) -> None:
-    assert data.ndim >= 2, (
-        f"Input tensor must be more than 2 dimensional with batch dimension as first axis, got {data.ndim}"
-    )
-
-
-def _check_angle_units(angles: torch.Tensor) -> None:
-    """Check if angles might be in degrees and warn user.
-
-    Parameters
-    ----------
-    angles : torch.Tensor
-        Input angles to check
-    """
-    max_val = torch.max(torch.abs(angles)).item()
-    if max_val > 2 * torch.pi:
-        logger.warning(
-            f"Maximum angle value is {max_val:.2f} (>2π). "
-            f"Consider using torch.deg2rad() or angle wrapping."
-        )
+    if _is_torch_tensor(angles):
+        return torch.stack(calculated, dim=-1), func_names
+    else:
+        return np.stack(calculated, axis=-1), func_names
 
 
-# @batch_fn
-@torch_fn
 def circular_mean(
-    angles: torch.Tensor,
-    values: torch.Tensor,
+    angles,
+    values,
     axis: int = -1,
     dim: int = None,
     batch_size: int = None,
     keepdims: bool = False,
-) -> torch.Tensor:
+):
     """Compute circular mean of angles weighted by histogram values.
 
     Parameters
     ----------
-    angles : torch.Tensor
+    angles : array-like
         Input angles in radians with batch dimension as first axis
-    values : torch.Tensor
+    values : array-like
         Histogram values for each angle (must match angles shape)
     axis : int, default=-1
         Axis along which to compute mean (deprecated, use dim)
     dim : int, optional
         Dimension along which to compute mean
     batch_size : int, optional
-        Batch size for processing (handled by decorator)
+        Batch size for processing (currently unused)
     keepdims : bool, default=False
         Whether to keep reduced dimensions
 
     Returns
     -------
-    torch.Tensor
+    ndarray or Tensor
         Circular mean in range [0, 2π]
     """
-
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert angles.shape == values.shape, (
-        f"angles shape {angles.shape} must match values shape {values.shape}"
-    )
 
-    dim = axis if dim is None else dim
-    cos_angles = torch.cos(angles)
-    sin_angles = torch.sin(angles)
+    dim = _normalize_axis(axis, dim)
+
+    if _is_torch_tensor(angles):
+        assert angles.shape == values.shape, (
+            f"angles shape {angles.shape} must match values shape {values.shape}"
+        )
+        cos_angles = torch.cos(angles)
+        sin_angles = torch.sin(angles)
+
+        cos_component = torch.sum(values * cos_angles, dim=dim, keepdim=True)
+        sin_component = torch.sum(values * sin_angles, dim=dim, keepdim=True)
+        value_sum = torch.sum(values, dim=dim, keepdim=True)
+        cos_component = cos_component / value_sum
+        sin_component = sin_component / value_sum
+
+        mean_angle = torch.atan2(sin_component, cos_component)
+        mean_angle = torch.where(mean_angle < 0, mean_angle + 2 * np.pi, mean_angle)
+        return mean_angle if keepdims else mean_angle.squeeze(dim)
+    else:
+        angles = np.asarray(angles)
+        values = np.asarray(values)
+        assert angles.shape == values.shape, (
+            f"angles shape {angles.shape} must match values shape {values.shape}"
+        )
 
-    cos_component = torch.sum(values * cos_angles, dim=dim, keepdim=True)
-    sin_component = torch.sum(values * sin_angles, dim=dim, keepdim=True)
-    value_sum = torch.sum(values, dim=dim, keepdim=True)
-    cos_component = cos_component / value_sum
-    sin_component = sin_component / value_sum
+        cos_angles = np.cos(angles)
+        sin_angles = np.sin(angles)
 
-    mean_angle = torch.atan2(sin_component, cos_component)
-    mean_angle = torch.where(mean_angle < 0, mean_angle + 2 * np.pi, mean_angle)
+        cos_component = np.sum(values * cos_angles, axis=dim, keepdims=True)
+        sin_component = np.sum(values * sin_angles, axis=dim, keepdims=True)
+        value_sum = np.sum(values, axis=dim, keepdims=True)
+        cos_component = cos_component / value_sum
+        sin_component = sin_component / value_sum
 
-    return mean_angle if keepdims else mean_angle.squeeze(dim)
+        mean_angle = np.arctan2(sin_component, cos_component)
+        mean_angle = np.where(mean_angle < 0, mean_angle + 2 * np.pi, mean_angle)
+        return mean_angle if keepdims else np.squeeze(mean_angle, axis=dim)
 
 
-# @batch_fn
-@torch_fn
 def circular_concentration(
-    angles: torch.Tensor,
-    values: torch.Tensor,
+    angles,
+    values,
     axis: int = -1,
     dim: int = None,
     batch_size: int = None,
     keepdims: bool = False,
-) -> torch.Tensor:
+):
     """Compute circular concentration (mean resultant length).
 
     Parameters
     ----------
-    angles : torch.Tensor with batch dimension as first axis
-        Input angles in radians
-    values : torch.Tensor
+    angles : array-like
+        Input angles in radians with batch dimension as first axis
+    values : array-like
         Histogram values for each angle (must match angles shape)
     axis : int, default=-1
         Axis along which to compute concentration (deprecated, use dim)
     dim : int, optional
         Dimension along which to compute concentration
     batch_size : int, optional
-        Batch size for processing (handled by decorator)
+        Batch size for processing (currently unused)
     keepdims : bool, default=False
         Whether to keep reduced dimensions
 
     Returns
     -------
-    torch.Tensor
+    ndarray or Tensor
         Concentration parameter in range [0, 1]
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert angles.shape == values.shape, (
-        f"angles shape {angles.shape} must match values shape {values.shape}"
-    )
 
-    dim = axis if dim is None else dim
-    cos_angles = torch.cos(angles)
-    sin_angles = torch.sin(angles)
+    dim = _normalize_axis(axis, dim)
+
+    if _is_torch_tensor(angles):
+        assert angles.shape == values.shape
+        cos_angles = torch.cos(angles)
+        sin_angles = torch.sin(angles)
+
+        cos_component = torch.sum(values * cos_angles, dim=dim, keepdim=keepdims)
+        sin_component = torch.sum(values * sin_angles, dim=dim, keepdim=keepdims)
+        value_sum = torch.sum(values, dim=dim, keepdim=keepdims)
+        return torch.sqrt(cos_component**2 + sin_component**2) / value_sum
+    else:
+        angles = np.asarray(angles)
+        values = np.asarray(values)
+        assert angles.shape == values.shape
 
-    cos_component = torch.sum(values * cos_angles, dim=dim, keepdim=keepdims)
-    sin_component = torch.sum(values * sin_angles, dim=dim, keepdim=keepdims)
-    value_sum = torch.sum(values, dim=dim, keepdim=keepdims)
-    vector_length = torch.sqrt(cos_component**2 + sin_component**2) / value_sum
+        cos_angles = np.cos(angles)
+        sin_angles = np.sin(angles)
 
-    return vector_length
+        cos_component = np.sum(values * cos_angles, axis=dim, keepdims=keepdims)
+        sin_component = np.sum(values * sin_angles, axis=dim, keepdims=keepdims)
+        value_sum = np.sum(values, axis=dim, keepdims=keepdims)
+        return np.sqrt(cos_component**2 + sin_component**2) / value_sum
 
 
-# @batch_fn
-@torch_fn
 def circular_skewness(
-    angles: torch.Tensor,
-    values: torch.Tensor,
+    angles,
+    values,
     axis: int = -1,
     dim: int = None,
     batch_size: int = None,
     keepdims: bool = False,
-) -> torch.Tensor:
+):
     """Compute circular skewness.
 
     Parameters
     ----------
-    angles : torch.Tensor with batch dimension as first axis
-        Input angles in radians
-    values : torch.Tensor
+    angles : array-like
+        Input angles in radians with batch dimension as first axis
+    values : array-like
         Histogram values for each angle (must match angles shape)
     axis : int, default=-1
         Axis along which to compute skewness (deprecated, use dim)
     dim : int, optional
         Dimension along which to compute skewness
     batch_size : int, optional
-        Batch size for processing (handled by decorator)
+        Batch size for processing (currently unused)
     keepdims : bool, default=False
         Whether to keep reduced dimensions
 
     Returns
     -------
-    torch.Tensor
+    ndarray or Tensor
         Circular skewness
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert angles.shape == values.shape, (
-        f"angles shape {angles.shape} must match values shape {values.shape}"
-    )
 
-    dim = axis if dim is None else dim
-    cos_angles = torch.cos(angles)
-    sin_angles = torch.sin(angles)
-    cos_2angles = torch.cos(2 * angles)
-    sin_2angles = torch.sin(2 * angles)
+    dim = _normalize_axis(axis, dim)
+
+    if _is_torch_tensor(angles):
+        assert angles.shape == values.shape
+        cos_angles = torch.cos(angles)
+        sin_angles = torch.sin(angles)
+        cos_2angles = torch.cos(2 * angles)
+        sin_2angles = torch.sin(2 * angles)
 
-    value_sum = torch.sum(values, dim=dim, keepdim=True)
-    c1 = torch.sum(values * cos_angles, dim=dim, keepdim=True) / value_sum
-    s1 = torch.sum(values * sin_angles, dim=dim, keepdim=True) / value_sum
-    c2 = torch.sum(values * cos_2angles, dim=dim, keepdim=True) / value_sum
-    s2 = torch.sum(values * sin_2angles, dim=dim, keepdim=True) / value_sum
+        value_sum = torch.sum(values, dim=dim, keepdim=True)
+        c1 = torch.sum(values * cos_angles, dim=dim, keepdim=True) / value_sum
+        s1 = torch.sum(values * sin_angles, dim=dim, keepdim=True) / value_sum
+        c2 = torch.sum(values * cos_2angles, dim=dim, keepdim=True) / value_sum
+        s2 = torch.sum(values * sin_2angles, dim=dim, keepdim=True) / value_sum
+
+        skewness = (c2 * s1 - s2 * c1) / (1 - (c1**2 + s1**2)) ** (3 / 2)
+        return skewness if keepdims else skewness.squeeze(dim)
+    else:
+        angles = np.asarray(angles)
+        values = np.asarray(values)
+        assert angles.shape == values.shape
 
-    skewness = (c2 * s1 - s2 * c1) / (1 - (c1**2 + s1**2)) ** (3 / 2)
-    return skewness if keepdims else skewness.squeeze(dim)
+        cos_angles = np.cos(angles)
+        sin_angles = np.sin(angles)
+        cos_2angles = np.cos(2 * angles)
+        sin_2angles = np.sin(2 * angles)
+
+        value_sum = np.sum(values, axis=dim, keepdims=True)
+        c1 = np.sum(values * cos_angles, axis=dim, keepdims=True) / value_sum
+        s1 = np.sum(values * sin_angles, axis=dim, keepdims=True) / value_sum
+        c2 = np.sum(values * cos_2angles, axis=dim, keepdims=True) / value_sum
+        s2 = np.sum(values * sin_2angles, axis=dim, keepdims=True) / value_sum
+
+        skewness = (c2 * s1 - s2 * c1) / (1 - (c1**2 + s1**2)) ** (3 / 2)
+        return skewness if keepdims else np.squeeze(skewness, axis=dim)
 
 
-# @batch_fn
-@torch_fn
 def circular_kurtosis(
-    angles: torch.Tensor,
-    values: torch.Tensor,
+    angles,
+    values,
     axis: int = -1,
     dim: int = None,
     batch_size: int = None,
     keepdims: bool = False,
-) -> torch.Tensor:
+):
     """Compute circular kurtosis.
 
     Parameters
     ----------
-    angles : torch.Tensor
+    angles : array-like
         Input angles in radians with batch dimension as first axis
-    values : torch.Tensor
+    values : array-like
         Histogram values for each angle (must match angles shape)
     axis : int, default=-1
         Axis along which to compute kurtosis (deprecated, use dim)
     dim : int, optional
         Dimension along which to compute kurtosis
     batch_size : int, optional
-        Batch size for processing (handled by decorator)
+        Batch size for processing (currently unused)
     keepdims : bool, default=False
         Whether to keep reduced dimensions
 
     Returns
     -------
-    torch.Tensor
+    ndarray or Tensor
         Circular kurtosis
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert angles.shape == values.shape, (
-        f"angles shape {angles.shape} must match values shape {values.shape}"
-    )
-
-    dim = axis if dim is None else dim
-    cos_angles = torch.cos(angles)
-    sin_angles = torch.sin(angles)
-    cos_2angles = torch.cos(2 * angles)
-    sin_2angles = torch.sin(2 * angles)
-
-    value_sum = torch.sum(values, dim=dim, keepdim=True)
-    c1 = torch.sum(values * cos_angles, dim=dim, keepdim=True) / value_sum
-    s1 = torch.sum(values * sin_angles, dim=dim, keepdim=True) / value_sum
-    c2 = torch.sum(values * cos_2angles, dim=dim, keepdim=True) / value_sum
-    s2 = torch.sum(values * sin_2angles, dim=dim, keepdim=True) / value_sum
-
-    kurtosis = (c2 * c1 + s2 * s1) / (1 - (c1**2 + s1**2)) ** 2
-    return kurtosis if keepdims else kurtosis.squeeze(dim)
-
-
-def main(args) -> int:
-    """Demonstrate circular statistics functions with synthetic data."""
-
-    # Generate synthetic circular histogram data
-    angles = torch.tensor([0.5, 1.2, 2.1, 3.8, 4.9, 5.7])
-    values = torch.tensor([1.0, 2.0, 1.5, 1.0, 3.0, 1.2])
-
-    angles = angles.reshape(1, -1)
-    values = values.reshape(1, -1)
-
-    # All at once
-    described, methods = describe_circular(angles, values)
-    described, methods = described[0], methods
-    for i_dd, dd in enumerate(described):
-        print(f"{methods[i_dd]}: {dd}")
-
-    # Compute circular statistics
-    c_mean = circular_mean(angles, values)
-    c_concentration = circular_concentration(angles, values)
-    c_skewness = circular_skewness(angles, values)
-    c_kurtosis = circular_kurtosis(angles, values)
-
-    # Store results
-    ii = 0
-    results = {
-        "angles": angles[ii],
-        "values": values[ii],
-        "circular_mean": c_mean[ii],
-        "circular_concentration": c_concentration[ii],
-        "circular_skewness": c_skewness[ii],
-        "circular_kurtosis": c_kurtosis[ii],
-    }
-
-    for k, v in results.items():
-        if isinstance(v, (np.ndarray, torch.Tensor)):
-            print(f"\n{k}, Type: {type(v)}, Shape: {v.shape}, Values: {v}")
-        elif isinstance(v, list):
-            print(f"\n{k}, Type: {type(v)}, Length: {len(v)}, Values: {v}")
-        else:
-            print(f"\n{k}, Type: {type(v)}, Values: {v}")
-
-    # Create visualization
-    fig, axes = plt.subplots(
-        2, 2, figsize=(12, 10), subplot_kw=dict(projection="polar")
-    )
-
-    # Plot 1: Histogram visualization
-    axes[0, 0].bar(
-        results["angles"],
-        results["values"],
-        width=0.3,
-        alpha=0.7,
-        color="blue",
-    )
-    axes[0, 0].axvline(
-        c_mean.item(),
-        color="red",
-        linewidth=2,
-        label=f"Mean: {c_mean.item():.2f}",
-    )
-    axes[0, 0].set_title("Circular Histogram")
-    axes[0, 0].legend()
-
-    # Plot 2: Concentration visualization
-    theta = torch.linspace(0, 2 * np.pi, 100)
-    radius = torch.ones_like(theta) * c_concentration.item()
-    axes[0, 1].plot(
-        theta,
-        radius,
-        "g-",
-        linewidth=2,
-        label=f"Concentration: {c_concentration.item():.3f}",
-    )
-    axes[0, 1].bar(
-        results["angles"],
-        results["values"],
-        width=0.3,
-        alpha=0.5,
-        color="blue",
-    )
-    axes[0, 1].set_title("Concentration Circle")
-    axes[0, 1].legend()
-
-    # Plot 3: Mean direction
-    axes[1, 0].bar(
-        results["angles"],
-        results["values"],
-        width=0.3,
-        alpha=0.7,
-        color="blue",
-    )
-    axes[1, 0].arrow(
-        0,
-        0,
-        np.cos(c_mean.item()) * c_concentration.item(),
-        np.sin(c_mean.item()) * c_concentration.item(),
-        head_width=0.1,
-        head_length=0.1,
-        fc="red",
-        ec="red",
-    )
-    axes[1, 0].set_title("Mean Vector")
-
-    # Plot 4: Statistics summary
-    axes[1, 1].axis("off")
-    stats_text = f"""Circular Statistics:
-
-Mean: {c_mean.item():.3f} rad ({np.degrees(c_mean.item()):.1f}°)
-Concentration: {c_concentration.item():.3f}
-Skewness: {c_skewness.item():.3f}
-Kurtosis: {c_kurtosis.item():.3f}"""
-
-    axes[1, 1].text(
-        0.1,
-        0.5,
-        stats_text,
-        transform=axes[1, 1].transAxes,
-        fontsize=12,
-        verticalalignment="center",
-    )
-    axes[1, 1].set_title("Statistics Summary")
-
-    plt.tight_layout()
-    stx.io.save(fig, "./circular_stats_demo.jpg")
 
-    # Save results
-    stx.io.save(results, "./circular_statistics.pkl")
+    dim = _normalize_axis(axis, dim)
 
-    # Log results
-    logger.info(
-        f"Circular mean: {c_mean.item():.3f} rad ({np.degrees(c_mean.item()):.1f}°)"
-    )
-    logger.info(f"Circular concentration: {c_concentration.item():.3f}")
-    logger.info(f"Circular skewness: {c_skewness.item():.3f}")
-    logger.info(f"Circular kurtosis: {c_kurtosis.item():.3f}")
+    if _is_torch_tensor(angles):
+        assert angles.shape == values.shape
+        cos_angles = torch.cos(angles)
+        sin_angles = torch.sin(angles)
+        cos_2angles = torch.cos(2 * angles)
+        sin_2angles = torch.sin(2 * angles)
 
-    return 0
+        value_sum = torch.sum(values, dim=dim, keepdim=True)
+        c1 = torch.sum(values * cos_angles, dim=dim, keepdim=True) / value_sum
+        s1 = torch.sum(values * sin_angles, dim=dim, keepdim=True) / value_sum
+        c2 = torch.sum(values * cos_2angles, dim=dim, keepdim=True) / value_sum
+        s2 = torch.sum(values * sin_2angles, dim=dim, keepdim=True) / value_sum
 
+        kurtosis = (c2 * c1 + s2 * s1) / (1 - (c1**2 + s1**2)) ** 2
+        return kurtosis if keepdims else kurtosis.squeeze(dim)
+    else:
+        angles = np.asarray(angles)
+        values = np.asarray(values)
+        assert angles.shape == values.shape
 
-def parse_args() -> argparse.Namespace:
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Demonstrate circular statistics functions for histogram data"
-    )
-    args = parser.parse_args()
-    return args
-
-
-def run_main() -> None:
-    """Initialize scitex framework, run main function, and cleanup."""
-    global CONFIG, CC, sys, plt, rng
-
-    import sys
-
-    import matplotlib.pyplot as plt
-    import scitex as stx
-
-    args = parse_args()
-
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng_manager = stx.session.start(
-        sys,
-        plt,
-        args=args,
-        file=__FILE__,
-        sdir_suffix=None,
-        verbose=False,
-        agg=True,
-    )
-
-    exit_status = main(args)
+        cos_angles = np.cos(angles)
+        sin_angles = np.sin(angles)
+        cos_2angles = np.cos(2 * angles)
+        sin_2angles = np.sin(2 * angles)
 
-    stx.session.close(
-        CONFIG,
-        verbose=False,
-        notify=False,
-        message="",
-        exit_status=exit_status,
-    )
+        value_sum = np.sum(values, axis=dim, keepdims=True)
+        c1 = np.sum(values * cos_angles, axis=dim, keepdims=True) / value_sum
+        s1 = np.sum(values * sin_angles, axis=dim, keepdims=True) / value_sum
+        c2 = np.sum(values * cos_2angles, axis=dim, keepdims=True) / value_sum
+        s2 = np.sum(values * sin_2angles, axis=dim, keepdims=True) / value_sum
 
+        kurtosis = (c2 * c1 + s2 * s1) / (1 - (c1**2 + s1**2)) ** 2
+        return kurtosis if keepdims else np.squeeze(kurtosis, axis=dim)
 
-if __name__ == "__main__":
-    run_main()
 
 # EOF