Question

Context – developing algorithm to determine loop flows in a power flow network.

Issue:

I have a list of lists, each list represents a loop within the network determined via my algorithm. Unfortunately, the algorithm will also pick up the reversed duplicates.

i.e.

L1 = [a, b, c, -d, -a]

L2  = [a, d, c, -b, -a]

(Please note that c should not be negative, it is correct as written due to the structure of the network and defined flows)

Now these two loops are equivalent, simply following the reverse structure throughout the network.

I wish to retain L1, whilst discarding L2 from the list of lists.
Thus if I have a list of 6 loops, of which 3 are reversed duplicates I wish to retain all three.

Additionally, The loop does not have to follow the format specified above. It can be shorter, longer, and the sign structure (e.g. pos pos pos neg neg) will not occur in all instances.

I have been attempting to sort this by reversing the list and comparing the absolute values.

I am completely stumped and any assistance would be appreciated.

Based upon some of the code provided by mgibson I was able to create the following.

def Check_Dup(Loops):
    Act = []
    while Loops:
        L = Loops.pop()
        Act.append(L)
        Loops = Popper(Loops, L)
    return Act

def Popper(Loops, L):
    for loop in Loops:
        Rev = loop[::-1]
        if all (abs(x) == abs(y) for x, y in zip(loop_check, Rev)):
            Loops.remove(loop)
    return Loops

This code should run until there are no loops left discarding the duplicates each time. I’m accepting mgibsons answers as it provided the necessary keys to create the solution

Answer 1

I’m not sure I get your question, but reversing a list is easy:

a = [1,2]
a_rev = a[::-1]  #new list -- if you just want an iterator, reversed(a) also works.

To compare the absolute values of a and a_rev:

all( abs(x) == abs(y) for x,y in zip(a,a_rev) )

which can be simplified to:

all( abs(x) == abs(y) for x,y in zip(a,reversed(a)) )

Now, in order to make this as efficient as possible, I would first sort the arrays based on the absolute value:

your_list_of_lists.sort(key = lambda x : map(abs,x) )

Now you know that if two lists are going to be equal, they have to be adjacent in the list and you can just pull that out using enumerate:

def cmp_list(x,y):
    return True if x == y else all( abs(a) == abs(b) for a,b in zip(a,b) )

duplicate_idx = [ idx for idx,val in enumerate(your_list_of_lists[1:]) 
                  if cmp_list(val,your_list_of_lists[idx])  ]

#now remove duplicates:
for idx in reversed(duplicate_idx):
    _ = your_list_of_lists.pop(idx)

---

If your (sub) lists are either strictly increasing or strictly decreasing, this becomes MUCH simpler.

lists = list(set( tuple(sorted(x)) for x in your_list_of_lists ) )