Merge pull request #1418 from FlorianPfaff/megalinter-fixes

[MegaLinter] Apply linters automatic fixes

Author: FlorianPfaff

pyrecest/distributions/abstract_grid_distribution.py

@@ -1,12 +1,12 @@
 import copy
 import warnings
 from abc import abstractmethod
+from math import prod
 
 from beartype import beartype
 
 # pylint: disable=redefined-builtin,no-name-in-module,no-member
 from pyrecest.backend import abs, any, mean
-from math import prod
 
 from .abstract_distribution_type import AbstractDistributionType
 
@@ -27,7 +27,9 @@ def __init__(
         )  # if grid_type is custom, grid needs to be given
         assert (
             # Use builtin prod because .shape is a tuple of ints
-            grid is None or grid.shape == () or grid.shape[0] == prod(grid_values.shape)
+            grid is None
+            or grid.shape == ()
+            or grid.shape[0] == prod(grid_values.shape)
         )
         assert (
             grid is None or grid.shape == () or grid.ndim == 1 or grid.shape[1] == dim

pyrecest/distributions/hypersphere_subset/abstract_hypersphere_subset_grid_distribution.py

@@ -1,83 +1,137 @@
 import warnings
 
-from ..abstract_grid_distribution import AbstractGridDistribution 
-from .abstract_hypersphere_subset_distribution import AbstractHypersphereSubsetDistribution
-from .abstract_hyperhemispherical_distribution import AbstractHyperhemisphericalDistribution
+from beartype import beartype
+
+# pylint: disable=redefined-builtin,no-name-in-module,no-member
+from pyrecest.backend import argmax, array_equal, sum
+
+from ..abstract_grid_distribution import AbstractGridDistribution
+from .abstract_hyperhemispherical_distribution import (
+    AbstractHyperhemisphericalDistribution,
+)
+from .abstract_hypersphere_subset_distribution import (
+    AbstractHypersphereSubsetDistribution,
+)
 from .abstract_hyperspherical_distribution import AbstractHypersphericalDistribution
-from .von_mises_fisher_distribution import VonMisesFisherDistribution
 from .bingham_distribution import BinghamDistribution
 from .hyperspherical_mixture import HypersphericalMixture
+from .von_mises_fisher_distribution import VonMisesFisherDistribution
 from .watson_distribution import WatsonDistribution
-from beartype import beartype
 
-# pylint: disable=redefined-builtin,no-name-in-module,no-member
-from pyrecest.backend import array_equal, argmax, sum
 
-class AbstractHypersphereSubsetGridDistribution(AbstractGridDistribution, AbstractHypersphereSubsetDistribution):
-    
+class AbstractHypersphereSubsetGridDistribution(
+    AbstractGridDistribution, AbstractHypersphereSubsetDistribution
+):
+
     def __init__(self, grid, grid_values, enforce_pdf_nonnegative=True):
         # Check size consistency
         if grid.shape[0] != grid_values.shape[0]:
             raise ValueError("Grid size must match number of grid values.")
-            
-        AbstractGridDistribution.__init__(self, grid_values, grid_type = "unknown", grid=grid, dim=grid.shape[1],  enforce_pdf_nonnegative=enforce_pdf_nonnegative)     
+
+        AbstractGridDistribution.__init__(
+            self,
+            grid_values,
+            grid_type="unknown",
+            grid=grid,
+            dim=grid.shape[1],
+            enforce_pdf_nonnegative=enforce_pdf_nonnegative,
+        )
         AbstractHypersphereSubsetDistribution.__init__(self, dim=grid.shape[1])
-        self.normalize() 
+        self.normalize()
 
     def mean_direction(self):
-        warnings.warn("For hyperhemispheres, this function yields the mode and not the mean.", UserWarning)
+        warnings.warn(
+            "For hyperhemispheres, this function yields the mode and not the mean.",
+            UserWarning,
+        )
         # If we took the mean, it would be biased toward [0;...;0;1]
         # because the lower half is considered inexistant.
         index_max = argmax(self.grid_values)
         mu = self.get_grid_point(index_max)
         return mu
 
     def moment(self):
-        weights = self.grid_values / sum(self.grid_values) # (N,)
-        
-        weighted_grid = self.get_grid() * weights 
+        weights = self.grid_values / sum(self.grid_values)  # (N,)
+
+        weighted_grid = self.get_grid() * weights
 
         C = weighted_grid * (self.get_grid().T @ self.get_grid())
         return C
 
     @beartype
-    def multiply(self: "AbstractHypersphereSubsetGridDistribution", other: "AbstractHypersphereSubsetGridDistribution") -> "AbstractHypersphereSubsetGridDistribution":
+    def multiply(
+        self: "AbstractHypersphereSubsetGridDistribution",
+        other: "AbstractHypersphereSubsetGridDistribution",
+    ) -> "AbstractHypersphereSubsetGridDistribution":
         # Check for grid compatibility
         if not array_equal(self.get_grid(), other.get_grid()):
-            raise ValueError("Can only multiply for equal grids. Grids are incompatible.")
-        
+            raise ValueError(
+                "Can only multiply for equal grids. Grids are incompatible."
+            )
+
         # Delegates multiplication logic to AbstractGridDistribution
         return super().multiply(other)
 
     @classmethod
-    def from_distribution(cls, distribution, no_of_grid_points, grid_type, enforce_pdf_nonnegative=True):
+    def from_distribution(
+        cls, distribution, no_of_grid_points, grid_type, enforce_pdf_nonnegative=True
+    ):
+        from .hyperhemispherical_grid_distribution import (
+            HyperhemisphericalGridDistribution,
+        )
         from .hyperspherical_grid_distribution import HypersphericalGridDistribution
-        from .hyperhemispherical_grid_distribution import HyperhemisphericalGridDistribution
+
         # pylint: disable=too-many-boolean-expressions
         if isinstance(distribution, AbstractHypersphereSubsetGridDistribution):
-            raise ValueError('Already a grid distribution. Use directly instead of converting.')
-        
-        if isinstance(distribution, AbstractHypersphericalDistribution) and issubclass(cls, HypersphericalGridDistribution)\
-            or isinstance(distribution, AbstractHyperhemisphericalDistribution) and issubclass(cls, HyperhemisphericalGridDistribution):
+            raise ValueError(
+                "Already a grid distribution. Use directly instead of converting."
+            )
+
+        if (
+            isinstance(distribution, AbstractHypersphericalDistribution)
+            and issubclass(cls, HypersphericalGridDistribution)
+            or isinstance(distribution, AbstractHyperhemisphericalDistribution)
+            and issubclass(cls, HyperhemisphericalGridDistribution)
+        ):
             # sphere -> sphere or hemisphere -> hemisphere
             fun = distribution.pdf
-        elif issubclass(cls, HyperhemisphericalGridDistribution) and (isinstance(distribution, (WatsonDistribution, BinghamDistribution)) or 
-              (isinstance(distribution, VonMisesFisherDistribution) and distribution.mu[-1] == 0) or 
-              (isinstance(distribution, HypersphericalMixture) and
-                len(distribution.dists) == 2 and all(w == 0.5 for w in distribution.w) and
-                array_equal(distribution.dists[1].mu, -distribution.dists[0].mu))):
+        elif issubclass(cls, HyperhemisphericalGridDistribution) and (
+            isinstance(distribution, (WatsonDistribution, BinghamDistribution))
+            or (
+                isinstance(distribution, VonMisesFisherDistribution)
+                and distribution.mu[-1] == 0
+            )
+            or (
+                isinstance(distribution, HypersphericalMixture)
+                and len(distribution.dists) == 2
+                and all(w == 0.5 for w in distribution.w)
+                and array_equal(distribution.dists[1].mu, -distribution.dists[0].mu)
+            )
+        ):
             # sphere -> hemisphere for symmetric distributions
             def fun(x):
                 return 2 * distribution.pdf(x)
-        elif isinstance(distribution, AbstractHypersphericalDistribution) and issubclass(cls, HyperhemisphericalGridDistribution):
+
+        elif isinstance(
+            distribution, AbstractHypersphericalDistribution
+        ) and issubclass(cls, HyperhemisphericalGridDistribution):
             # sphere -> hemisphere for general distributions, which we do not know to be symmetric
-            warnings.warn('Approximating a hyperspherical distribution on a hemisphere. The density may not be symmetric. Double check if this is intentional.',
-                          UserWarning)
+            warnings.warn(
+                "Approximating a hyperspherical distribution on a hemisphere. The density may not be symmetric. Double check if this is intentional.",
+                UserWarning,
+            )
+
             def fun(x):
                 return 2 * distribution.pdf(x)
+
         else:
-            raise ValueError('Distribution currently not supported.')
-            
-        sgd = cls.from_function(fun, no_of_grid_points, distribution.dim, grid_type, enforce_pdf_nonnegative=enforce_pdf_nonnegative)
-        return sgd
+            raise ValueError("Distribution currently not supported.")
 
+        sgd = cls.from_function(
+            fun,
+            no_of_grid_points,
+            distribution.dim,
+            grid_type,
+            enforce_pdf_nonnegative=enforce_pdf_nonnegative,
+        )
+        return sgd

pyrecest/distributions/hypersphere_subset/hyperhemispherical_grid_distribution.py

@@ -1,28 +1,40 @@
-from .abstract_hypersphere_subset_grid_distribution import (
-    AbstractHypersphereSubsetGridDistribution,
+import warnings
+
+from beartype import beartype
+
+# pylint: disable=redefined-builtin,no-name-in-module,no-member
+from pyrecest.backend import (
+    abs,
+    all,
+    allclose,
+    argmax,
+    argmin,
+    concatenate,
+    linalg,
+    minimum,
+    vstack,
 )
+
+from ...sampling.hyperspherical_sampler import get_grid_hyperhemisphere
 from .abstract_hyperhemispherical_distribution import (
     AbstractHyperhemisphericalDistribution,
 )
+from .abstract_hypersphere_subset_grid_distribution import (
+    AbstractHypersphereSubsetGridDistribution,
+)
 from .custom_hyperhemispherical_distribution import CustomHyperhemisphericalDistribution
 from .hyperspherical_dirac_distribution import HypersphericalDiracDistribution
-from ...sampling.hyperspherical_sampler import get_grid_hyperhemisphere
 
-import warnings
-
-# pylint: disable=redefined-builtin,no-name-in-module,no-member
-from pyrecest.backend import all, abs, argmax, concatenate, vstack, linalg, allclose, minimum, argmin
-from beartype import beartype
 
 class HyperhemisphericalGridDistribution(
     AbstractHypersphereSubsetGridDistribution, AbstractHyperhemisphericalDistribution
 ):
 
     def __init__(self, grid, grid_values, enforce_pdf_nonnegative=True):
         # Do not test norm precisely, only quick test if any coordinate exceeds 1.
-        assert all(abs(grid) <= 1 + 1e-12), (
-            "Grid points must not lie outside the unit cube."
-        )
+        assert all(
+            abs(grid) <= 1 + 1e-12
+        ), "Grid points must not lie outside the unit cube."
         assert all(
             grid[:, -1] >= -1e-12
         ), "Always using upper hemisphere (along last dimension)."
@@ -62,6 +74,7 @@ def to_full_sphere(self, method="antipodal"):
             "full-sphere grid distributions."
         )
         from .hyperspherical_grid_distribution import HypersphericalGridDistribution
+
         grid_full = vstack((self.grid, -self.grid))
         grid_values_ = 0.5 * concatenate((self.grid_values, self.grid_values))
         hgd = HypersphericalGridDistribution(grid_full, grid_values_)
@@ -74,13 +87,14 @@ def plot(self):
 
     def plot_interpolated(self):
         hdgd = self.to_full_sphere()
+
         def pdf_doubled(x):
             return 2 * hdgd.pdf(x)
-        hhgd_interp = CustomHyperhemisphericalDistribution(
-            pdf_doubled, 3
-        )
+
+        hhgd_interp = CustomHyperhemisphericalDistribution(pdf_doubled, 3)
         h = hhgd_interp.plot()
         return h
+
     # ------------------------------------------------------------------
     # Grid geometry utilities
     # ------------------------------------------------------------------
@@ -105,19 +119,15 @@ def get_closest_point(self, xs):
 
         if xs.ndim == 1:
             if xs.shape[0] != self.dim:
-                raise ValueError(
-                    f"xs must have length {self.dim}, got {xs.shape[0]}."
-                )
+                raise ValueError(f"xs must have length {self.dim}, got {xs.shape[0]}.")
             xs = xs[None, :]  # (1, dim)
         elif xs.ndim == 2:
             if xs.shape[1] == self.dim:
                 pass  # already (batch, dim)
             elif xs.shape[0] == self.dim:
                 xs = xs.T  # (batch, dim)
             else:
-                raise ValueError(
-                    f"xs must have shape (n, dim) with dim={self.dim}."
-                )
+                raise ValueError(f"xs must have shape (n, dim) with dim={self.dim}.")
         else:
             raise ValueError("xs must be a 1D or 2D array.")
 
@@ -139,15 +149,18 @@ def get_closest_point(self, xs):
             indices = indices[0]
 
         return points, indices
-    
+
     def get_manifold_size(self):
         return AbstractHyperhemisphericalDistribution.get_manifold_size(self)
 
     # ------------------------------------------------------------------
     # Multiplication on the hemisphere
     # ------------------------------------------------------------------
     @beartype
-    def multiply(self: "HyperhemisphericalGridDistribution", other: "HyperhemisphericalGridDistribution") -> "HyperhemisphericalGridDistribution":
+    def multiply(
+        self: "HyperhemisphericalGridDistribution",
+        other: "HyperhemisphericalGridDistribution",
+    ) -> "HyperhemisphericalGridDistribution":
         """
         Multiply two hyperhemispherical grid distributions that share the same grid.
 
@@ -194,7 +207,13 @@ def multiply(self: "HyperhemisphericalGridDistribution", other: "Hyperhemispheri
     # ------------------------------------------------------------------
     # pylint: disable=too-many-locals
     @staticmethod
-    def from_function(fun, no_of_grid_points, dim=2, grid_type="leopardi_symm", enforce_pdf_nonnegative=True):
+    def from_function(
+        fun,
+        no_of_grid_points,
+        dim=2,
+        grid_type="leopardi_symm",
+        enforce_pdf_nonnegative=True,
+    ):
         """
         Construct a hyperhemispherical grid distribution from a callable.
 
@@ -216,13 +235,16 @@ def from_function(fun, no_of_grid_points, dim=2, grid_type="leopardi_symm", enfo
         depends on (dim, no_of_grid_points, grid_type). For 'healpix',
         only dim == 3 is supported and `healpy` must be installed.
         """
-        assert grid_type in ("leopardi_symm", "healpix"), (
-            "For hyperhemispheres, use one of the symmetric grid types 'leopardi_symm' or 'healpix'."
-        )
+        assert grid_type in (
+            "leopardi_symm",
+            "healpix",
+        ), "For hyperhemispheres, use one of the symmetric grid types 'leopardi_symm' or 'healpix'."
         grid, _ = get_grid_hyperhemisphere(grid_type, no_of_grid_points, dim=dim)
 
         grid_values = fun(grid)
 
-        sgd = HyperhemisphericalGridDistribution(grid, grid_values, enforce_pdf_nonnegative=enforce_pdf_nonnegative)
+        sgd = HyperhemisphericalGridDistribution(
+            grid, grid_values, enforce_pdf_nonnegative=enforce_pdf_nonnegative
+        )
         sgd.grid_type = grid_type
         return sgd