feat: add batch support and refactor mixture evaluation logic

- Updated `moment`, `pdf`, `cdf`, and `logpdf` methods to support both scalar and list inputs for efficient batch computation.
- Extracted shared evaluation logic (e.g., `moment`, `pdf`, `cdf`, `logpdf`) into the `AbstractMixtures` base class to eliminate code duplication across subclasses.
- Centralized input validation, RQMC integration, and distribution handling within the base class for better maintainability.
- Fixed type annotations to align with abstract method signatures and resolve `mypy` type-checking issues.

These changes improve code clarity, enable vectorized evaluations, and make future extensions easier to implement.

Author: plidan123

src/mixtures/abstract_mixture.py

@@ -1,6 +1,8 @@
 from abc import ABCMeta, abstractmethod
 from dataclasses import fields
-from typing import Any
+from typing import Any, List, Tuple, Union, Dict
+import numpy as np
+from numpy.typing import NDArray
 
 from scipy.stats import rv_continuous
 from scipy.stats.distributions import rv_frozen
@@ -15,7 +17,6 @@ class AbstractMixtures(metaclass=ABCMeta):
     @abstractmethod
     def __init__(self, mixture_form: str, **kwargs: Any) -> None:
         """
-
         Args:
             mixture_form: Form of Mixture classical or Canonical
             **kwargs: Parameters of Mixture
@@ -28,40 +29,103 @@ def __init__(self, mixture_form: str, **kwargs: Any) -> None:
             raise AssertionError(f"Unknown mixture form: {mixture_form}")
 
     @abstractmethod
-    def compute_moment(self, n: int, params: dict) -> tuple[float, float]: ...
+    def _compute_moment(self, n: int, params: Dict) -> Tuple[float, float]:
+        ...
+
+    def compute_moment(
+        self, x: Union[List[int], int, NDArray[np.float64]], params: Dict
+    ) -> Union[List[Tuple[float, float]], Tuple[float, float], NDArray[Any]]:
+        if isinstance(x, np.ndarray):
+            return np.array([self._compute_moment(xp, params) for xp in x], dtype=object)
+        elif isinstance(x, list):
+            return [self._compute_moment(xp, params) for xp in x]
+        elif isinstance(x, int):
+            return self._compute_moment(x, params)
+        else:
+            raise TypeError(f"Unsupported type for x: {type(x)}")
 
     @abstractmethod
-    def compute_cdf(self, x: float, params: dict) -> tuple[float, float]: ...
+    def _compute_pdf(self, x: float, params: Dict) -> Tuple[float, float]:
+        ...
+
+    def compute_pdf(
+        self, x: Union[List[float], float, NDArray[np.float64]], params: Dict
+    ) -> Union[List[Tuple[float, float]], Tuple[float, float], NDArray[Any]]:
+        if isinstance(x, np.ndarray):
+            return np.array([self._compute_pdf(xp, params) for xp in x], dtype=object)
+        elif isinstance(x, list):
+            return [self._compute_pdf(xp, params) for xp in x]
+        elif isinstance(x, float):
+            return self._compute_pdf(x, params)
+        else:
+            raise TypeError(f"Unsupported type for x: {type(x)}")
 
     @abstractmethod
-    def compute_pdf(self, x: float, params: dict) -> tuple[float, float]: ...
+    def _compute_logpdf(self, x: float, params: Dict) -> Tuple[float, float]:
+        ...
+
+    def compute_logpdf(
+        self, x: Union[List[float], float, NDArray[np.float64]], params: Dict
+    ) -> Union[List[Tuple[float, float]], Tuple[float, float], NDArray[Any]]:
+        if isinstance(x, np.ndarray):
+            return np.array([self._compute_logpdf(xp, params) for xp in x], dtype=object)
+        elif isinstance(x, list):
+            return [self._compute_logpdf(xp, params) for xp in x]
+        elif isinstance(x, float):
+            return self._compute_logpdf(x, params)
+        else:
+            raise TypeError(f"Unsupported type for x: {type(x)}")
 
     @abstractmethod
-    def compute_logpdf(self, x: float, params: dict) -> tuple[float, float]: ...
+    def _compute_cdf(self, x: float, rqmc_params: Dict[str, Any]) -> Tuple[float, float]:
+        ...
+
+    def compute_cdf(
+        self, x: Union[List[float], float, NDArray[np.float64]], params: Dict
+    ) -> Union[List[Tuple[float, float]], Tuple[float, float], NDArray[Any]]:
+        if isinstance(x, np.ndarray):
+            return np.array([self._compute_cdf(xp, params) for xp in x], dtype=object)
+        elif isinstance(x, list):
+            return [self._compute_cdf(xp, params) for xp in x]
+        elif isinstance(x, float):
+            return self._compute_cdf(x, params)
+        else:
+            raise TypeError(f"Unsupported type for x: {type(x)}")
 
-    def _params_validation(self, data_collector: Any, params: dict[str, float | rv_continuous | rv_frozen]) -> Any:
-        """Mixture Parameters Validation
+    def _params_validation(
+            self,
+            data_collector: Any,
+            params: Dict[str, Union[float, rv_continuous, rv_frozen]],
+    ) -> Any:
+        """Mixture Parameters Validation"""
 
-        Args:
-            data_collector: Dataclass that collect parameters of Mixture
-            params: Input parameters
+        dataclass_fields = fields(data_collector)
+        if len(params) != len(dataclass_fields):
+            raise ValueError(f"Expected {len(dataclass_fields)} arguments, got {len(params)}")
 
-        Returns: Instance of dataclass
+        names_and_types = {field.name: field.type for field in dataclass_fields}
 
-        Raises:
-            ValueError: If given parameters is unexpected
-            ValueError: If parameter type is invalid
-            ValueError: If parameters age not given
+        for key, value in params.items():
+            if key not in names_and_types:
+                raise ValueError(f"Unexpected parameter {key}")
 
-        """
+            # Проверка, что значение не список или массив (т.е. скаляр)
+            if not np.isscalar(value):
+                raise ValueError(f"Parameter '{key}' must be a scalar value, got {type(value)}")
 
-        dataclass_fields = fields(data_collector)
-        if len(params) != len(dataclass_fields):
-            raise ValueError(f"Expected {len(dataclass_fields)} arguments, got {len(params)}")
-        names_and_types = dict((field.name, field.type) for field in dataclass_fields)
-        for pair in params.items():
-            if pair[0] not in names_and_types:
-                raise ValueError(f"Unexpected parameter {pair[0]}")
-            if not isinstance(pair[1], names_and_types[pair[0]]):
-                raise ValueError(f"Type missmatch: {pair[0]} should be {names_and_types[pair[0]]}, not {type(pair[1])}")
-        return data_collector(**params)
+            # Проверка типа — либо число (int или float), либо распределение (rv_continuous/rv_frozen)
+            expected_type = names_and_types[key]
+
+            if expected_type in [float, int]:
+                if not isinstance(value, (int, float)):
+                    raise ValueError(f"Parameter '{key}' must be int or float, got {type(value)}")
+
+            elif expected_type in [rv_continuous, rv_frozen]:
+                # Проверяем, что это объект распределения scipy.stats
+                if not (hasattr(value, "pdf") and callable(value.pdf)):
+                    raise ValueError(f"Parameter '{key}' must be a scipy.stats distribution object")
+
+            else:
+                pass
+
+        return data_collector(**params)