refactor: analytical computations build optimization

Author: LeonidElkin

src/pysatl_core/families/distribution.py

@@ -87,7 +87,7 @@ def analytical_computations(
         cache_val = getattr(self, "_analytical_cache_val", None)
 
         if cache_key != key or cache_val is None:
-            cache_val = self.family._build_analytical_computations(self.parameters)
+            cache_val = self.family.build_analytical_computations(self.parameters)
             self._analytical_cache_key = key
             self._analytical_cache_val = cache_val
 

src/pysatl_core/families/parametric_family.py

@@ -291,6 +291,46 @@ def _build_analytical_computations(
 
         return result
 
+    def build_analytical_computations(
+        self, parameters: Parametrization
+    ) -> dict[GenericCharacteristicName, AnalyticalComputation[Any, Any]]:
+        """
+        Build analytical computations mapping for the given parameter instance.
+
+        This uses a precomputed provider plan so runtime work is reduced to:
+        - (Optionally) converting parameters to base once,
+        - binding callables with :func:`functools.partial`.
+
+        Parameters
+        ----------
+        parameters : Parametrization
+            Parameters in any registered parametrization.
+
+        Returns
+        -------
+        dict[GenericCharacteristicName, AnalyticalComputation]
+            Mapping from characteristic name to analytical computation callable.
+        """
+        plan = self._analytical_plan.get(parameters.name, {})
+        result: dict[GenericCharacteristicName, AnalyticalComputation[Any, Any]] = {}
+        base_params: Parametrization | None = None
+
+        for characteristic, provider_name in plan.items():
+            if provider_name == parameters.name:
+                params_obj = parameters
+            else:
+                if base_params is None:
+                    base_params = self.get_base_parameters(parameters)
+                params_obj = base_params
+
+            func_factory = self.distr_characteristics[characteristic][provider_name]
+            result[characteristic] = AnalyticalComputation(
+                target=characteristic,
+                func=partial(func_factory, params_obj),
+            )
+
+        return result
+
     def distribution(
         self,
         parametrization_name: str | None = None,