itertools remove equivalent elements

Question

I'm generating all vectors respecting some symmetry groups using itertools in python.

Basically all is just permutation of x,y,z axis and sign. I'm just not sure what is the best way to ensure that equivalent vectors are not duplicated E.g.

1. 0 = -0 therefore sign permuations of [1, 2, 0] should be just [[1, 2, 0], [1, -2, 0], [-1, 2, 0], [-1, -2, 0]]
2. itertools.permutations( 'AAB' ) should produce [('A', 'B', 'A'), ('B', 'A', 'A'), ('A', 'A', 'B')] i.e. not duplicating each elements by exchange of equvalent A

---

My current solution:

to remove dumplicate I pass it through a set like lst = list(set(lst)). But I don't like to create a lot of garbage which is filtered out later. Also it arbitrarily change order of elements. Also it set can be created just form hashable elements (e.g. tuples, but not lists or numpy arrays ) which requires conversion.

# using itertools.product and set filer
def signPermut( t ):
    lst = []
    n = len(t)
    for signs in itertools.product( [-1,1], repeat=n):
        p = [ ti*si for ti,si in zip(t,signs) ]
        lst.append(tuple(p))
    #return lst
    return list(set(lst))

This function does the sign permutation with checking for zeros, but it is probably very inefficient:

def permutSign( t ):
    lst = [ [] ]
    for c in t:
        lst_ = []
        if c != 0:
            for p in lst:
                lst_.append(p+[ c]) 
                lst_.append(p+[-c])
        else:
            for p in lst:
                lst_.append( p+[c])
        lst = lst_
    return lst

It is working, but I was thinking maybe there is something prefabricated ... more efficient, simple and pythonic

Answer 1

how about creating a list with the signs and using itertools.product over that:

from itertools import product

lst = [1, 2, 0]

signs = [(1, -1) if item != 0 else (1, ) for item in lst]
print(signs)  # [(1, -1), (1, -1), (1,)]

res = []
for sign in product(*signs):
    res.append([s*n for s, n in zip(sign, lst)])

print(res)  # [[1, 2, 0], [1, -2, 0], [-1, 2, 0], [-1, -2, 0]]

or in one go:

from itertools import product

sgn_lst =  [(n, -n) if n != 0 else (0, ) for n in lst]
print(sgn_lst)  # [(1, -1), (2, -2), (0,)]

res = []
for item in product(*sgn_lst):
    res.append(item)

print(res)  # [(1, 2, 0), (1, -2, 0), (-1, 2, 0), (-1, -2, 0)]

this way there is a lot less work to do inside the loop.

Answer 2

Maybe this is a bit more Pythonic:

import itertools

def signProducts(vector):
    svector = [[x,-x] if x != 0 else [x] for x in vector]
    return itertools.product(*svector)

#test:
v = [1,2,0]
for w in signProducts(v): print(w)

Output:

(1, 2, 0)
(1, -2, 0)
(-1, 2, 0)
(-1, -2, 0)

Answer 3

I think no matter how smart you are about using itertools, sets or iterators - the most important thing is to write code in a way that is easy to understand e.g. it won't hurt to name vars better and make it obvious that you multiply vectors:

import itertools
import operator

def genAxes(n):
    return itertools.product((-1, 1), repeat=n)

def multiplyVectors(x, y):
    return itertools.imap(operator.mul, x, y)

def signPermutation(v):
    n = len(v)
    axes = genAxes(n)
    permut = map(lambda a: tuple(multiplyVectors(v, a)), axes)
    return list(set(permut))

v = [0, 1, 2]
print signPermutation(v)

This is just an example how to make it easier to follow IMHO.