codacy

Author: GiovanniCanali

pina/domain/base_domain.py

@@ -1,11 +1,12 @@
-"""Module for the Base Domain class."""
+"""Module for the Base class for domains."""
 
 from copy import deepcopy
+from abc import ABCMeta
 from .domain_interface import DomainInterface
 from ..utils import check_consistency, check_positive_integer
 
 
-class BaseDomain(DomainInterface):
+class BaseDomain(DomainInterface, metaclass=ABCMeta):
     """
     Base class for all geometric domains, implementing common functionality.
 
@@ -51,9 +52,9 @@ def __init__(self, domain_dict):
             check_consistency(v, (int, float))
 
         # Store
-        self._fixed = dict()
-        self._range = dict()
-        invalid = list()
+        self._fixed = {}
+        self._range = {}
+        invalid = []
 
         # Iterate over domain_dict items
         for k, v in domain_dict.items():
@@ -70,8 +71,7 @@ def __init__(self, domain_dict):
                         f"Invalid range for variable '{k}': "
                         f"low ({low}) >= high ({high})"
                     )
-                else:
-                    self._range[k] = (low, high)
+                self._range[k] = (low, high)
 
             # Save invalid keys
             else:
@@ -106,8 +106,8 @@ def update(self, domain):
 
         # Update fixed and ranged variables
         updated = deepcopy(self)
-        updated._fixed.update(domain._fixed)
-        updated._range.update(domain._range)
+        updated.fixed.update(domain.fixed)
+        updated.range.update(domain.range)
 
         return updated
 
@@ -207,3 +207,23 @@ def domain_dict(self):
         :rtype: dict
         """
         return {**self._fixed, **self._range}
+
+    @property
+    def range(self):
+        """
+        The range variables of the domain.
+
+        :return: The range variables of the domain.
+        :rtype: dict
+        """
+        return self._range
+
+    @property
+    def fixed(self):
+        """
+        The fixed variables of the domain.
+
+        :return: The fixed variables of the domain.
+        :rtype: dict
+        """
+        return self._fixed

pina/domain/base_operation.py

@@ -1,12 +1,13 @@
-"""Module for the Base Operation class."""
+"""Module for the Base class for all set-operations."""
 
 from copy import deepcopy
+from abc import ABCMeta
 from .operation_interface import OperationInterface
 from .base_domain import BaseDomain
 from ..utils import check_consistency, check_positive_integer
 
 
-class BaseOperation(OperationInterface):
+class BaseOperation(OperationInterface, metaclass=ABCMeta):
     """
     Base class for all set operation defined on geometric domains, implementing
     common functionality.
@@ -172,6 +173,26 @@ def geometries(self):
         """
         return self._geometries
 
+    @property
+    def range(self):
+        """
+        The range variables of each geometry.
+
+        :return: The range variables of each geometry.
+        :rtype: dict
+        """
+        return {f"geometry_{i}": g.range for i, g in enumerate(self.geometries)}
+
+    @property
+    def fixed(self):
+        """
+        The fixed variables of each geometry.
+
+        :return: The fixed variables of each geometry.
+        :rtype: dict
+        """
+        return {f"geometry_{i}": g.fixed for i, g in enumerate(self.geometries)}
+
     @geometries.setter
     def geometries(self, values):
         """

pina/domain/cartesian_domain.py

@@ -41,9 +41,7 @@ def is_inside(self, point, check_border=False):
 
         # Fixed variable checks
         fixed_check = all(
-            bool((point.extract([k]) == v).all())
-            for k, v in self._fixed.items()
-            if k in point.labels
+            (point.extract([k]) == v).all() for k, v in self._fixed.items()
         )
 
         # If there are no range variables, return fixed variable check
@@ -53,27 +51,17 @@ def is_inside(self, point, check_border=False):
         # Ranged variable checks -- check_border True
         if check_border:
             range_check = all(
-                bool(
-                    (
-                        (point.extract([k]) >= self._range[k][0])
-                        & (point.extract([k]) <= self._range[k][1])
-                    ).all()
-                )
-                for k in self._range
-                if k in point.labels
+                (
+                    (point.extract([k]) >= low) & (point.extract([k]) <= high)
+                ).all()
+                for k, (low, high) in self._range.items()
             )
 
         # Ranged variable checks -- check_border False
         else:
             range_check = all(
-                bool(
-                    (
-                        (point.extract([k]) > self._range[k][0])
-                        & (point.extract([k]) < self._range[k][1])
-                    ).all()
-                )
-                for k in self._range
-                if k in point.labels
+                ((point.extract([k]) > low) & (point.extract([k]) < high)).all()
+                for k, (low, high) in self._range.items()
             )
 
         return fixed_check and range_check
@@ -213,29 +201,17 @@ def partial(self):
         :return: The boundary of the domain.
         :rtype: Union
         """
-        faces = list()
+        faces = []
 
         # Iterate over ranged variables
         for var, (low, high) in self._range.items():
 
             # Fix the variable to its low value to get the lower face
-            low_face = CartesianDomain(
-                {
-                    **self._fixed,
-                    **{k: v for k, v in self._range.items()},
-                    var: low,
-                }
-            )
+            lower = CartesianDomain({**self._fixed, **self._range, var: low})
 
             # Fix the variable to its high value to get the upper face
-            high_face = CartesianDomain(
-                {
-                    **self._fixed,
-                    **{k: v for k, v in self._range.items()},
-                    var: high,
-                }
-            )
+            higher = CartesianDomain({**self._fixed, **self._range, var: high})
 
-            faces.extend([low_face, high_face])
+            faces.extend([lower, higher])
 
         return Union(faces)

pina/domain/domain_interface.py

@@ -93,3 +93,23 @@ def domain_dict(self):
         :return: The dictionary representing the domain.
         :rtype: dict
         """
+
+    @property
+    @abstractmethod
+    def range(self):
+        """
+        The range variables of the domain.
+
+        :return: The range variables of the domain.
+        :rtype: dict
+        """
+
+    @property
+    @abstractmethod
+    def fixed(self):
+        """
+        The fixed variables of the domain.
+
+        :return: The fixed variables of the domain.
+        :rtype: dict
+        """

pina/domain/ellipsoid_domain.py

@@ -1,7 +1,7 @@
 """Module for the Ellipsoid Domain."""
 
-import torch
 from copy import deepcopy
+import torch
 from .base_domain import BaseDomain
 from ..label_tensor import LabelTensor
 from ..utils import check_consistency
@@ -43,16 +43,13 @@ def __init__(self, ellipsoid_dict, sample_surface=False):
         :raises ValueError: If the ellipsoid dictionary contains values that are
             neither numbers nor lists/tuples of numbers of length 2.
         """
-        # Check consistency
-        check_consistency(sample_surface, bool)
-
         # Initialization
         super().__init__(domain_dict=ellipsoid_dict)
-        self._sample_surface = sample_surface
+        self.sample_surface = sample_surface
         self.sample_modes = ["random"]
-        self._compute_center_axes()
+        self.compute_center_axes()
 
-    def _compute_center_axes(self):
+    def compute_center_axes(self):
         """
         Compute centers and axes for the ellipsoid.
         """
@@ -93,9 +90,7 @@ def is_inside(self, point, check_border=False):
 
         # Fixed variable checks
         fixed_check = all(
-            bool((point.extract([k]) == v).all())
-            for k, v in self._fixed.items()
-            if k in point.labels
+            (point.extract([k]) == v).all() for k, v in self._fixed.items()
         )
 
         # If there are no range variables, return fixed variable check
@@ -116,7 +111,7 @@ def is_inside(self, point, check_border=False):
         # Range variable check in the volume
         range_check = (eqn <= 0) if check_border else (eqn < 0)
 
-        return fixed_check and bool(range_check.item())
+        return fixed_check and range_check.item()
 
     def update(self, domain):
         """
@@ -132,7 +127,7 @@ def update(self, domain):
         :rtype: EllipsoidDomain
         """
         updated = super().update(domain)
-        updated._compute_center_axes()
+        updated.compute_center_axes()
 
         return updated
 
@@ -180,7 +175,7 @@ def sample(self, n, mode="random", variables="all"):
             return result
 
         # Sample points
-        pts = self._sample_range(n, mode, range_vars)
+        pts = self._sample_range(n, range_vars)
         labels = range_vars
 
         # Add fixed vars
@@ -198,12 +193,11 @@ def sample(self, n, mode="random", variables="all"):
 
         return pts[sorted(pts.labels)]
 
-    def _sample_range(self, n, mode, variables):
+    def _sample_range(self, n, variables):
         """
         Sample points and rescale to fit within the specified bounds.
 
         :param int n: The number of points to sample.
-        :param str mode: The sampling method. Default is ``random``.
         :param list[str] variables: variables whose samples must be rescaled.
         :return: The rescaled sample points.
         :rtype: torch.Tensor
@@ -242,6 +236,29 @@ def partial(self):
         :rtype: EllipsoidDomain
         """
         boundary = deepcopy(self)
-        boundary._sample_surface = True
+        boundary.sample_surface = True
 
         return boundary
+
+    @property
+    def sample_surface(self):
+        """
+        Whether only the surface of the ellipsoid is considered part of the
+        domain.
+
+        :return: ``True`` if only the surface is considered part of the domain,
+            ``False`` otherwise.
+        :rtype: bool
+        """
+        return self._sample_surface
+
+    @sample_surface.setter
+    def sample_surface(self, value):
+        """
+        Setter for the sample_surface property.
+
+        :param bool value: The new value for the sample_surface property.
+        :raises ValueError: If ``value`` is not a boolean.
+        """
+        check_consistency(value, bool)
+        self._sample_surface = value

pina/domain/exclusion.py

@@ -1,4 +1,4 @@
-"""Module for the Exclusion operation."""
+"""Module for the Exclusion set-operation."""
 
 import random
 from .base_operation import BaseOperation
@@ -87,23 +87,22 @@ def sample(self, n, mode="random", variables="all"):
         # Validate sampling settings
         variables = self._validate_sampling(n, mode, variables)
 
-        # Save the number of geometries
-        n_geometries = len(self.geometries)
-
         # Compute number of points per geometry and remainder
-        num_points, remainder = divmod(n, n_geometries)
+        num_pts, remainder = divmod(n, len(self.geometries))
 
         # Shuffle indices
-        shuffled_geometries = random.sample(range(n_geometries), n_geometries)
+        shuffled_geometries = random.sample(
+            range(len(self.geometries)), len(self.geometries)
+        )
 
         # Precompute per-geometry allocations following the shuffled order
-        alloc = [num_points + (i < remainder) for i in range(n_geometries)]
+        alloc = [num_pts + (i < remainder) for i in range(len(self.geometries))]
         samples = []
 
         # Iterate over geometries in shuffled order
         for idx, gi in enumerate(shuffled_geometries):
 
-            # Skip if no points to allocate (possible if n_geometries > n)
+            # If no points to allocate (possible if len(self.geometries) > n)
             if alloc[idx] == 0:
                 continue
 

pina/domain/intersection.py

@@ -77,23 +77,22 @@ def sample(self, n, mode="random", variables="all"):
         # Validate sampling settings
         variables = self._validate_sampling(n, mode, variables)
 
-        # Save the number of geometries
-        n_geometries = len(self.geometries)
-
         # Compute number of points per geometry and remainder
-        num_points, remainder = divmod(n, n_geometries)
+        num_pts, remainder = divmod(n, len(self.geometries))
 
         # Shuffle indices
-        shuffled_geometries = random.sample(range(n_geometries), n_geometries)
+        shuffled_geometries = random.sample(
+            range(len(self.geometries)), len(self.geometries)
+        )
 
         # Precompute per-geometry allocations following the shuffled order
-        alloc = [num_points + (i < remainder) for i in range(n_geometries)]
+        alloc = [num_pts + (i < remainder) for i in range(len(self.geometries))]
         samples = []
 
         # Iterate over geometries in shuffled order
         for idx, gi in enumerate(shuffled_geometries):
 
-            # Skip if no points to allocate (possible if n_geometries > n)
+            # If no points to allocate (possible if len(self.geometries) > n)
             if alloc[idx] == 0:
                 continue