def test_multiset_permutations():
ans = ['abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab',
'byba', 'yabb', 'ybab', 'ybba']
assert [''.join(i) for i in multiset_permutations('baby')] == ans
assert [''.join(i) for i in multiset_permutations(multiset('baby'))] == ans
assert list(multiset_permutations([0, 0, 0], 2)) == [[0, 0]]
assert list(multiset_permutations([0, 2, 1], 2)) == [
[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]]
def test():
for i in range(1, 7):
print i
for p in multiset_permutations([0, 0, 1, 0, 1], i):
print p
assert capture(lambda: test()) == dedent('''\
1
[0]
[1]
2
[0, 0]
[0, 1]
[1, 0]
[1, 1]
3
[0, 0, 0]
[0, 0, 1]
[0, 1, 0]
[0, 1, 1]
[1, 0, 0]
[1, 0, 1]
[1, 1, 0]
4
[0, 0, 0, 1]
[0, 0, 1, 0]
[0, 0, 1, 1]
[0, 1, 0, 0]
[0, 1, 0, 1]
[0, 1, 1, 0]
[1, 0, 0, 0]
[1, 0, 0, 1]
[1, 0, 1, 0]
[1, 1, 0, 0]
5
[0, 0, 0, 1, 1]
[0, 0, 1, 0, 1]
[0, 0, 1, 1, 0]
[0, 1, 0, 0, 1]
[0, 1, 0, 1, 0]
[0, 1, 1, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 0, 1, 0]
[1, 0, 1, 0, 0]
[1, 1, 0, 0, 0]
6\n''')
def test_multiset_permutations():
ans = ["abby", "abyb", "aybb", "baby", "bayb", "bbay", "bbya", "byab", "byba", "yabb", "ybab", "ybba"]
assert ["".join(i) for i in multiset_permutations("baby")] == ans
assert ["".join(i) for i in multiset_permutations(multiset("baby"))] == ans
assert list(multiset_permutations([0, 0, 0], 2)) == [[0, 0]]
assert list(multiset_permutations([0, 2, 1], 2)) == [[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]]
assert len(list(multiset_permutations("a", 0))) == 1
assert len(list(multiset_permutations("a", 3))) == 0
def test():
for i in range(1, 7):
print(i)
for p in multiset_permutations([0, 0, 1, 0, 1], i):
print(p)
assert capture(lambda: test()) == dedent(
"""\
1
[0]
[1]
2
[0, 0]
[0, 1]
[1, 0]
[1, 1]
3
[0, 0, 0]
[0, 0, 1]
[0, 1, 0]
[0, 1, 1]
[1, 0, 0]
[1, 0, 1]
[1, 1, 0]
4
[0, 0, 0, 1]
[0, 0, 1, 0]
[0, 0, 1, 1]
[0, 1, 0, 0]
[0, 1, 0, 1]
[0, 1, 1, 0]
[1, 0, 0, 0]
[1, 0, 0, 1]
[1, 0, 1, 0]
[1, 1, 0, 0]
5
[0, 0, 0, 1, 1]
[0, 0, 1, 0, 1]
[0, 0, 1, 1, 0]
[0, 1, 0, 0, 1]
[0, 1, 0, 1, 0]
[0, 1, 1, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 0, 1, 0]
[1, 0, 1, 0, 0]
[1, 1, 0, 0, 0]
6\n"""
)
def test_multiset_permutations():
assert ["".join(i) for i in (list(multiset_permutations("baby")))] == [
"abby",
"abyb",
"aybb",
"baby",
"bayb",
"bbay",
"bbya",
"byab",
"byba",
"yabb",
"ybab",
"ybba",
]
def test_nC_nP_nT():
from sympy.utilities.iterables import (multiset_permutations,
multiset_combinations,
multiset_partitions, partitions,
subsets, permutations)
from sympy.functions.combinatorial.numbers import (nP, nC, nT, stirling,
_multiset_histogram,
_AOP_product)
from sympy.combinatorics.permutations import Permutation
from sympy.core.numbers import oo
from random import choice
c = string.ascii_lowercase
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(8):
check = nP(s, i)
tot += check
assert len(list(multiset_permutations(s, i))) == check
if u:
assert nP(len(s), i) == check
assert nP(s) == tot
except AssertionError:
print(s, i, 'failed perm test')
raise ValueError()
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(8):
check = nC(s, i)
tot += check
assert len(list(multiset_combinations(s, i))) == check
if u:
assert nC(len(s), i) == check
assert nC(s) == tot
if u:
assert nC(len(s)) == tot
except AssertionError:
print(s, i, 'failed combo test')
raise ValueError()
for i in range(1, 10):
tot = 0
for j in range(1, i + 2):
check = nT(i, j)
tot += check
assert sum(1 for p in partitions(i, j, size=True)
if p[0] == j) == check
assert nT(i) == tot
for i in range(1, 10):
tot = 0
for j in range(1, i + 2):
check = nT(range(i), j)
tot += check
assert len(list(multiset_partitions(list(range(i)), j))) == check
assert nT(range(i)) == tot
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(1, 8):
check = nT(s, i)
tot += check
assert len(list(multiset_partitions(s, i))) == check
if u:
assert nT(range(len(s)), i) == check
if u:
assert nT(range(len(s))) == tot
assert nT(s) == tot
except AssertionError:
print(s, i, 'failed partition test')
raise ValueError()
# tests for Stirling numbers of the first kind that are not tested in the
# above
assert [stirling(9, i, kind=1) for i in range(11)
] == [0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
perms = list(permutations(range(4)))
assert [
sum(1 for p in perms if Permutation(p).cycles == i) for i in range(5)
] == [0, 6, 11, 6, 1] == [stirling(4, i, kind=1) for i in range(5)]
# http://oeis.org/A008275
assert [
stirling(n, k, signed=1) for n in range(10) for k in range(1, n + 1)
] == [
1, -1, 1, 2, -3, 1, -6, 11, -6, 1, 24, -50, 35, -10, 1, -120, 274,
-225, 85, -15, 1, 720, -1764, 1624, -735, 175, -21, 1, -5040, 13068,
-13132, 6769, -1960, 322, -28, 1, 40320, -109584, 118124, -67284,
22449, -4536, 546, -36, 1
]
# http://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
assert [stirling(n, k, kind=1) for n in range(10)
for k in range(n + 1)] == [
1, 0, 1, 0, 1, 1, 0, 2, 3, 1, 0, 6, 11, 6, 1, 0, 24, 50, 35,
10, 1, 0, 120, 274, 225, 85, 15, 1, 0, 720, 1764, 1624, 735,
175, 21, 1, 0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1, 0,
40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1
]
# http://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
assert [stirling(n, k, kind=2) for n in range(10)
for k in range(n + 1)] == [
1, 0, 1, 0, 1, 1, 0, 1, 3, 1, 0, 1, 7, 6, 1, 0, 1, 15, 25, 10,
1, 0, 1, 31, 90, 65, 15, 1, 0, 1, 63, 301, 350, 140, 21, 1, 0,
1, 127, 966, 1701, 1050, 266, 28, 1, 0, 1, 255, 3025, 7770,
6951, 2646, 462, 36, 1
]
assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
raises(ValueError, lambda: stirling(-2, 2))
def delta(p):
if len(p) == 1:
return oo
return min(abs(i[0] - i[1]) for i in subsets(p, 2))
parts = multiset_partitions(range(5), 3)
d = 2
assert (sum(1
for p in parts if all(delta(i) >= d
for i in p)) == stirling(5, 3, d=d) == 7)
# other coverage tests
assert nC('abb', 2) == nC('aab', 2) == 2
assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
assert nP(3, 4) == 0
assert nP('aabc', 5) == 0
assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
len(list(multiset_combinations('aabbccdd', 2))) == 10
assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
assert nC(list('abcdd'), 4) == 4
assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
assert nC('aabb' * 3, 3) == 4 # aaa, bbb, abb, baa
assert dict(_AOP_product((4, 1, 1, 1))) == {
0: 1,
1: 4,
2: 7,
3: 8,
4: 8,
5: 7,
6: 4,
7: 1
}
# the following was the first t that showed a problem in a previous form of
# the function, so it's not as random as it may appear
t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
raises(ValueError, lambda: _multiset_histogram({1: 'a'}))
def computeExprTreeActionFixed(cur_strat, opp_action, ordered_groups, N):
"""
Compute the expression of a strategy against another strategy, knowing that the opponent's action is fixed
:param cur_strat: current strategy
:param opp_action: opponent action
:param ordered_groups: combination of all possible groups of size (N-1) of cur_strat and other_strat
:param N: size of the group
:return: array of expressions for each combination of the groups
"""
nb_states = len(cur_strat[2:])
expr_all_opponent_nb = []
print(len(ordered_groups))
for i in range(
N - 1
): #Only against 0same strat up to N-1 same strat (the rest in group is opponent strat)
print("loop ", i)
opponents = i * [0] + (N - 1 - i) * [1]
groups_comb = list(multiset_permutations(opponents))
print(len(groups_comb))
strat_loop = time.time()
expr_groups = 0.
for group in groups_comb:
expr_all_states = 0.
for state in range(nb_states):
root = Tree(state, cur_strat, 1)
if group[0] == 1: #If first element has the opponent strat
root.buildExpr(opp_action)
root.addChildren(opp_action)
else:
root.buildExprVariableActionsStrat(cur_strat)
root.addChildrenVariableAction(cur_strat)
current_level = root.getChildren()
expr_state_config = root.getExpr()
for j in range(1, N - 1):
if group[j] == 1:
next_level = []
for child in current_level:
child.buildExpr(opp_action)
child.addChildren(opp_action)
expr_state_config += child.getExpr()
for new_child in child.getChildren():
next_level.append(new_child)
current_level = list(next_level)
else:
next_level = []
for child in current_level:
child.buildExprVariableActionsStrat(cur_strat)
child.addChildrenVariableAction(cur_strat)
expr_state_config += child.getExpr()
for new_child in child.getChildren():
next_level.append(new_child)
current_level = list(next_level)
expr_all_states += expr_state_config
expr_all_states /= nb_states
expr_groups += expr_all_states
expr_groups /= len(
groups_comb
) #Avg expression of strategy A against group of A/B's of size N-1 with i B's in it
print(expr_groups)
expr_all_opponent_nb.append(expr_groups)
print("Loop computeExprTreeActionFixed ", i, " of ", N - 1,
" computed in --- %s seconds --- " % (time.time() - strat_loop))
print(len(expr_all_opponent_nb))
return expr_all_opponent_nb
def permutations(points):
return multiset_permutations(points)
def test_multiset_permutations():
ans = [
'abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab', 'byba',
'yabb', 'ybab', 'ybba'
]
assert [''.join(i) for i in multiset_permutations('baby')] == ans
assert [''.join(i) for i in multiset_permutations(multiset('baby'))] == ans
assert list(multiset_permutations([0, 0, 0], 2)) == [[0, 0]]
assert list(multiset_permutations([0, 2, 1],
2)) == [[0, 1], [0, 2], [1, 0], [1, 2],
[2, 0], [2, 1]]
assert len(list(multiset_permutations('a', 0))) == 1
assert len(list(multiset_permutations('a', 3))) == 0
for nul in ([], {}, ''):
assert list(multiset_permutations(nul)) == [[]]
assert list(multiset_permutations(nul, 0)) == [[]]
# impossible requests give no result
assert list(multiset_permutations(nul, 1)) == []
assert list(multiset_permutations(nul, -1)) == []
def test():
for i in range(1, 7):
print(i)
for p in multiset_permutations([0, 0, 1, 0, 1], i):
print(p)
assert capture(lambda: test()) == dedent('''\
1
[0]
[1]
2
[0, 0]
[0, 1]
[1, 0]
[1, 1]
3
[0, 0, 0]
[0, 0, 1]
[0, 1, 0]
[0, 1, 1]
[1, 0, 0]
[1, 0, 1]
[1, 1, 0]
4
[0, 0, 0, 1]
[0, 0, 1, 0]
[0, 0, 1, 1]
[0, 1, 0, 0]
[0, 1, 0, 1]
[0, 1, 1, 0]
[1, 0, 0, 0]
[1, 0, 0, 1]
[1, 0, 1, 0]
[1, 1, 0, 0]
5
[0, 0, 0, 1, 1]
[0, 0, 1, 0, 1]
[0, 0, 1, 1, 0]
[0, 1, 0, 0, 1]
[0, 1, 0, 1, 0]
[0, 1, 1, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 0, 1, 0]
[1, 0, 1, 0, 0]
[1, 1, 0, 0, 0]
6\n''')
raises(ValueError, lambda: list(multiset_permutations({0: 3, 1: -1})))
def playMusicPuzzle(save_txt=True, save_csv=True, save_mp3=True):
# all target audio
fs = sorted(glob('data/*.mp3'))
# extract mel-spectrogram and name
target_name, target_fea = [], []
for f in fs:
S = read_audio(f)
target_name.append(f.split('/')[-1][:-4])
target_fea.append(S)
# overall possible permutations (brute-force method)
n = len(fs)
ps = [p for p in multiset_permutations(np.arange(n))]
ps = np.array(ps)
# calculate pairwise-similarity
with tf.Session() as sess:
model = SEN(is_train=False)
sess.run(tf.global_variables_initializer())
model.saver.restore(sess, 'model/model')
score = np.zeros((n, n))
for i in range(n):
for j in range(n):
if i != j:
batch = Batch()
batch.x1 = [target_fea[i]]
batch.x2 = [target_fea[j]]
batch.y = [[0, 0]]
score[i, j] = model.calculate(sess, batch)[0][1]
# find the best permutation
output = []
for p in ps:
temp = 0
for z in range(len(p) - 1):
temp += score[p[z], p[z + 1]]
output.append(temp)
best_p = ps[np.argmax(output)]
# save best permutation (txt)
if save_txt:
with open('output/best_permutation.txt', mode='w',
encoding='utf-8') as file:
temp = [target_name[index] for index in best_p]
file.write('%s' % ('\t'.join(temp)))
# save pair-wise similarity (csv)
if save_csv:
with open('output/output.csv', mode='w',
encoding='utf_8_sig') as csvfile:
writer = csv.writer(csvfile)
writer.writerow([''] + target_name)
for n, s in zip(target_name, score):
temp = [str(ss) for ss in s]
temp = [n] + temp
writer.writerow(temp)
# save concatenated audio based on the best permutation (mp3)
if save_mp3:
result = ''
for index in best_p:
audio = AudioSegment.from_file(fs[index], format='mp3')
if result == '':
result = audio
else:
result += audio
result.export('output/output.mp3', format='mp3')
def combos(new_grid, blocks):
'''
This gives all the possible block location combinations.
'''
# This extracts all the 'o' in the original grid, and appends
# them into p_list. 'o' is the position we could put blocks.
p_list = []
block_list = bk_list(blocks)
for row in new_grid:
for item in row:
if item == 'o':
p_list.append('o')
else:
continue
# This uses blocks in the block list to replace the first 'o's
# in the p_list.
block_num = sum(blocks.values())
for num in range(block_num):
if len(block_list) >= num:
p_list[num] = block_list[num]
else:
continue
# This gives all the permutations of blocks and 'o's in the p_list.
Combo_list = list(multiset_permutations(p_list))
# This puts all the blocks and 'o's in p_list back to the new_grid.
possibile_grid_list = []
for number in range(len(Combo_list)):
# This makes a copy of the new_grid
possible_grid = [['n' for x in range(len(new_grid[0]))]
for y in range(len(new_grid))]
for i in range(len(new_grid)):
for j in range(len(new_grid[0])):
possible_grid[i][j] = new_grid[i][j]
# This puts blocks and 'o's into the copied grid.
for y in range(len(possible_grid)):
for x in range(len(possible_grid[0])):
if possible_grid[y][x] == 'o':
possible_grid[y][x] = Combo_list[number].pop(0)
else:
continue
# All the possible grids are appended into possibile_grid_list.
possibile_grid_list.append(possible_grid)
# From all possible grids, this extracts the (x,y) coordinates of
# blocks A, B, and C, including the fixed blocks.
block_A = []
block_B = []
block_C = []
for n in range(len(possibile_grid_list)):
block_A.append([])
block_B.append([])
block_C.append([])
for i in range(len(new_grid)):
for j in range(len(new_grid[0])):
if possibile_grid_list[n][i][j] == 'A':
block_A[n].append((int(j), int(i)))
elif possibile_grid_list[n][i][j] == 'B':
block_B[n].append((int(j), int(i)))
elif possibile_grid_list[n][i][j] == 'C':
block_C[n].append((int(j), int(i)))
else:
continue
return block_A, block_B, block_C
print(*args)
DEBUG = False
HISTORY_THRESHOLD = 1000
Ntot = 20
N4 = 14
N3 = 2
N2 = 2
N1 = 2
startingUnified = [4]*N4 + [3]*N3 + [2]*N2 + [1]*N1
startingUnified = np.array(startingUnified, np.int8)
iterations = 0
max_moves = 0
for currentSet in multiset_permutations(startingUnified):
iterations = iterations+1
starting0 = currentSet[:Ntot//2]
starting1 = currentSet[Ntot//2:]
if iterations % 10000 == 0:
print("ITERATION:", iterations, starting0, starting1, max_moves)
max_moves = 0
#starting0 = [1, 3, 4, 2, 4, 2, 4, 4, 4, 4]
#starting1 = [4, 4, 3, 4, 1, 4, 4, 4, 4, 4]
#Start playing!
#0 always starts first
s0 = list(currentSet[:Ntot//2])
s1 = list(currentSet[Ntot//2:])
s = [s0, s1]
def blocks(self, filename):
'''
Depensing upon the data read from the bff file
Board, Number of A, B, C blocks, Lazor List, Holes
This block generates all the possible boards by permuting the list
of all movable blocks like o's, A's, B's, and C's
Each board so generated is first converted into a grid and then checked
with lazor solver function if the generated board is the solution for
the board so given, The maximum iterations possible and iterations so
performed are printed
** Parameters **
self - consists of all data (board, A_blocks, B_blocks, C_blocks .. )
** Returns **
Nothing!
'''
movable_blocks = []
for x in self.board:
for y in x:
if y == 'o':
movable_blocks.append(y)
for i in range(self.A):
movable_blocks[i] = 'A'
for i in range(self.A, (self.A + self.B)):
movable_blocks[i] = 'B'
for i in range((self.A + self.B), (self.A + self.B + self.C)):
movable_blocks[i] = 'C'
ITER_B = 0
b = "Loading"
print(b, end="\r")
t1 = time.time()
permutations = list(multiset_permutations(movable_blocks))
t2 = time.time()
print("Maximum possible iteration possible : ", len(permutations))
print("Time for generating grids: ", t2 - t1)
x = 0
b = "Loading"
print(b, end="\r")
t1 = time.time()
for permut in permutations:
sinks = copy.deepcopy(self.H)
actual_board = copy.deepcopy(self.grid)
possible_grid = create_grid(actual_board, permut)
ITER_B += 1
if lazor_path(possible_grid, self.L, sinks):
print("Congratulations!! Board Solved")
length = int((len(possible_grid) - 1) / 2)
width = int((len(possible_grid[0]) - 1) / 2)
for i in range(length):
for j in range(width):
print(possible_grid[2 * i + 1][2 * j + 1], end=' ')
print()
print(
"This is the solution grid! OR just check the pngimage so created!"
)
fname1 = filename.split(".bff")[0]
fname = fname1 + "_solution_textfile.txt"
f = open(fname, "w+")
f.write("The solution to your board is: \n")
for i in range(length):
for j in range(width):
f.write(possible_grid[2 * i + 1][2 * j + 1])
f.write(" ")
f.write("\n")
f.write("A is the reflect block, B is the absorb ")
f.write("block and C is the reflect block.\nThe o should ")
f.write("be empty. Try not to cheat next time :)")
f.close()
break
t2 = time.time()
if t2 - t1 >= 5:
t1 = time.time()
b = "Loading" + "." * x
print(b, end="\r")
if x == 3:
x = 0
x += 1
print("Iteration took to solve: ", ITER_B)
#-*-coding:utf8-*-
from sympy.utilities.iterables import multiset_permutations
import datetime
import numpy as np
a = np.array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'])
pat_list = []
start = datetime.datetime.now()
for i in range(1, len(a) + 1):
print(i)
for p in multiset_permutations(a, i):
pat_list.append(p)
end = datetime.datetime.now()
print((end - start).total_seconds())
def convexConcaveOptimization(self,x,Y,sample_weight,samp_counts):
random.seed()
self.counts = numpy.zeros((x.shape[0],))
if x.shape[0] > 0:
sample_idx = sample_weight > 0
sample_idx_ran = asarray(range(x.shape[0]))[sample_idx.reshape(-1)]
Y_tmp = Y[sample_idx.reshape(-1)]
x_tmp = csr_matrix(x[sample_idx.reshape(-1)],dtype=np.float32)
#sample X and Y
if self.sample_ratio*x.shape[0] > 10:
#idxs = random.permutation(x_tmp.shape[0])[:int(x_tmp.shape[0]*self.sample_ratio)]
idxs = randint(0, x_tmp.shape[0], int(x_tmp.shape[0]*self.sample_ratio)) #bootstrap
to_add_cnt = numpy.unique(sample_idx_ran[idxs])
x_ = csr_matrix(x_tmp[idxs],dtype=np.float32)
Y_ = Y_tmp[idxs]
diff_y = unique(Y_)
if diff_y.shape[0] > 1:
x_tmp = x_
Y_tmp = Y_
#print ("sampling shape:",diff_y.shape[0])
else:
to_add_cnt = sample_idx_ran
if not (samp_counts is None):
self.counts[to_add_cnt] += 1
def nu(arr):
return asarray([1 + unique(arr[:,i].data,return_counts=True)[1].shape[0] for i in range(arr.shape[1])])
#nonzero_idxs = unique(x_tmp.nonzero()[1])
counts_p = nu(csc_matrix(x_tmp))
pos_idx = where(counts_p > 1)[0]
fw_size = int(x_tmp.shape[1] * self.feature_ratio)
if fw_size > pos_idx.shape[0]:
fw_size = pos_idx.shape[0]
#fw_size = int(pos_idx.shape[0] * self.feature_ratio)
self.features_weight = random.permutation(pos_idx)[:fw_size]
if fw_size == 0:
return 0.
x_tmp = csr_matrix(x_tmp[:,self.features_weight],dtype=np.float32)
#print (x_tmp.shape,fw_size)
H = zeros(shape = (1,Y_tmp.shape[0]))
gini_res = 0
class_counts = unique(Y_tmp, return_counts=True)
class_counts = numpy.asarray(list(zip(class_counts[0],class_counts[1])))
class2side = {}
class2count = {}
side2count = {}
min_gini = self.max_criteria
min_p = []
if len(class_counts) > 13:
#Greedy
for _ in range(len(class_counts)*len(class_counts)*15):
lmin_gini = self.max_criteria
lmin_p = []
next = True
elements = [-1,+1]
probabilities = [0.5, 0.5]
p = numpy.random.choice(elements,len(class_counts) , p=probabilities)
zc = 0
while next:
next = False
zc += 1
for i in range(p.shape[0]):
p[i] = - p[i]
left_counts = class_counts[p < 0, 1]
right_counts = class_counts[p > 0, 1]
lcs = left_counts.sum()
rcs = right_counts.sum()
den = lcs + rcs
PL = float(lcs)/ den
PR = float(rcs)/ den
gini_l = self.criteria_row(left_counts / lcs)
gini_r = self.criteria_row(right_counts / rcs)
gini = PL*gini_l + PR* gini_r
if gini < lmin_gini:
lmin_p = deepcopy(p)
lmin_gini = gini
next = True
p = lmin_p
if lmin_gini < min_gini:
min_p = deepcopy(lmin_p)
min_gini = lmin_gini
else:
for zc in range(1,len(class_counts),1):
a = numpy.hstack([-numpy.ones((zc,)),numpy.ones((len(class_counts) - zc,))])
for p in multiset_permutations(a):
p = numpy.asarray(p)
left_counts = class_counts[p < 0, 1]
right_counts = class_counts[p > 0, 1]
lcs = left_counts.sum()
rcs = right_counts.sum()
den = lcs + rcs
PL = float(lcs)/ den
PR = float(rcs)/ den
gini_l = self.criteria_row(left_counts / lcs)
gini_r = self.criteria_row(right_counts / rcs)
gini = PL*gini_l + PR* gini_r
if gini < min_gini:
min_p = p
min_gini = gini
left_counts = numpy.asarray([c[1] for c in class_counts[min_p < 0]])
right_counts = numpy.asarray([c[1] for c in class_counts[min_p > 0]])
side2count[-1] = left_counts.sum()
side2count[1] = right_counts.sum()
for i,(cl,cnt) in enumerate(class_counts):
class2side[cl] = min_p[i]
H[0,Y_tmp == cl] = min_p[i]
class2count[cl] = cnt
gini_best = 0
gini_old = 0
for class_id, count_ in class_counts:
p = float(count_) / side2count[class2side[class_id]]
p2 = float(count_) / (side2count[-1] + side2count[1])
gini_old += self.criteria(p2)
gini_best += (float(side2count[class2side[class_id]])/ (side2count[-1] + side2count[1]))*self.criteria(p)
Hsize, IH,IY, gini_old_wise = self.getDeltaParams(H,Y_tmp, self.criteria)
gini_best = gini_old - gini_best
deltas = zeros(shape=(H.shape[1]))
#deltas = ones(shape=(H.shape[1]))
for i in range(H.shape[1]):
gini_i = self.delta_wise(Hsize, IH,IY,Y_tmp[i],-H[0,i],self.criteria)
deltas[i] = float(gini_i - gini_old_wise)
if self.balance:
deltas[i] = deltas[i] * float(H.reshape(-1).shape[0]) / (2*side2count[H[0,i]])
#deltas = deltas - deltas.min()
ratio = 1
dm = deltas.max()
if deltas.max() == 0:
deltas = ones(shape=(H.shape[1]))
else:
deltas = (deltas / dm)*ratio
#print ("deltas:",deltas.min(),deltas.max())
#start_time = time.time()
if self.noise > 0.:
#x_maxis = asarray(abs(x_tmp).max(axis=0).todense()).flatten()
gauss_noise = random.normal(ones((x_tmp.shape[1],),dtype=float),self.noise,(1,x_tmp.shape[1]))
x_tmp = csr_matrix(x_tmp.multiply(gauss_noise),dtype=np.float32)
#numpy.save("x_tmp",numpy.asarray(x_tmp.todense()))
#numpy.save("H",H.reshape(-1))
#numpy.save("deltas",deltas)
#time.sleep(10.0)
#return
try:
if self.kernel == 'linear':
if not self.dual:
self.model = SGDClassifier(n_iter_no_change=5,loss='squared_hinge', alpha=1. / (100*self.C), fit_intercept=True, max_iter=self.max_iter, tol=self.tol, eta0=0.5,shuffle=True, learning_rate='adaptive')
#self.model = LinearSVC(penalty='l2',dual=self.dual,tol=self.tol,C = self.C,max_iter=self.max_iter)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
else:
self.model = LinearSVC(penalty='l2',dual=self.dual,tol=self.tol,C = self.C,max_iter=self.max_iter)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
#else:
if self.kernel == 'polynomial':
self.model = SVC(kernel='poly',tol=self.tol,C = self.C,max_iter=self.max_iter,degree=4,gamma=self.gamma)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
else:
if self.kernel == 'gaussian':
self.model = SVC(kernel='rbf',tol=self.tol,C = self.C,max_iter=self.max_iter,gamma=self.gamma)#,gpu_id=1,max_mem_size=128)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
#numpy.save("vertexDataX",x_tmp.data)
#numpy.save("vertexIndX",x_tmp.indices)
#numpy.save("vertexPtrX",x_tmp.indptr)
#numpy.save("DataH",H)
#numpy.save("deltas",deltas)
#self.classifier_id = str(uuid.uuid4())
#with open('shape.pickle', 'wb') as f:
# pickle.dump(x_tmp.shape, f)
#if self.kernel == 'gaussian':
# kernel_ = 'rbf'
#else:
# kernel_ = 'linear'
#p = subprocess.Popen("python train.py " + self.classifier_id + " " + kernel_, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
#p.wait()
#self.model = SVC(kernel='rbf',tol=self.tol,C = self.C,max_iter=self.max_iter,gamma=self.gamma,gpu_id=1)
#self.model.load_from_file(".model")
except Exception as exp:
print (str(exp))
return 0.
#print(1,unique(H),unique(Y_tmp,return_counts = True),accuracy_score(self.model.predict(x_tmp),H.reshape(-1)))
#end_time = time.time()
#print ("Fit 1") #, end_time - start_time,"div:",side2count,"delta_uniques:",unique(deltas))
if self.dropout_low > 0 or self.dropout_high < 1.:
#coeffs = np.abs(self.model.coef_).flatten()
#max_coeff = coeffs.max()
#if max_coeff > 0:
# coeffs = coeffs / max_coeff
#den = np.exp(self.dropout_low*coeffs)
#p = den / den.sum()
#remain_idxs = np.random.choice(len(coeffs), size=len(coeffs), replace=True, p=p)
max_coef = np.abs(self.model.coef_).max()
remain_idxs = ((np.abs(self.model.coef_) >= max_coef * self.dropout_low) & (np.abs(self.model.coef_) <= max_coef * self.dropout_high)).flatten()
#print ("old feat size: ", self.features_weight.shape[0])
#if self.features_weight[remain_idxs].shape[0] < 1:
# remain_idxs = np.asarray([np.argmax(np.abs(self.model.coef_.flatten()), axis = 0)])
self.features_weight = self.features_weight[remain_idxs]
#print ("new feat size: ", self.features_weight.shape[0])
x_tmp = x_tmp[:,remain_idxs]
if self.kernel == 'linear':
if not self.dual:
self.model = SGDClassifier(n_iter_no_change=5,loss='squared_hinge', alpha=1. / (100*self.C), fit_intercept=True, max_iter=self.max_iter, tol=self.tol, eta0=0.5,shuffle=True, learning_rate='adaptive')
#self.model = LinearSVC(penalty='l2',dual=self.dual,tol=self.tol,C = self.C,max_iter=self.max_iter)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
#coef_tmp = self.model.coef_[0,remain_idxs].reshape(1,-1)
#self.model.coef_ = coef_tmp
else:
self.model = LinearSVC(penalty='l2',dual=self.dual,tol=self.tol,C = self.C,max_iter=self.max_iter)
self.model.fit(x_tmp,H.reshape(-1),sample_weight=deltas)
else:
if self.kernel == 'polynomial':
self.model = SVC(kernel='poly',tol=self.tol,C = self.C,max_iter=self.max_iter,degree=3,gamma=self.gamma)
self.model.fit(x_tmp,H.reshape(-1),sample_weights=deltas)
else:
if self.kernel == 'gaussian':
self.model = SVC(kernel='rbf',tol=self.tol,C = self.C,max_iter=self.max_iter,gamma=self.gamma)
self.model.fit(x_tmp,H.reshape(-1),sample_weights=deltas)
#print ("Fit 2")
gini_res = self.calcGini(x,Y)
#print (gini_res,"|",gini_best)
self.estimateTetas(x_tmp, Y_tmp)
self.p0 = zeros(shape=(self.class_max + 1))
self.p1 = zeros(shape=(self.class_max + 1))
sum_t0 = self.Teta0.sum()
sum_t1 = self.Teta1.sum()
if sum_t0 > 0:
p0_ = multiply(self.Teta0, 1. / sum_t0)
for i in range(len(p0_)):
self.p0[self.class_map_inv[i]] = p0_[i]
#exp_0 = exp(self.p0)
#self.p0 = exp_0 / exp_0.sum()
if sum_t1 > 0:
p1_ = multiply(self.Teta1, 1. / sum_t1)
for i in range(len(p1_)):
self.p1[self.class_map_inv[i]] = p1_[i]
#exp_1 = exp(self.p1)
#self.p1 = exp_1 / exp_1.sum()
self.counts = numpy.hstack([samp_counts,self.counts])
return gini_res
def Ceq_search(
d,
nev,
b=True,
ref=True,
f=False,
spec=False,
tol=1e-13,
info=False):
# Turn off reflection relation if 3d
if len(d) == 3:
ref = True
# Generate inidicator arrays
print('...Generating indicator arrays')
Ss = gS(d, nev, sh=False).flatten()[1:]
Ss = np.array(list(multiset_permutations(Ss)))
nSs = len(Ss)
Ss = np.hstack([
np.ones([nSs, 1], dtype=np.int), Ss
])
Ss = Ss.reshape([nSs] + list(d))
# Compute correlations
print('...Computing correlations')
temp = rCs(Ss[0], f=f, spec=spec)
C = np.zeros([nSs] + list(temp.shape))
C[0] = temp
for i in range(1, nSs):
if info:
print('...Computing correlations - %i / %i = %.4f' %
(i + 1, nSs, (i + 1) / nSs))
C[i] = rCs(Ss[i], f=f, spec=spec)
# Search for cases
print('...Searching for cases')
i = 0
out = []
def unrelloc(i1, i2): return not rel(Ss[i1], Ss[i2], ref)
while i < nSs:
if info:
print('...Searching for cases - %i / %i = %.4f' %
(i + 1, nSs, (i + 1) / nSs))
Ci = C[i]
if f:
cand = np.where([np.linalg.norm(Ci - CC) < tol for CC in C])[0]
else:
cand = np.array(
[j for j in range(i + 1, nSs) if np.all(Ci == C[j])])
if len(cand) > 0:
Si = Ss[i]
check = [not rel(Si, Ss[c], ref) for c in cand]
cand = cand[check]
if len(cand) > 0:
cand = unrelmax(np.array(cand), unrelloc)
event = np.zeros([1 + len(cand)] + d, dtype=np.int)
event[0] = Si
for j in range(len(cand)):
event[j + 1] = Ss[cand[j]]
out.append(event)
if isinstance(b, type(True)):
if b:
break
if isinstance(b, type(1)):
if len(out) == b:
break
i += 1
if len(out) > 1:
def unrelloc(i1, i2): return not rel(out[i1][0], out[i2][0], ref)
cand = unrelmax(np.array(list(range(len(out)))), unrelloc)
for j in range(1, len(out[0])):
cand = np.array([c for c in cand if not rel(out[0][j], out[c][0])])
if len(cand) > 1:
out = [out[c] for c in cand]
else:
out = [out[0]]
print('...Number of structure sets: %i' % len(out))
return out
def get_best_perm(Ca, Ce, Ua, Ue, N):
clone_idxs = [x for x in range(0, N)]
perms = [p for p in multiset_permutations(clone_idxs)]
perms = get_perms_best_C_score(Ca, Ce, perms)
perm = get_perm_best_U_score(Ua, Ue, perms)
return perm
def test_nC_nP_nT():
from sympy.utilities.iterables import (
multiset_permutations, multiset_combinations, multiset_partitions,
partitions, subsets, permutations)
from sympy.functions.combinatorial.numbers import (
nP, nC, nT, stirling, _multiset_histogram, _AOP_product)
from sympy.combinatorics.permutations import Permutation
from sympy.core.numbers import oo
from random import choice
c = string.ascii_lowercase
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(8):
check = nP(s, i)
tot += check
assert len(list(multiset_permutations(s, i))) == check
if u:
assert nP(len(s), i) == check
assert nP(s) == tot
except AssertionError:
print(s, i, 'failed perm test')
raise ValueError()
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(8):
check = nC(s, i)
tot += check
assert len(list(multiset_combinations(s, i))) == check
if u:
assert nC(len(s), i) == check
assert nC(s) == tot
if u:
assert nC(len(s)) == tot
except AssertionError:
print(s, i, 'failed combo test')
raise ValueError()
for i in range(1, 10):
tot = 0
for j in range(1, i + 2):
check = nT(i, j)
tot += check
assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
assert nT(i) == tot
for i in range(1, 10):
tot = 0
for j in range(1, i + 2):
check = nT(range(i), j)
tot += check
assert len(list(multiset_partitions(range(i), j))) == check
assert nT(range(i)) == tot
for i in range(100):
s = ''.join(choice(c) for i in range(7))
u = len(s) == len(set(s))
try:
tot = 0
for i in range(1, 8):
check = nT(s, i)
tot += check
assert len(list(multiset_partitions(s, i))) == check
if u:
assert nT(range(len(s)), i) == check
if u:
assert nT(range(len(s))) == tot
assert nT(s) == tot
except AssertionError:
print(s, i, 'failed partition test')
raise ValueError()
# tests for Stirling numbers of the first kind that are not tested in the
# above
assert [stirling(9, i, kind=1) for i in range(11)] == [
0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
perms = list(permutations(range(4)))
assert [sum(1 for p in perms if Permutation(p).cycles == i)
for i in range(5)] == [0, 6, 11, 6, 1] == [
stirling(4, i, kind=1) for i in range(5)]
# http://oeis.org/A008275
assert [stirling(n, k, signed=1)
for n in range(10) for k in range(1, n + 1)] == [
1, -1,
1, 2, -3,
1, -6, 11, -6,
1, 24, -50, 35, -10,
1, -120, 274, -225, 85, -15,
1, 720, -1764, 1624, -735, 175, -21,
1, -5040, 13068, -13132, 6769, -1960, 322, -28,
1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
# http://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
assert [stirling(n, k, kind=1)
for n in range(10) for k in range(n+1)] == [
1,
0, 1,
0, 1, 1,
0, 2, 3, 1,
0, 6, 11, 6, 1,
0, 24, 50, 35, 10, 1,
0, 120, 274, 225, 85, 15, 1,
0, 720, 1764, 1624, 735, 175, 21, 1,
0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
# http://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
assert [stirling(n, k, kind=2)
for n in range(10) for k in range(n+1)] == [
1,
0, 1,
0, 1, 1,
0, 1, 3, 1,
0, 1, 7, 6, 1,
0, 1, 15, 25, 10, 1,
0, 1, 31, 90, 65, 15, 1,
0, 1, 63, 301, 350, 140, 21, 1,
0, 1, 127, 966, 1701, 1050, 266, 28, 1,
0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
raises(ValueError, lambda: stirling(-2, 2))
def delta(p):
if len(p) == 1:
return oo
return min(abs(i[0] - i[1]) for i in subsets(p, 2))
parts = multiset_partitions(range(5), 3)
d = 2
assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
stirling(5, 3, d=d) == 7)
# other coverage tests
assert nC('abb', 2) == nC('aab', 2) == 2
assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
assert nP(3, 4) == 0
assert nP('aabc', 5) == 0
assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
len(list(multiset_combinations('aabbccdd', 2))) == 10
assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
assert nC(list('abcdd'), 4) == 4
assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
assert nC('aabb'*3, 3) == 4 # aaa, bbb, abb, baa
assert dict(_AOP_product((4,1,1,1))) == {
0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
# the following was the first t that showed a problem in a previous form of
# the function, so it's not as random as it may appear
t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
raises(ValueError, lambda: _multiset_histogram({1:'a'}))
def get_full_basis(self):
assert (self.nspin <= 20), "basis too large, use rand_basis instead"
ref_state = np.concatenate([np.ones(self.num_spinup), -np.ones(self.num_spindown)]).astype(int)
np_output = np.array(list(multiset_permutations(ref_state)))
return th.tensor(np_output,dtype=self.dtype,device = self.device)
def m_perms(l: List):
if l:
return multiset_permutations(l)
else:
return [()]
[2, 3, 0, -1, 0], [2, 3, 1, -1, 0],
[2, 0, 0, 0, 0], [2, 0, 0, -1, 0],
[2, 0, 0, 0, -1], [2, 0, 0, -1, -1],
[2, 1, 0, 0, 0], [2, 1, 1, 0, 0],
[2, 1, 0, 0, -1], [2, 1, 1, 0, -1],
[3, 2, 0, 0, 0], [3, 2, -1, 0, 0],
[3, 2, 0, 1, 0], [3, 2, -1, 1, 0],
[3, 1, 0, 0, 0], [3, 1, 0, 1, 0],
[3, 1, 0, 0, -1], [3, 1, 0, 1, -1],
[3, 0, 0, 0, 0], [3, 0, -1, 0, 0],
[3, 0, 0, 0, -1], [3, 0, -1, 0, -1]])
# occupancies (there will be 70^4 = 24.01 million of these!)
c0 = np.array([0, 0, 0, 0, 1, 1, 1, 1])
pc0 = np.array(list(multiset_permutations(c0))).reshape(70, 2, 2, 2)
c1 = np.array([2, 2, 2, 2, 3, 3, 3, 3])
pc1 = np.array(list(multiset_permutations(c1))).reshape(70, 2, 2, 2)
c2 = np.array([4, 4, 4, 4, 5, 5, 5, 5])
pc2 = np.array(list(multiset_permutations(c2))).reshape(70, 2, 2, 2)
c3 = np.array([6, 6, 6, 6, 7, 7, 7, 7])
pc3 = np.array(list(multiset_permutations(c3))).reshape(70, 2, 2, 2)
bond_energies = np.array([[0., 1., 2., 3., 4., 6., 7., 5.],
[0., 0., 7., 7., 4., 4., 3., 4.],
[0., 0., 0., 1., 1., 6., 3., 6.],
[0., 0., 0., 0., 2., 7., 7., 8.],
[0., 0., 0., 0., 0., 2., 5., 3.],
def lazors_cheat(filename):
"""
Takes a .bff file for a Lazor puzzle (containing only block types reflect,
opaque, and refract) and solves it. Then creates a .png solution that shows
where to put each block
**Parameters**
filename: *string*
The .bff file that contains all the Lazor information.
Can contain .bff or not
**Returns**
None
"""
# Checks for if the file name contains '.bff'' or not
if ".bff" in filename:
filename = filename.split(".bff")[0]
# Read the .bff file and extract the information
information = laser_board_reader(filename=filename + '.bff')
grid = information[0]
[A, B, C] = information[1]
laser_origin = information[2]
targetPos = information[3]
# Seting up block locations
# 1. Pull out block locations from grid
blockspots = []
for y in grid:
for x in y:
if x is 'o':
blockspots.append(x)
# 2. Assign types of block to list of grid locations
for i in range(A):
blockspots[i] = 'A'
for i in range(A, (A + B)):
blockspots[i] = 'B'
for i in range((A + B), (A + B + C)):
blockspots[i] = 'C'
# 3. Get all permutations of block locations for a given grid and number of each
# type of block
permutations = list(multiset_permutations(blockspots))
length = len(grid)
width = len(grid[0])
# Algorithm for solving: Create a list of all possible combinations of the
# lists containging possible block positions and run them individually until
# finding a solution
print("%i possible solutions." % len(permutations))
print("Solving...")
SOLUTION_FOUND = False
for possibility in permutations:
# Create a working grid that reads the information of the block location
# inside each possibility of the permutations by looping through the array
# replacing 'o's with the blocks
workinggrid = copy.deepcopy(grid)
for l in range(length):
for w in range(width):
if workinggrid[l][w] == 'o':
workinggrid[l][w] = possibility.pop(0)
if laser_runner(workinggrid, laser_origin, targetPos):
print("Solution found!")
save_grid(workinggrid, name="%s_solution.png" % filename)
SOLUTION_FOUND = True
break
if not SOLUTION_FOUND:
print(
'''Solution not found. Please double check .bff file is correct''')
"е": "e",
"о": "o",
"а": "a",
"с": "c",
"А": "A",
"О": "O",
"Е": "E",
"С": "C",
}
string_dict = {}
all_symbols = np.array([])
string = "1. Физические явления и процессы в об.. 11:50-13:20\nНизамов А.Ж."
all_combs_list = []
for i in range(len(string)):
if string[i] in d:
all_symbols = np.append(all_symbols, i)
i = 0
for p in multiset_permutations(all_symbols.astype(int)):
i += 1
#buf_string = list(string)
#for element in p:
# buf_string[element] = d[buf_string[element]]
# string_dict["".join(buf_string)] = None
print(i)
#print(len(string_dict))
#for key in string_dict:
# print(key)
def permutate(self, l): #you might have to make this a generator
return [i for i in multiset_permutations(l)]
pass #take in necessary objs and their corresponding prob via zip. #create permutations (this could possibly be the first step). use build ftns above to create one_hot_vecs
def compute_elementary_contractions_half_cumulant(pure_ops_list, max_cu):
"""
Generate all possible combinations of pure creation and annihilation operators for cumulant contractions.
:param pure_ops_list: a list of pure creation or annihilation indices for each input operator
:param max_cu: the max level of cumulants
:return: {cumulant level: [[n_cumulant of chosen indices (op index, relative index)], ...]}
Consider the following list of pure cre/ann operators: pure_ops_list = [[a, b], [c, d], [e, f, g]]
and we want to obtain 2, 3, 4 cumulants, i.e., max_cu = 4.
Note that there are three macro operators: [a, b], [c, d], [e, f, g]
and the first macro operator has two micro operators: a, b
This function will do the following:
(1) generate all unique integer partitions of 2, 3, and 4, i.e, partition legs for k cumulant
2 = 1 + 1 # note a)
3 = 2 + 1 = 1 + 1 + 1 # note b)
4 = 3 + 1 = 2 + 2 = 2 + 1 + 1 # note c)
Note:
a) single partition is included, e.g, [2] is valid
a) only unique partitions, e.g., 1 + 2 is ignored
b) len(pure_ops_list) = 3 => number of partitions must <= 3
(2) generate all possible sub-indices for each macro operator in pure_ops_list
and return [{n_leg: [relative indices of the current string of cre/ann operators]}, ...]
for the example, we should get:
[{1: [(0,), (1,)], 2: [(0, 1)]},
{1: [(0,), (1,)], 2: [(0, 1)]},
{1: [(0,), (1,), (2,)], 2: [(0, 1), (0, 2), (1, 2)], 3: [(0, 1, 2)]}]
(3) loop over integer partitions and choose the corresponding sub-indices partitions
for example,
=> 2 + 1, i.e, select 2 legs from one macro operator and 1 leg from one of the others
=> consider multiset permutations, 2 + 1 = 1 + 2. another example: 2 + 1 + 1 = 1 + 2 + 1 = 1 + 1 + 2
=> choose 2 macro operators from the given three
=> say we choose the first two macro operators, where the first contributes two legs:
that is, [(0, 1)] from the first macro operator, [(0,), (1,)] from the second macro operator
=> generate all possible selections by a nested loop
=> cartesian product between [(0, 1)] and [(0,), (1,)], i.e., a nested loop
=> combine with macro operator index and get [(0, 0), (0, 1), (1, 0)], [(0, 0), (0, 1), (1, 1)]
"""
results = {i: [] for i in range(2, max_cu + 1)}
# generate all possible unique partitions for k cre/ann legs for k cumulant
macro_size = len(pure_ops_list)
unique_partitions = [
part for k in range(2, max_cu + 1) for part in integer_partition(k)
if len(part) <= macro_size
]
# generate all possible sub-indices for each macro operator
sub_indices = [{
n_leg: [ele_ops for ele_ops in combinations(range(ops.size), n_leg)]
for n_leg in range(1,
min(max_cu, ops.size) + 1)
} for ops in pure_ops_list]
for unique_partition in unique_partitions:
n_macro = len(unique_partition)
cu_level = sum(unique_partition)
for leg_part in multiset_permutations(unique_partition):
# choose n_macro from ops_list
for macro_ops in combinations(range(macro_size), n_macro):
# check if this partition is valid on these chosen macro operators
if any([
len(pure_ops_list[i]) < n_leg
for i, n_leg in zip(macro_ops, leg_part)
]):
continue
# generate all possibilities
for micro_ops_pro in product(*[
sub_indices[i][n_leg]
for i, n_leg in zip(macro_ops, leg_part)
]):
results[cu_level].append([
(i_macro, i_micro)
for i_macro, micro_ops in zip(macro_ops, micro_ops_pro)
for i_micro in micro_ops
])
return results
else:
memory[paramThree] = 0
if jumped == False:
pc = pc + length
instructionRead = int(memory[pc])
return prgOutput
file = open('input.txt', 'r')
for line in file:
origPrg = line.split(',')
phaseSettings = list(multiset_permutations([0, 1, 2, 3, 4]))
maxSignal = 0
for phaseSetting in phaseSettings:
prg = origPrg.copy()
output = intcodeVM(prg, phaseSetting[0], 0)
prg = origPrg.copy()
output = intcodeVM(prg, phaseSetting[1], output)
prg = origPrg.copy()
output = intcodeVM(prg, phaseSetting[2], output)
prg = origPrg.copy()
output = intcodeVM(prg, phaseSetting[3], output)
prg = origPrg.copy()
output = intcodeVM(prg, phaseSetting[4], output)
if output > maxSignal:
def test():
for i in range(1, 7):
print(i)
for p in multiset_permutations([0, 0, 1, 0, 1], i):
print(p)
# -*- coding: utf-8 -*-
def computeExprTreeComplete(cur_strat, other_strat, ordered_groups, N):
"""
Compute the expression of a strategy against another strategy, knowing that their action vary over time
:param cur_strat: current strategy
:param other_strat: opponent strategy
:param ordered_groups: combination of all possible groups of size (N-1) of cur_strat and other_strat
:param N: size of the group
:return: array of expressions for each combination of the groups
"""
nb_states = len(cur_strat[2:])
expr_all_opponent_nb = []
for i in range(
N - 1
): #Only against one same strat up to N-1 in group of N containing opponent strat
#print("loop ", i)
strat_loop = time.time()
opponents = i * [0] + (N - 1 - i) * [1]
groups_comb = list(multiset_permutations(opponents))
#print(len(groups_comb))
#groups = ordered_groups[i]
expr_groups = 0.
for group in groups_comb:
expr_all_states = 0.
for state in range(nb_states):
root = Tree(state, cur_strat, 1)
if group[0] == 1: #If first element has the opponent strat
root.buildExprVariableActionsStrat(other_strat)
root.addChildrenVariableAction(other_strat)
else:
root.buildExprVariableActionsStrat(cur_strat)
root.addChildrenVariableAction(cur_strat)
current_level = root.getChildren()
expr_state_config = root.getExpr()
for j in range(1, N - 1):
if group[j] == 1:
next_level = []
for child in current_level:
child.buildExprVariableActionsStrat(other_strat)
child.addChildrenVariableAction(other_strat)
expr_state_config += child.getExpr()
for new_child in child.getChildren():
next_level.append(new_child)
current_level = list(next_level)
else:
next_level = []
for child in current_level:
child.buildExprVariableActionsStrat(cur_strat)
child.addChildrenVariableAction(cur_strat)
expr_state_config += child.getExpr()
for new_child in child.getChildren():
next_level.append(new_child)
current_level = list(next_level)
# expr_state_config /= N-1 #in comment because I want the total payoff expression after N rounds
expr_all_states += expr_state_config
expr_all_states /= nb_states
expr_groups += expr_all_states
expr_groups /= len(
groups_comb
) #Avg expression of strategy A against group of A/B's of size N-1 with i B's in it
expr_all_opponent_nb.append(expr_groups)
print("Loop computeExprTreeComplete ", i, " of ", N - 1,
" computed in --- %s seconds --- " % (time.time() - strat_loop))
return expr_all_opponent_nb
def q_instability_psi(n_qubits, n_ones):
# from Phys. Rev. A 79, 022302 , eq. 4
S = lambda k, l: np.sqrt(2 /
(n_qubits + 1)) * np.sin(np.pi * (k + 1) *
(l + 1) / (n_qubits + 1))
## generate unnormalized dicke state with (n_qubits, k).
n_zeros = n_qubits - n_ones
# initialize vector with n_zeros of zeros and n_ones of ones
zeros_int = [0 for _ in range(n_zeros)]
ones_int = [1 for _ in range(n_ones)]
statevector_init_int = zeros_int + ones_int
# generate all permutations
statevect_permutations_int = multiset_permutations(statevector_init_int)
# generate a list of combinations of flipped spin locations for a given number of spins
ls = [list(np.nonzero(row)[0]) for row in list(statevect_permutations_int)]
ls = np.array(ls)
# generate a permutation group for number of spins
#ks = list(multiset_permutations(list(range(n_ones))))
ks = list(generate_bell(n_ones))
ks = np.array(ks)
# construct pairs of ks and ls
clist = []
for llist in ls:
# llist goes in the subscript of C (so C_(llist))
c = 0
for j, klist in enumerate(ks):
# j = permutation number
# klist = ks[j] = member of the permuation group of k
# = P_j(ks)
cterm = (-1)**(j + 1)
for i in range(len(klist)):
k, l = klist[i], llist[i]
cterm *= S(k, l)
c += cterm
clist += [c]
zeros = ["0" for _ in range(n_zeros)]
ones = ["1" for _ in range(n_ones)]
statevector_init = zeros + ones
# generate all permutations
statevect_permutations = multiset_permutations(statevector_init)
# join the string of 0s and 1s, convert it to an integer from base 2,
# these will be the locations of nonzero probabilities
positiveproblocations = [
int("".join(vect_permutation), 2)
for vect_permutation in statevect_permutations
]
# generate XX state
q_instability_state = [0.] * 2**n_qubits
for i, loc in enumerate(positiveproblocations):
q_instability_state[loc] = clist[i]
# normalize
q_instability_state = np.array(q_instability_state)
q_instability_state /= norm(q_instability_state)
return q_instability_state
down = lst[i + L]
if right == x:
total_pen += 1
if up == x:
total_pen += 1
if left == x:
total_pen += 1
if down == x:
total_pen += 1
return total_pen
colors = ['R'] * 13 + ['B'] * 12
L = 5
combi_list = multiset_permutations(colors, L * L)
best_combi, best_penalty = None, L * L * 4
for combi in combi_list:
pen = calc_penalty(combi)
if pen < best_penalty:
best_combi = combi
best_penalty = pen
print("Best: {}, pen: {}".format(best_combi, best_penalty))
if best_penalty == 0:
break
square_grid = pd.DataFrame('-', index=list(range(L)), columns=list(range(L)))
for i in range(len(best_combi)):
color = best_combi[i]
col = i % L
row = int(i / L)
def test_multiset_permutations():
assert [''.join(i) for i in (list(multiset_permutations('baby')))] == [
'abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab',
'byba', 'yabb', 'ybab', 'ybba']
#print(RSS(res.x,TOL))
#print(RSS(err1,TOL))
return err1, errE, x0, BS
#%%
#################################################
################################################################
################################################################################
from sympy.utilities.iterables import multiset_permutations
l = list(multiset_permutations([1, 1, 1, 1, 0, 0, 0, 0]))
print(l)
original = np.zeros(8)
results = np.zeros(8)
cn = 0
for p in l:
print("%2.f%%\r" % (cn / len(l) * 100))
err1, errE, x0, BS = all(TOL, p)
count = 0
arr = np.zeros(8)
ori = np.zeros(8)
for i in range(len(p)):
if p[i] == 0:
arr[i] = errE[count]
for p in p_set:
#hamming distances of ith for all other P'
D_i = torch.stack([(p != p_prime) for p_prime in P_[1:, :].t()],
dim=1).sum(dim=0).view(1, -1).type(
torch.FloatTensor).to(device=device)
D = torch.cat((D, D_i)).to(device=device)
D = D.sum(dim=0).view(1, -1).to(device=device)
j = P_[0, torch.argmax(D).item()].item(
) #first row of P_ is index checking which indexed perm is max
return int(j)
set_p = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
P_ = torch.stack([torch.FloatTensor(p) for p in multiset_permutations(set_p)],
dim=1).to(device=device)
_, perm_size = P_.shape
idx = torch.arange(perm_size).type(torch.FloatTensor).view(
1, -1).to(device=device)
P_ = torch.cat((idx, P_))
p_set = torch.Tensor().to(device=device)
j = np.random.choice(perm_size)
i = 0
checkpoint = 1
cardinality = 110
while i <= cardinality:
def main(experiment_path, load_path, data_path, loss_type, freqloss, optimizer,
upsampling_mode, model_type, blocktype, space, weight_init,
init_criterion, learning_rate, weight_decay, momentum, alpha, eps,
beta1, beta2, clip, stochastic_drop, dropcopy, real_penalty,
imag_penalty, efficient, bottleneck, schedule, nonesterov,
rmspop_momentum, nopil, avg_copies, stochdrop_schedule, nb_resblocks,
growth_rate, start_fmaps, epochs, batch_size, n_sources,
print_interval, seed, nb_copies, **kwargs):
# First thing we check is to see if we should load a prexisting model.
if load_path:
load_path = os.path.join(experiment_path, load_path)
chkptFilename = os.path.join(experiment_path, 'checkpoint.pth.tar')
isResuming = os.path.isfile(chkptFilename) or load_path
if isResuming and (not load_path):
load_path = chkptFilename
# If experiment path is not created, we create it.
if not os.path.isdir(experiment_path):
os.mkdir(experiment_path)
print('...preparing dataset')
trainset = WSJ2MReader(data_path, 'train', random_seed=seed)
devset = WSJ2MReader(data_path, 'dev', random_seed=seed)
print('...number of training utterances {}'.format(trainset.n_examples))
print('...number of dev utterances {}'.format(devset.n_examples))
bptt_len = None
train_stream = trainset.read(batch=batch_size,
sortseq=False,
normalize=False,
bptt_len=bptt_len)
dev_stream = devset.read(batch=batch_size,
sortseq=False,
normalize=False,
bptt_len=bptt_len)
print('...building model')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_type == 'complexunet':
model = ComplexUNet(in_channels=1,
nb_speakers=2,
mode=upsampling_mode,
nb_residual_blocks=nb_resblocks,
start_fmaps=start_fmaps,
blocktype=blocktype,
growth_rate=growth_rate,
space=space,
seed=seed,
weight_init=weight_init,
init_criterion=init_criterion,
efficient=efficient,
bottleneck=bottleneck,
nb_copies=nb_copies,
avg_copies=avg_copies,
stochastic_drop=stochastic_drop,
stochdrop_schedule=stochdrop_schedule,
dropcopy=dropcopy).to(device)
print(model)
if torch.cuda.device_count() > 1:
print('...multi-gpu training')
model = DataParallel(model)
# loss function
print('...define loss function')
if freqloss is None:
if loss_type == 'specl2loss':
maskloss = SequenceLoss(nb_speakers=n_sources, pil=nopil)
elif loss_type == 'speccosloss':
maskloss = CosLoss(real_penalty=real_penalty,
imag_penalty=imag_penalty,
nb_speakers=n_sources,
pil=nopil)
elif loss_type in {'istftl2loss', 'istftcosloss'}:
maskloss = ISTFTLoss(nb_speakers=n_sources,
pil=nopil,
loss_type=loss_type)
else:
print("USING TIME FREQUENCY LOSS!")
if loss_type in {'istftl2loss', 'istftcosloss'
} and freqloss in {'specl2loss', 'speccosloss'}:
maskloss = ISTFTLoss(nb_speakers=n_sources,
pil=nopil,
loss_type=loss_type,
frequencyloss=freqloss,
real_penalty=real_penalty,
imag_penalty=imag_penalty)
else:
raise Exception(
"When a frequency loss is used it should be used along with a loss on the temporal signal."
+ "Found freqloss == " + str(freqloss) + " and loss_type == " +
str(loss_type) + ".")
maskloss = maskloss.to(device)
# optimizer
print('...define optimizer')
if optimizer == 'adam':
optimizer = Adam(filter(lambda p: p.requires_grad, model.parameters()),
lr=learning_rate,
weight_decay=weight_decay,
betas=(beta1, beta2),
eps=eps)
elif optimizer == 'sgd':
optimizer = SGD(filter(lambda p: p.requires_grad, model.parameters()),
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay,
nesterov=nonesterov)
elif optimizer == 'rmsprop':
rmsmom = momentum if rmspop_momentum else 0
optimizer = RMSprop(filter(lambda p: p.requires_grad,
model.parameters()),
lr=learning_rate,
alpha=alpha,
eps=eps,
weight_decay=weight_decay,
momentum=rmsmom)
# initialize training arguments
start_epoch = 0
start_i = 0
bestloss = np.inf
best_epoch = 0
best_iter = 0
training_losses = []
validation_losses = []
trainCost = []
devSDR, devSIR, devSAR = [], [], []
params_num = 0
best_devSDR = 0.
# perform the loading if we need to do it
if load_path:
if os.path.isfile(load_path):
print("=> loading checkpoint '{}'".format(load_path))
checkpoint = torch.load(load_path)
for k in checkpoint.keys():
if k not in [
'optimizer', 'training_losses', 'validation_losses',
'training_losses', 'train_reader', 'model_state_dict'
]:
print(" " + str(k) + ": " + str(checkpoint[k]))
start_epoch = checkpoint['start_epoch']
clip = checkpoint['clip']
schedule = checkpoint['schedule']
epochs = checkpoint['epochs']
batch_size = checkpoint['batch_size']
print_interval = checkpoint['print_interval']
best_devSDR = checkpoint['bestSDR']
best_epoch = checkpoint['best_epoch']
trainCost = checkpoint['training_losses']
devSDR = checkpoint['devSDR']
devSIR = checkpoint['devSIR']
devSAR = checkpoint['devSAR']
trainset = checkpoint['train_reader']
devset = checkpoint['dev_reader']
maskloss = checkpoint['maskloss']
optimizer.load_state_dict(checkpoint['optimizer'])
model.load_state_dict(checkpoint['model_state_dict'])
else:
print("=> no checkpoint found at '{}'".format(load_path))
m = model.module if isinstance(model, DataParallel) else model
print(" loss_type: " + str(maskloss.loss_type))
if maskloss.loss_type == 'speccosloss':
print(" real_penalty: " + str(maskloss.real_penalty))
print(" imag_penalty: " + str(maskloss.imag_penalty))
print(" PIL: " + str(maskloss.pil))
print(" maskloss: " + str(maskloss.modules))
print(" optimizer: " + str(optimizer.__module__))
print(" upsampling_mode " + str(m.mode))
print(" model_type " + str(model_type))
print(" weight_init " + str(m.weight_init))
print(" init_criterion " + str(m.init_criterion))
if isinstance(m, ComplexUNet):
print(" space " + str(m.space))
print(" blocktype " + str(m.blocktype))
print(" nb_copies " + str(m.nb_copies))
print(" avg_copies " + str(m.avg_copies))
print(" stochastic_drop " + str(m.stochastic_drop))
print(" stochdrop_schedule " + str(m.stochdrop_schedule))
print(" nb_residual_blocks " + str(m.nb_residual_blocks))
print(" dropcopy " + str(m.dropcopy))
if m.blocktype in {'dense'}:
print(" growth_rate " + str(m.growth_rate))
if m.space == 'real':
print(" efficient " + str(m.efficient))
print(" bottleneck " + str(m.bottleneck))
print(" start_fmaps " + str(m.start_fmaps))
print(" learning_rate " +
str(optimizer.param_groups[0]['lr']))
print(" weight_decay " +
str(optimizer.param_groups[0]['weight_decay']))
if isinstance(optimizer, SGD):
print(" nesterov " +
str(optimizer.param_groups[0]['nesterov']))
print(" momentum " +
str(optimizer.param_groups[0]['momentum']))
elif isinstance(optimizer, RMSprop):
print(" alpha " +
str(optimizer.param_groups[0]['alpha']))
print(" rms_momentum " +
str(optimizer.param_groups[0]['momentum']))
print(" eps " +
str(optimizer.param_groups[0]['eps']))
elif isinstance(optimizer, Adam):
print(" beta1 " +
str(optimizer.param_groups[0]['betas'][0]))
print(" beta2 " +
str(optimizer.param_groups[0]['betas'][1]))
print(" eps " +
str(optimizer.param_groups[0]['eps']))
print(" clip: " + str(clip))
print(" schedule " + str(schedule))
print(" start_epoch: " + str(start_epoch))
print(" epochs: " + str(epochs))
print(" print_interval: " + str(print_interval))
print(" batch_size: " + str(batch_size))
print(" nb_speakers: " + str(maskloss.nb_speakers))
print(" trainset_seed: " + str(trainset.random_seed))
print(" model_seed: " + str(m.seed))
for param in model.parameters():
if param.requires_grad:
params_num += np.prod(param.size())
print("number of parameters: {}".format(params_num))
print('...start training')
for epoch in range(start_epoch, epochs):
model.train()
if schedule:
adjust_learning_rate(optimizer, epoch)
train_cost, total_train_cost = 0, 0
print("------ Epoch {} ------".format(epoch))
train_iters = 0
for data in train_stream:
source, target, mask, _ = (torch.FloatTensor(_data).to(device)
for _data in data)
optimizer.zero_grad()
loss = 0
output = model(
source[:, None]
) # By providing a None in the second dimension, we actually add a new dimension so
# source[:, None] has shape of (batch_size, 1, feature_size, nb_spectrums)
#if torch.cuda.is_available():
# torch.cuda.empty_cache()
if not maskloss.pil:
for i in range(n_sources):
if nb_copies is None:
loss += maskloss(
pred=complex_product(
source, output[i], input_type='convolution'
), #complex_mul(source, output[i]),
truth=target[:, i],
mask=mask)
else:
loss += maskloss(pred=output[i],
truth=target[:, i],
mask=mask)
loss.backward()
else:
list_losses = []
speakers_indices = range(n_sources)
for speakers_idx in multiset_permutations(speakers_indices):
loss = 0
j = 0
for i in speakers_idx:
if nb_copies is None:
loss += maskloss(
pred=complex_product(
source,
output[j],
input_type='convolution'
), # complex_mul(source, output[j]),
truth=target[:, i],
mask=mask)
else:
loss += maskloss(pred=output[j],
truth=target[:, i],
mask=mask)
j += 1
list_losses.append(loss)
loss = min(torch.stack(list_losses))
loss.backward()
# gradient clipping
torch.nn.utils.clip_grad_norm_(
filter(lambda p: p.requires_grad, model.parameters()), clip)
optimizer.step()
#if torch.cuda.is_available():
# torch.cuda.empty_cache()
train_cost += loss.item()
train_iters += 1
if train_iters % print_interval == 0:
print("train loss {} at batch \
{}".format(train_cost / print_interval, train_iters))
train_cost = 0
total_train_cost += loss.item()
trainCost.append(total_train_cost / train_iters)
train_stream = trainset.read(batch=batch_size,
sortseq=False,
normalize=False,
bptt_len=bptt_len)
print('...start evaluation')
dev_sdr, dev_sir, dev_sar = 0, 0, 0
dev_iters = 0
model.eval()
with torch.no_grad():
for idx, data in enumerate(dev_stream):
source, target, mask, sourcelen = (
torch.FloatTensor(_data).to(device) for _data in data)
output = model(source[:, None])
#if torch.cuda.is_available():
# torch.cuda.empty_cache()
output_pred = []
for i in range(n_sources):
if nb_copies is None:
output_pred.append(
complex_product(
source, output[i],
input_type='convolution').cpu().data.numpy()
) # complex_mul(source, output[i]).cpu().data.numpy())
else:
output_pred.append(output[i].cpu().data.numpy())
if (idx + 1) % 10 == 0:
sdr, sir, sar = eval_sources(source.cpu().data.numpy(),
target.cpu().data.numpy(),
output_pred,
mask.cpu().data.numpy(),
sourcelen.cpu().data.numpy())
dev_sdr += sdr
dev_sir += sir
dev_sar += sar
print(sdr, sir, sar)
dev_iters += 1
#if torch.cuda.is_available():
# torch.cuda.empty_cache()
devSDR.append(dev_sdr / (dev_iters // 10))
devSIR.append(dev_sir / (dev_iters // 10))
devSAR.append(dev_sar / (dev_iters // 10))
print("SDR on valid set {}".format(devSDR[-1]))
print("SIR on valid set {}".format(devSIR[-1]))
print("SAR on valid set {}".format(devSAR[-1]))
print("------- End -------")
dev_stream = devset.read(batch=batch_size,
sortseq=False,
normalize=False,
bptt_len=bptt_len)
if len(devSDR) == 1 or devSDR[-1] > best_devSDR:
is_best = True
best_devSDR = devSDR[-1]
best_epoch = epoch
else:
is_best = False
state = {
'start_epoch': epoch + 1,
'model_state_dict': model.state_dict(),
'bestSDR': best_devSDR,
'optimizer': optimizer.state_dict(),
'clip': clip,
'schedule': schedule,
'epochs': epochs,
'batch_size': batch_size,
'print_interval': print_interval,
'best_epoch': best_epoch,
'maskloss': maskloss,
'training_losses': trainCost,
'devSDR': devSDR,
'devSIR': devSIR,
'devSAR': devSAR,
'train_reader': trainset,
'dev_reader': devset
}
if is_best:
print("\rSaving Best Model.\r")
save_checkpoint(state, is_best, save_path=experiment_path)
else:
print("\rSaving last Model.\r")
save_checkpoint(state, False, save_path=experiment_path)
[3, 2, 0, 0, 0], [3, 2, -1, 0, 0],
[3, 2, 0, 1, 0], [3, 2, -1, 1, 0],
[3, 1, 0, 0, 0], [3, 1, 0, 1, 0],
[3, 1, 0, 0, -1], [3, 1, 0, 1, -1],
[3, 0, 0, 0, 0], [3, 0, -1, 0, 0],
[3, 0, 0, 0, -1], [3, 0, -1, 0, -1]])
# occupancies (there will be 70^4 = 24.01 million of these!)
lengths = [2, 2, 2]
bond_energies = np.array([[0., 1., 3., 5.], [1., 0., 6., 8.], [3., 6., 0., 2.],
[5., 8., 2., 0.]])
c0 = np.array([0, 0, 1, 1, 2, 2, 3, 3])
pc0 = np.array(list(multiset_permutations(c0)))
pc0 = pc0.reshape(len(pc0), *lengths)
xc = [list(range(l)) for l in lengths]
clusters = np.array(list(product(xc[0], xc[1], xc[2])))
cls = product(clusters, bond_connectivities)
bonds = []
for cl in cls:
bonds.append([[cl[1][0], cl[0][0], cl[0][1], cl[0][2]],
[
cl[1][1], (cl[0][0] + cl[1][2]) % lengths[0],
(cl[0][1] + cl[1][3]) % lengths[1],
(cl[0][2] + cl[1][4]) % lengths[2]
]])
def test():
for i in range(1, 7):
print i
for p in multiset_permutations([0, 0, 1, 0, 1], i):
print p
def test_multiset_permutations():
assert [''.join(i) for i in (list(multiset_permutations('baby')))] == [
'abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab',
'byba', 'yabb', 'ybab', 'ybba']
