diff --git a/b_asic/basic_operation.py b/b_asic/basic_operation.py
index e237bf130fec0bd115f115aa8aed1418dc9b3393..4f7b426b995eb390001d39a0785f3dd0841f2563 100644
--- a/b_asic/basic_operation.py
+++ b/b_asic/basic_operation.py
@@ -36,7 +36,7 @@ class BasicOperation(Operation):
Evaluate the operation and generate a list of output values given a list of input values.
"""
pass
-
+
def inputs(self) -> List[InputPort]:
return self._input_ports.copy()
@@ -97,4 +97,13 @@ class BasicOperation(Operation):
return results
return [self]
+ @property
+ def neighbours(self) -> List[Operation]:
+ neighbours: List[Operation] = []
+ for port in self._output_ports + self._input_ports:
+ for signal in port.signals():
+ neighbours += [signal.source.operation, signal.destination.operation]
+
+ return neighbours
+
# TODO: More stuff.
diff --git a/b_asic/core_operations.py b/b_asic/core_operations.py
index 744e37681fddff9c36d9cd35a426637ed4cf5803..bca344cf91a3c21065692a054bd0382dc77724d4 100644
--- a/b_asic/core_operations.py
+++ b/b_asic/core_operations.py
@@ -30,8 +30,8 @@ class Constant(BasicOperation):
"""
Construct a Constant.
"""
- super().__init__(identifier)
- self._output_ports = [OutputPort()] # TODO: Generate appropriate ID for ports.
+ super().__init__()
+ self._output_ports = [OutputPort(1)] # TODO: Generate appropriate ID for ports.
self._parameters["value"] = value
def evaluate(self, inputs: list) -> list:
@@ -50,7 +50,7 @@ class Addition(BasicOperation):
"""
Construct an Addition.
"""
- super().__init__(self)
+ super().__init__()
self._input_ports = [InputPort(1), InputPort(1)] # TODO: Generate appropriate ID for ports.
self._output_ports = [OutputPort(1)] # TODO: Generate appropriate ID for ports.
@@ -59,7 +59,7 @@ class Addition(BasicOperation):
def get_op_name(self) -> GraphIDType:
return "add"
-
+
class ConstantMultiplication(BasicOperation):
"""
@@ -71,7 +71,7 @@ class ConstantMultiplication(BasicOperation):
"""
Construct a ConstantMultiplication.
"""
- super().__init__(identifier)
+ super().__init__()
self._input_ports = [InputPort(1)] # TODO: Generate appropriate ID for ports.
self._output_ports = [OutputPort(1)] # TODO: Generate appropriate ID for ports.
self._parameters["coefficient"] = coefficient
diff --git a/b_asic/graph_id.py b/b_asic/graph_id.py
index c19f6fb0d9dc26ac70a908d527b20ab0f449bb20..3f25f5139d9a8388127962015680e73cf01751c0 100644
--- a/b_asic/graph_id.py
+++ b/b_asic/graph_id.py
@@ -12,7 +12,7 @@ GraphIDNumber = NewType("GraphIDNumber", int)
class GraphIDGenerator:
"""
- A class that generates Graph IDs for objects.
+ A class that generates Graph IDs for objects.
"""
_next_id_number: DefaultDict[GraphIDType, GraphIDNumber]
diff --git a/b_asic/operation.py b/b_asic/operation.py
index 2c35b20ba216cf19570de27e537b0de37595c96d..f02cd70054880fb533fa4a2a292fbdaf222ee085 100644
--- a/b_asic/operation.py
+++ b/b_asic/operation.py
@@ -88,7 +88,7 @@ class Operation(ABC):
"""
Simulate the circuit until its iteration count matches that of the simulation state,
then return the resulting output vector.
- """
+ """
pass
@abstractmethod
@@ -104,5 +104,12 @@ class Operation(ABC):
"""Returns a string representing the operation name of the operation."""
pass
+ @abstractmethod
+ def neighbours(self) -> "List[Operation]":
+ """
+ Return all operations that are connected by signals to this operation.
+ If no neighbours are found this returns an empty list
+ """
+
# TODO: More stuff.
diff --git a/b_asic/traverse_tree.py b/b_asic/traverse_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..024a542d558dd7fd140b54120f19ad12c623f9f9
--- /dev/null
+++ b/b_asic/traverse_tree.py
@@ -0,0 +1,54 @@
+"""
+B-ASIC Operation Tree Traversing Module.
+TODO:
+ - Get a first operation or? an entire operation tree
+ - For each start point, follow it to the next operation from it's out port.
+ - If we are searching for a specific operation end.
+ - If we are searching for a specific type of operation add the operation to a list and continue.
+ - When we no more out ports can be traversed return results and end.
+"""
+
+from typing import List, Optional
+from collections import deque
+
+from b_asic.operation import Operation
+
+
+class Traverse:
+ """Traverse operation tree.
+ TODO:
+ - More info.
+ - Check if a datastructure other than list suits better as return value.
+ - Implement the type check for operation.
+ """
+
+ def __init__(self, operation: Operation):
+ """Construct a TraverseTree."""
+ self._initial_operation = operation
+
+ def _breadth_first_search(self, start: Operation) -> List[Operation]:
+ """Use breadth first search to traverse the operation tree."""
+ visited: List[Operation] = [start]
+ queue = deque([start])
+ while queue:
+ operation = queue.popleft()
+ for n_operation in operation.neighbours:
+ if n_operation not in visited:
+ visited.append(n_operation)
+ queue.append(n_operation)
+
+ return visited
+
+ def traverse(self, type_: Optional[Operation] = None) -> List[Operation]:
+ """Traverse the the operation tree and return operation where type matches.
+ If the type is None then return the entire tree.
+
+ Keyword arguments:
+ type_-- the operation type to search for (default None)
+ """
+
+ operations: List[Operation] = self._breadth_first_search(self._initial_operation)
+ if type_ is not None:
+ operations = [oper for oper in operations if isinstance(oper, type_)]
+
+ return operations
diff --git a/test/fixtures/signal.py b/test/fixtures/signal.py
index 5fbdcf2b4e5e50c9728fb50529835a6fb501fc4c..64b96f5541c7866c4540cd3052a5cbeaea5e4400 100644
--- a/test/fixtures/signal.py
+++ b/test/fixtures/signal.py
@@ -6,15 +6,15 @@ Use a fixture for initializing objects and pass them as argument to a test funct
"""
@pytest.fixture
def signal():
- source = SignalSource(Addition(0), 1)
- dest = SignalDestination(Addition(1), 2)
- return Signal(0, source, dest)
+ source = SignalSource(Addition(), 1)
+ dest = SignalDestination(Addition(), 2)
+ return Signal(source, dest)
@pytest.fixture
def signals():
ret = []
- for i in range(0,3):
- source = SignalSource(Addition(0), 1)
- dest = SignalDestination(Addition(1), 2)
- ret.append(Signal(i, source, dest))
+ for _ in range(0,3):
+ source = SignalSource(Addition(), 1)
+ dest = SignalDestination(Addition(), 2)
+ ret.append(Signal(source, dest))
return ret
\ No newline at end of file
diff --git a/test/port/test_port.py b/test/port/test_port.py
index 5fcf563d8f6897eb00863e781bff0dfd994801b3..7e1fc9b7589a4955966d3333d336bdb6f3245014 100644
--- a/test/port/test_port.py
+++ b/test/port/test_port.py
@@ -15,8 +15,8 @@ def test_connect_one_signal_to_port(signal):
def test_change_port_signal():
source = SignalSource(Addition, 1)
dest = SignalDestination(Addition,2)
- signal1 = Signal(1, source, dest)
- signal2 = Signal(2, source, dest)
+ signal1 = Signal(source, dest)
+ signal2 = Signal(source, dest)
port = InputPort(0)
port.connect(signal1)
diff --git a/test/traverse/test_traverse_tree.py b/test/traverse/test_traverse_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..d218a6e74aed06fee9691ae78e754367cc6f2988
--- /dev/null
+++ b/test/traverse/test_traverse_tree.py
@@ -0,0 +1,85 @@
+"""
+TODO:
+ - Rewrite to more clean code, not so repetitive
+ - Update when signals and id's has been merged.
+"""
+
+from b_asic.core_operations import Constant, Addition
+from b_asic.signal import Signal, SignalSource, SignalDestination
+from b_asic.port import InputPort, OutputPort
+from b_asic.traverse_tree import Traverse
+
+import pytest
+
+@pytest.fixture
+def operation():
+ return Constant(2)
+
+def create_operation(_type, dest_oper, index, **kwargs):
+ oper = _type(**kwargs)
+ oper_signal_source = SignalSource(oper, 0)
+ oper_signal_dest = SignalDestination(dest_oper, index)
+ oper_signal = Signal(oper_signal_source, oper_signal_dest)
+ oper._output_ports[0].connect(oper_signal)
+ dest_oper._input_ports[index].connect(oper_signal)
+ return oper
+
+@pytest.fixture
+def operation_tree():
+ add_oper = Addition()
+
+ const_oper = create_operation(Constant, add_oper, 0, value=2)
+ const_oper_2 = create_operation(Constant, add_oper, 1, value=3)
+
+ return add_oper
+
+@pytest.fixture
+def large_operation_tree():
+ add_oper = Addition()
+ add_oper_2 = Addition()
+
+ const_oper = create_operation(Constant, add_oper, 0, value=2)
+ const_oper_2 = create_operation(Constant, add_oper, 1, value=3)
+
+ const_oper_3 = create_operation(Constant, add_oper_2, 0, value=4)
+ const_oper_4 = create_operation(Constant, add_oper_2, 1, value=5)
+
+ add_oper_3 = Addition()
+ add_oper_signal_source = SignalSource(add_oper, 0)
+ add_oper_signal_dest = SignalDestination(add_oper_3, 0)
+ add_oper_signal = Signal(add_oper_signal_source, add_oper_signal_dest)
+ add_oper._output_ports[0].connect(add_oper_signal)
+ add_oper_3._input_ports[0].connect(add_oper_signal)
+
+ add_oper_2_signal_source = SignalSource(add_oper_2, 0)
+ add_oper_2_signal_dest = SignalDestination(add_oper_3, 1)
+ add_oper_2_signal = Signal(add_oper_2_signal_source, add_oper_2_signal_dest)
+ add_oper_2._output_ports[0].connect(add_oper_2_signal)
+ add_oper_3._input_ports[1].connect(add_oper_2_signal)
+ return const_oper
+
+def test_traverse_single_tree(operation):
+ traverse = Traverse(operation)
+ assert traverse.traverse() == [operation]
+
+def test_traverse_tree(operation_tree):
+ traverse = Traverse(operation_tree)
+ assert len(traverse.traverse()) == 3
+
+def test_traverse_large_tree(large_operation_tree):
+ traverse = Traverse(large_operation_tree)
+ assert len(traverse.traverse()) == 7
+
+def test_traverse_type(large_operation_tree):
+ traverse = Traverse(large_operation_tree)
+ assert len(traverse.traverse(Addition)) == 3
+ assert len(traverse.traverse(Constant)) == 4
+
+def test_traverse_loop(operation_tree):
+ add_oper_signal_source = SignalSource(operation_tree, 0)
+ add_oper_signal_dest = SignalDestination(operation_tree, 0)
+ add_oper_signal = Signal(add_oper_signal_source, add_oper_signal_dest)
+ operation_tree._output_ports[0].connect(add_oper_signal)
+ operation_tree._input_ports[0].connect(add_oper_signal)
+ traverse = Traverse(operation_tree)
+ assert len(traverse.traverse()) == 2
\ No newline at end of file