def test_read_logic_missing_equation(self): """ Raise ValueError if an equation is missing """ LOGIC = join(self.LOGIC_PATH, "missing_equation.txt") with self.assertRaises(FormatError): LogicNetwork.read_logic(LOGIC)
def test_logic_simple_read_no_node_headers(self): """ Test simple network read in (no node headers) """ SIMPLE_TRUTH_TABLE = join(self.TABLE_PATH, "no_node_headers.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(SIMPLE_TRUTH_TABLE)
def test_read_table_missing_node(self): """ Raise FormatError if a node is missing from the header """ TRUTH_TABLE = join(self.TABLE_PATH, "missing_node.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(TRUTH_TABLE)
def test_read_table_invalid_condition(self): """ Raise FormatError if a condition has an invalid state """ TRUTH_TABLE = join(self.TABLE_PATH, "invalid_condition.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(TRUTH_TABLE)
def test_neighbors_both(self): net = LogicNetwork([((1, 2), set(['11', '10'])), ((0, ), set(['1'])), ((0, 1, 2), set(['010', '011', '101'])), ((3, ), set(['1']))]) self.assertEqual(net.neighbors(2), set([0, 1, 2]))
def test_to_networkx_graph_names(self): net = LogicNetwork([((1, 2), {'01', '10'}), ((0, 2), ((0, 1), '10', [1, 1])), ((0, 1), {'11'})], ['A', 'B', 'C']) nx_net = net.to_networkx_graph(labels='names') self.assertEqual(set(nx_net), set(['A', 'B', 'C']))
def test_logic_simple_read_no_header(self): """ Test simple network read in (no header) """ TRUTH_TABLE = join(self.TABLE_PATH, "no_header.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(TRUTH_TABLE)
def test_network_graph_metadata(self): net = LogicNetwork([((0, ), {'0'})]) net.metadata['name'] = 'net_name' nx_net = net.network_graph(labels='indices') self.assertEqual(nx_net.graph['name'], net.metadata['name'])
def test_canalizing(self): net = LogicNetwork([((1, 2), {'01', '10'}), ((0, 2), ('01', '10', '11')), ((0, 1), {'11'})]) edges = net.canalizing_edges() self.assertEqual(edges, {(1, 0), (1, 2), (2, 0), (2, 1)}) nodes = net.canalizing_nodes() self.assertEqual(nodes, {1, 2})
def test_init(self): net = LogicNetwork([((0, ), {'0'})]) self.assertEqual(1, net.size) self.assertEqual([(1, {0})], net._encoded_table) net = LogicNetwork([((1, ), {'0', '1'}), ((0, ), {'1'})], ['A', 'B']) self.assertEqual(2, net.size) self.assertEqual(['A', 'B'], net.names) self.assertEqual([(2, {0, 2}), (1, {1})], net._encoded_table)
def test_is_canalizing_logic_network(self): net = LogicNetwork([((1, 2), {'01', '10'}), ((0, 2), ('01', '10', '11')), ((0, 1), {'11'}), ((3, ), {'0'})]) self.assertFalse(net.is_canalizing(0, 1)) self.assertTrue(net.is_canalizing(1, 0)) self.assertTrue(net.is_canalizing(2, 1)) self.assertFalse(net.is_canalizing(0, 3)) self.assertFalse(net.is_canalizing(3, 0))
def test_logic_simple_read_no_node_headers(self): from os.path import dirname, abspath, realpath, join # Determine the path to the "data" directory of the neet.test module DATA_PATH = join(dirname(abspath(realpath(__file__))), "data") # Test simple network read in (no header) SIMPLE_TRUTH_TABLE = join( DATA_PATH, "test_simple_no_node_headers-truth_table.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(SIMPLE_TRUTH_TABLE)
def test_read_table_condition_len_mismatch(self): """ Raise FormatError if a condition has too many or too few bits in it """ TRUTH_TABLE = join(self.TABLE_PATH, "missing_condition.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(TRUTH_TABLE) TRUTH_TABLE = join(self.TABLE_PATH, "extra_condition.txt") with self.assertRaises(FormatError): LogicNetwork.read_table(TRUTH_TABLE)
def test_average_sensitivity_logic_network(self): net = LogicNetwork([((1, 2), {'01', '10'}), ((0, 2), ('01', '10', '11')), ((0, 1), {'11'})]) s = net.average_sensitivity() self.assertAlmostEqual(s, 1.3333333333333333) s = net.average_sensitivity(weights=np.ones(8)) self.assertAlmostEqual(s, 1.3333333333333333) s = net.average_sensitivity(states=list(net)) self.assertAlmostEqual(s, 1.3333333333333333)
def test_transitions_logicnetwork(self): net = LogicNetwork([((1, ), {'0', '1'}), ((0, ), {'1'})]) landscape = Landscape(net) self.assertEqual(net, landscape.network) self.assertEqual(2, landscape.size) self.assertEqual([1, 3, 1, 3], list(landscape.transitions))
def test_transitions_logicnetwork_encoded(self): """ test `transitions` on `LogicNetwork`s, states encoded """ net = LogicNetwork([((1, ), {'0', '1'}), ((0, ), {'1'})]) got = transitions(net, encode=True) self.assertEqual([1, 3, 1, 3], got)
def test_transitions_logicnetwork(self): """ test `transitions` on `LogicNetwork`s """ net = LogicNetwork([((1, ), {'0', '1'}), ((0, ), {'1'})]) got = transitions(net) self.assertEqual([[1, 0], [1, 1], [1, 0], [1, 1]], got)
def test_init_long(self): table = [((), set()) for _ in range(65)] table[0] = ((np.int64(64), ), set('1')) mask = long(2)**64 net = LogicNetwork(table) self.assertEqual(net.table, table) self.assertEqual(net._encoded_table[0], (mask, set([mask])))
def test_transitions_logicnetwork_index(self): net = LogicNetwork([((1,), {'0', '1'}), ((0,), {'1'})]) net.landscape(index=1) self.assertEqual([0, 3, 0, 3], list(net.transitions)) net.landscape(index=0) self.assertEqual([1, 1, 3, 3], list(net.transitions)) net.landscape(index=None) self.assertEqual([1, 3, 1, 3], list(net.transitions))
def test_transitions_logicnetwork_pin(self): net = LogicNetwork([((1,), {'0', '1'}), ((0,), {'1'})]) net.landscape(pin=[1]) self.assertEqual([1, 1, 3, 3], list(net.transitions)) net.landscape(pin=[0]) self.assertEqual([0, 3, 0, 3], list(net.transitions)) net.landscape(pin=None) self.assertEqual([1, 3, 1, 3], list(net.transitions))
def test_transitions_logicnetwork_values(self): net = LogicNetwork([((1,), {'0', '1'}), ((0,), {'1'})]) net.landscape(values={0: 1}) self.assertEqual([1, 3, 1, 3], list(net.transitions)) net.landscape(values={1: 0}) self.assertEqual([1, 1, 1, 1], list(net.transitions)) net.landscape(values={}) self.assertEqual([1, 3, 1, 3], list(net.transitions))
def test_read_table_skips_empty(self): """ Empty lines are skipped when reading truth tables """ TRUTH_TABLE = join(self.TABLE_PATH, "empty_lines.txt") simple = LogicNetwork.read_table(TRUTH_TABLE) self.assertEqual(simple.names, ['A', 'B', 'C']) self.assertEqual(simple.table, [((1, 2), set(['10', '11'])), ((0, ), set(['1'])), ((1, 2, 0), set(['101', '010', '011']))])
def test_update_exceptions(self): net = LogicNetwork([((1, 2), {'01', '10'}), ((0, 2), {(0, 1), '10', (1, 1)}), ((0, 1), {'11'})]) with self.assertRaises(ValueError): net.update([0, 0]) with self.assertRaises(ValueError): net.update([0, 0, 1], values={0: 2}) with self.assertRaises(ValueError): net.update([0, 0, 1], pin=[0], values={0: 1})
def _randomize(self, topo=None): if topo is None: topo = self.topogen.random() table = [] for node in np.sort(topo.nodes): predecessors = tuple(topo.predecessors(node)) table.append( (predecessors, self._random_function(len(predecessors)))) return LogicNetwork(table)
def test_node_dependency(self): net = LogicNetwork([((1, 2), {'11', '10'}), ((0, ), {'1'}), ((0, 1, 2), {'010', '011', '101', '100'})]) self.assertTrue(net.is_dependent(0, 1)) self.assertFalse(net.is_dependent(0, 2)) self.assertTrue(net.is_dependent(1, 0)) self.assertFalse(net.is_dependent(1, 2)) self.assertFalse(net.is_dependent(2, 2)) self.assertTrue(net.is_dependent(2, 0)) self.assertTrue(net.is_dependent(2, 1))
def test_logic_simple_read_empty(self): """ Test simple network read in (empty table) """ TRUTH_TABLE = join(self.TABLE_PATH, "empty_table.txt") simple = LogicNetwork.read_table(TRUTH_TABLE) self.assertEqual(simple.names, ['A', 'B', 'C', 'D']) self.assertEqual(simple.table, [((0, ), set(['1'])), ((1, ), set(['1'])), ((2, ), set(['1'])), ((3, ), set(['1']))])
def make_network(net, trans): """ Given a network and desired state transitions, construct a `LogicNetwork` which implements those transitions. """ table = [(list(range(net.size)), set()) for _ in range(net.size)] for a, b in zip(net, map(net.decode, trans)): state = ''.join(map(str, a)) for u, row in zip(b, table): if u == 1: row[1].add(state) return LogicNetwork(table, reduced=True)
def test_logic_simple_read_custom_comment(self): """ Test simple network read in with custom comments """ TRUTH_TABLE = join(self.TABLE_PATH, "custom_comment.txt") simple = LogicNetwork.read_table(TRUTH_TABLE) self.assertEqual(simple.names, ['A', 'B', 'C', 'D']) self.assertEqual(simple.table, [((1, 2), set(['11', '10'])), ((0, ), set(['1'])), ((1, 2, 0), set(['010', '011', '101'])), ((3, ), set(['1']))])
def test_logic_simple_read(self): """ Read a network from a truth table file """ TRUTH_TABLE = join(self.TABLE_PATH, "simple_table.txt") simple = LogicNetwork.read_table(TRUTH_TABLE) self.assertEqual(simple.names, ['A', 'B', 'C', 'D']) self.assertEqual(simple.table, [((1, 2), set(['11', '10'])), ((0, ), set(['1'])), ((1, 2, 0), set(['010', '011', '101'])), ((3, ), set(['1']))])
def test_is_irreducible_satisfies(self): """ IsIrreducible.satisfies correctly identifies networks that are irreducible. """ constraint = IsIrreducible() self.assertTrue(constraint.satisfies(myeloid)) reducible = LogicNetwork([((0,), {'0', '1'})]) self.assertFalse(constraint.satisfies(reducible)) reducible = LogicNetwork([((0, 1), {'01', '11'}), ((0, 1), {'00', '01', '11'})]) self.assertFalse(constraint.satisfies(reducible)) reducible = LogicNetwork([((1,), {'0'}), ((0, 1), {'01', '11'})]) self.assertFalse(constraint.satisfies(reducible)) irreducible = LogicNetwork([((0,), {'0'})]) self.assertTrue(constraint.satisfies(irreducible)) irreducible = LogicNetwork([((0, 1), {'01'}), ((0, 1), {'00', '01', '11'})]) self.assertTrue(constraint.satisfies(irreducible)) irreducible = LogicNetwork([((1,), {'0'}), ((0, 1), {'01', '11', '10'})]) self.assertTrue(constraint.satisfies(irreducible))