diff --git a/b_asic/core_operations.py b/b_asic/core_operations.py
index df0868ee53b0b2d8b0d74706e8f3b31cad813892..c670b15a1fdc76b0f575da9f7aa3d0c5da01f492 100644
--- a/b_asic/core_operations.py
+++ b/b_asic/core_operations.py
@@ -1053,6 +1053,7 @@ class MAD(AbstractOperation):
_execution_time: Optional[int]
is_swappable = True
+ is_distributive = True
def __init__(
self,
diff --git a/b_asic/gui_utils/color_button.py b/b_asic/gui_utils/color_button.py
index 834d07271576b177ec95efdb5a69a1b1fee77e97..ea54c6b5ac560a9afeac2b1516db4039bd518a6a 100644
--- a/b_asic/gui_utils/color_button.py
+++ b/b_asic/gui_utils/color_button.py
@@ -31,7 +31,10 @@ class ColorButton(QPushButton):
self.set_color(self._default)
def set_color(self, color: QColor):
- """Set new color."""
+ """Set new color.
+ color : QColor
+ The new color of the button.
+ """
if color != self._color:
self._color = color
self._color_changed.emit(color)
@@ -42,7 +45,10 @@ class ColorButton(QPushButton):
self.setStyleSheet("")
def set_text_color(self, color: QColor):
- """Set text color."""
+ """Set text color.
+ color : QColor
+ The new color of the text in the button.
+ """
self.setStyleSheet(f"color: {color.name()};")
@property
diff --git a/b_asic/operation.py b/b_asic/operation.py
index 02995d3f7cc6ee7658b9677fbd36d26406aa82f7..8e550874b9c4900cd1d8dd08321cba9eb354eee3 100644
--- a/b_asic/operation.py
+++ b/b_asic/operation.py
@@ -425,6 +425,22 @@ class Operation(GraphComponent, SignalSourceProvider):
"""
raise NotImplementedError
+ @property
+ @abstractmethod
+ def is_commutative(self) -> bool:
+ """
+ Return True if the operation is commutative.
+ """
+ raise NotImplementedError
+
+ @property
+ @abstractmethod
+ def is_distributive(self) -> bool:
+ """
+ Return True if the operation is distributive.
+ """
+ raise NotImplementedError
+
@property
@abstractmethod
def is_swappable(self) -> bool:
@@ -1064,6 +1080,29 @@ class AbstractOperation(Operation, AbstractGraphComponent):
input_.connected_source.operation.is_constant for input_ in self.inputs
)
+ @property
+ def is_commutative(self) -> bool:
+ """
+ Checks if the operation is commutative.
+
+ An operation is commutative if the order of the inputs does not change the result.
+ For example, addition is commutative because `a + b == b + a`, but subtraction is not
+ because `a - b != b - a`.
+
+ Returns:
+ bool: True if the operation is commutative, False otherwise.
+
+ """
+ # doc-string inherited
+ if self.input_count == 2:
+ return self.is_swappable
+ return False
+
+ @property
+ def is_distributive(self) -> bool:
+ # doc-string inherited
+ return False
+
@property
def is_swappable(self) -> bool:
# doc-string inherited
diff --git a/b_asic/signal_flow_graph.py b/b_asic/signal_flow_graph.py
index cbd491d78ccee41bd79f50d444c1721ff983da60..651751f269af6fb347c99c400f80163f2e686239 100644
--- a/b_asic/signal_flow_graph.py
+++ b/b_asic/signal_flow_graph.py
@@ -2111,6 +2111,118 @@ class SFG(AbstractOperation):
def is_constant(self) -> bool:
return all(output.is_constant for output in self._output_operations)
+ @property
+ def is_commutative(self) -> bool:
+ """
+ Checks if all operations in the sfg are commutative.
+
+ An operation is considered commutative if it is not an 'in' or 'out' operation,
+ and its `is_commutative` property is `True`.
+
+ Returns:
+ bool: `True` if all operations are commutative, `False` otherwise.
+ """
+ return all(
+ (op.is_commutative if op.type_name() not in ['in', 'out'] else True)
+ for op in self.split()
+ )
+
+ @property
+ def is_distributive(self) -> bool:
+ """
+ Checks if the sfg is distributive.
+
+ An operation is considered distributive if it can be applied to each element of a set separately.
+ For example, multiplication is distributive over addition, meaning that `a * (b + c)` is equivalent to `a * b + a * c`.
+
+ Returns:
+ bool: True if the sfg is distributive, False otherwise.
+
+ Example:
+ >>> Mad_op = MAD(Input(), Input(), Input()) # Creates an instance of the Mad operation, MAD is defined in b_asic.core_operations
+ >>> Mad_sfg = Mad_op.to_sfg() # The operation is turned into a sfg
+ >>> Mad_sfg.is_distributive # True # if the distributive property holds, False otherwise
+
+ """
+ structures = []
+ operations = self.get_operations_topological_order()
+ for op in operations:
+ if not (
+ op.type_name() == "in"
+ or op.type_name() == "out"
+ or op.type_name() == "c"
+ or op.type_name() == "t"
+ ):
+ structures.append(op)
+ return (
+ all(self.has_distributive_structure(op) for op in structures)
+ if len(structures) > 1
+ else False
+ )
+
+ def has_distributive_structure(self, op: Operation) -> bool:
+ """
+ Checks if the sfg contains distributive structures.
+ Parameters
+ ==========
+ op : Operation
+ The operation that is the start of the structure to check for distributivity.
+ Returns:
+ bool: True if a distributive structures is found, False otherwise.
+ """
+ if op.type_name() == 'mac':
+ return True
+ elif op.type_name() in ['cmul', 'mul', 'div']:
+ for subsequent_op in op.subsequent_operations:
+ if subsequent_op.type_name() in [
+ 'add',
+ 'sub',
+ 'addsub',
+ 'min',
+ 'max',
+ 'sqrt',
+ 'rec',
+ 'out',
+ 't',
+ ]:
+ return True
+ else:
+ return False
+ elif op.type_name() in ['add', 'sub', 'addsub']:
+ for subsequent_op in op.subsequent_operations:
+ if subsequent_op.type_name() in [
+ 'mul',
+ 'div',
+ 'min',
+ 'max',
+ 'out',
+ 'cmul',
+ 't',
+ ]:
+ return True
+ else:
+ return False
+ elif op.type_name() in ['min', 'max']:
+ for subsequent_op in op.subsequent_operations:
+ if subsequent_op.type_name() in [
+ 'add',
+ 'sub',
+ 'addsub',
+ 'cmul',
+ 'out',
+ 't',
+ ]:
+ return True
+ else:
+ return False
+
+ # elif op.type_name() == 'cmul':
+ # for subsequent_op in op.subsequent_operations:
+ # if subsequent_op.type_name() in ['max', 'min', 'out', 't']:
+ # return True
+ # else: return False
+ return False
+
def get_used_type_names(self) -> List[TypeName]:
"""Get a list of all TypeNames used in the SFG."""
ret = list({op.type_name() for op in self.operations})