def test_topological_sort():
V = [2, 3, 5, 7, 8, 9, 10, 11]
E = [(7, 11), (7, 8), (5, 11), (3, 8), (3, 10), (11, 2), (11, 9), (11, 10), (8, 9)]
assert topological_sort((V, E)) == [3, 5, 7, 8, 11, 2, 9, 10]
assert topological_sort((V, E), key=lambda v: -v) == [7, 5, 11, 3, 10, 8, 9, 2]
raises(ValueError, lambda: topological_sort((V, E + [(10, 7)])))
def test_topological_sort():
V = [2, 3, 5, 7, 8, 9, 10, 11]
E = [(7, 11), (7, 8), (5, 11), (3, 8), (3, 10), (11, 2), (11, 9), (11, 10), (8, 9)]
assert topological_sort((V, E)) == [3, 5, 7, 8, 11, 2, 9, 10]
assert topological_sort((V, E), key=lambda v: -v) == [7, 5, 11, 3, 10, 8, 9, 2]
raises(ValueError, "topological_sort((V, E + [(10, 7)]))")
def reps_toposort(r):
"""Sort replacements `r` so (k1, v1) appears before (k2, v2)
if k2 is in v1's free symbols. This orders items in the
way that cse returns its results (hence, in order to use the
replacements in a substitution option it would make sense
to reverse the order).
Examples
========
>>> from sympy.simplify.cse_main import reps_toposort
>>> from sympy.abc import x, y
>>> from sympy import Eq
>>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):
... print(Eq(l, r))
...
Eq(y, 2)
Eq(x, y + 1)
"""
r = sympify(r)
E = []
for c1, (k1, v1) in enumerate(r):
for c2, (k2, v2) in enumerate(r):
if k1 in v2.free_symbols:
E.append((c1, c2))
return [r[i] for i in topological_sort((range(len(r)), E))]
def reps_toposort(r):
"""Sort replacements `r` so (k1, v1) appears before (k2, v2)
if k2 is in v1's free symbols. This orders items in the
way that cse returns its results (hence, in order to use the
replacements in a substitution option it would make sense
to reverse the order).
Examples
========
>>> from sympy.simplify.cse_main import reps_toposort
>>> from sympy.abc import x, y
>>> from sympy import Eq
>>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):
... print Eq(l, r)
...
y == 2
x == y + 1
"""
r = sympify(r)
E = []
for c1, (k1, v1) in enumerate(r):
for c2, (k2, v2) in enumerate(r):
if k1 in v2.free_symbols:
E.append((c1, c2))
return [r[i] for i in topological_sort((range(len(r)), E))]
def topological_sort(components: Sequence[Union['Rule', 'Constant']]):
# Returns a list of components sorted so that no element contains an element earlier in the list
n_components = len(components)
indexes_components = list(range(n_components))
# Find all pairs (i,j) where rule i contains a reference to rule j
edges = [(i, j) for i, j in permutations(indexes_components, 2) if components[i].contains(components[j].name)]
# Sort rules by topology
index_sorted = topological_sort([indexes_components, edges])
return [components[i] for i in index_sorted]
def topological_sort(components: List[Union['Rule', 'Constant']]) -> 'List[Component]':
# Returns a list of components sorted so that no element contains an element earlier in the list
n_components = len(components)
indexes_components = list(range(n_components))
# Find all pairs (i,j) where rule i contains a reference to rule j
edges = [(i, j) for i, j in permutations(indexes_components, 2) if components[i].contains(components[j].name)]
# Sort rules by topology
index_sorted = topological_sort([indexes_components, edges])
return [components[i] for i in index_sorted]
def _bounds_case(cls, limits):
V = list(limits.keys())
E = list()
for p in V:
lower_p = limits[p][0]
upper_p = limits[p][1]
lower_p = lower_p.atoms()
upper_p = upper_p.atoms()
for q in V:
if p == q:
continue
if lower_p.issuperset(set([q])) or upper_p.issuperset(set([q])):
E.append((p, q))
return topological_sort((V, E), key=default_sort_key)
def topological_sort(cls, assignments):
"""
Return a CodeBlock with topologically sorted assignments so that
variables are assigned before they are used.
The existing order of assignments is preserved as much as possible.
This function assumes that variables are assigned to only once.
This is a class constructor so that the default constructor for
CodeBlock can error when variables are used before they are assigned.
Example
=======
>>> from sympy import symbols
>>> from sympy.codegen.ast import CodeBlock, Assignment
>>> x, y, z = symbols('x y z')
>>> assignments = [
... Assignment(x, y + z),
... Assignment(y, z + 1),
... Assignment(z, 2),
... ]
>>> CodeBlock.topological_sort(assignments)
CodeBlock(Assignment(z, 2), Assignment(y, z + 1), Assignment(x, y + z))
"""
from sympy.utilities.iterables import topological_sort
# Create a graph where the nodes are assignments and there is a directed edge
# between nodes that use a variable and nodes that assign that
# variable, like
# [(x := 1, y := x + 1), (x := 1, z := y + z), (y := x + 1, z := y + z)]
# If we then topologically sort these nodes, they will be in
# assignment order, like
# x := 1
# y := x + 1
# z := y + z
# A = The nodes
#
# enumerate keeps nodes in the same order they are already in if
# possible. It will also allow us to handle duplicate assignments to
# the same variable when those are implemented.
A = list(enumerate(assignments))
# var_map = {variable: [assignments using variable]}
# like {x: [y := x + 1, z := y + x], ...}
var_map = {}
# E = Edges in the graph
E = []
for i in A:
if i[1].lhs in var_map:
E.append((var_map[i[1].lhs], i))
var_map[i[1].lhs] = i
for i in A:
for x in i[1].rhs.free_symbols:
if x not in var_map:
# XXX: Allow this case?
raise ValueError("Undefined variable %s" % x)
E.append((var_map[x], i))
ordered_assignments = topological_sort([A, E])
# De-enumerate the result
return cls(*list(zip(*ordered_assignments))[1])
def topological_sort(cls, assignments):
"""
Return a CodeBlock with topologically sorted assignments so that
variables are assigned before they are used.
The existing order of assignments is preserved as much as possible.
This function assumes that variables are assigned to only once.
This is a class constructor so that the default constructor for
CodeBlock can error when variables are used before they are assigned.
Example
=======
>>> from sympy import symbols
>>> from sympy.codegen.ast import CodeBlock, Assignment
>>> x, y, z = symbols('x y z')
>>> assignments = [
... Assignment(x, y + z),
... Assignment(y, z + 1),
... Assignment(z, 2),
... ]
>>> CodeBlock.topological_sort(assignments)
CodeBlock(Assignment(z, 2), Assignment(y, z + 1), Assignment(x, y + z))
"""
from sympy.utilities.iterables import topological_sort
# Create a graph where the nodes are assignments and there is a directed edge
# between nodes that use a variable and nodes that assign that
# variable, like
# [(x := 1, y := x + 1), (x := 1, z := y + z), (y := x + 1, z := y + z)]
# If we then topologically sort these nodes, they will be in
# assignment order, like
# x := 1
# y := x + 1
# z := y + z
# A = The nodes
#
# enumerate keeps nodes in the same order they are already in if
# possible. It will also allow us to handle duplicate assignments to
# the same variable when those are implemented.
A = list(enumerate(assignments))
# var_map = {variable: [assignments using variable]}
# like {x: [y := x + 1, z := y + x], ...}
var_map = {}
# E = Edges in the graph
E = []
for i in A:
if i[1].lhs in var_map:
E.append((var_map[i[1].lhs], i))
var_map[i[1].lhs] = i
for i in A:
for x in i[1].rhs.free_symbols:
if x not in var_map:
# XXX: Allow this case?
raise ValueError("Undefined variable %s" % x)
E.append((var_map[x], i))
ordered_assignments = topological_sort([A, E])
# De-enumerate the result
return cls(*list(zip(*ordered_assignments))[1])
