def test_15_new_form_list(self):
""" por definicao, (1 2 3) == (2 3 1) == (3 1 2)"""
a=permutation(self.sz, [1, 2, 3])
b=permutation(self.sz, [2, 3, 1])
c=permutation(self.sz, [3, 1, 2])
self.assertEqual(a,b)
self.assertEqual(b,c)
self.assertEqual(a,c) # redundante, por transitividade
def linkingFunc(polList, winSize):
polyPossibles = permutation.permutation(len(polList))
winPossibles = permutation.permutation(winSize)
keyList = {string: [] for string in polyPossibles}
winList = {string: [] for string in winPossibles}
for string in winPossibles:
strip = ""
for i in range(len(polList)):
strip += convolution(polList[i], string)
keyList[strip].append(string)
winList[string].append(strip)
# for key in keyList.keys() :
# if keyList[key] == [] :
# del keyList[i]
return keyList, winList
def __init__(self, vars=None, idx=None, perm=None):
self.vars = vars
self.idx = idx
if perm is None:
self.permutation = permutation.permutation(vars, idx)
else:
self.permutation = perm
def __init__(self, vars=None, idx=None, perm=None):
self.vars = vars
self.idx = idx
if perm is None:
self.permutation = permutation.permutation(vars, idx)
else:
self.permutation = perm
def main():
# start_time = time.time()
print("starting program")
reader = language_model.corpusReader(
"http://www.gutenberg.org/files/76/76-0.txt")
lngmodel = language_model.LanguageModel(reader)
txt = open("problemset_06_encrypted_input.txt", "r")
msg = str(txt.read())
txt.close()
perm = dict()
T = {",", ".", ":", "\n", "#", "(", ")", "!", "?", "\'", "\"", " "}
letters = "abcdefghijklmnopqrstuvwxyz"
for letter in letters:
perm[letter] = letter
for t in T:
perm[t] = t
p = permutation.permutation(perm)
print("start simulated_annealing")
sim = simulated_annealing.SimulatedAnnealing(300, 0.00001, 0.9990)
h = sim.run(p, msg, lngmodel)
# start_time = (time.time() - start_time)/60
# print("exacution took: "+str(start_time))
print(h.translate(msg))
print(h.mapChar)
def DriverNet(args):
'''
main function of DriverNet
'''
logger.info("Start running.")
logger.info("Parameters: %s" %(' '.join(sys.argv)))
ggi_matirx = args.network
sample_mutation_matrix = args.mutation
sample_exp_outlier = args.expression
permutation_time = args.permutation_time
threads = args.threads
notPurturbGraph = args.notPurturbGraph
purturbData = args.purturbData
output_prefix = args.output
edges, ggi, outlier_dict, mutation_dict = preprocess(ggi_matirx, sample_mutation_matrix, sample_exp_outlier)
drivers, actual_events = greedy(edges, mutation_dict)
logger.info("Driver finding done. Start significance test now.")
random_res = permutation(ggi, outlier_dict, mutation_dict, permutation_time, threads,
notPurturbGraph, purturbData)
pvalues, qvalues = compute_p(drivers, random_res)
logger.info("Significance test done.")
report(drivers, actual_events, pvalues, qvalues, output_prefix)
logger.info("Writing output done. Please check %s.txt." %(output_prefix))
logger.info("All done. Cheers.")
def test_30_permutate_list(self):
perm_list = [ 0, 1 ]
perm = permutation(self.sz,perm_list)
a = [ i for i in range(self.sz) ]
b = perm(a)
self.assertEqual(b[0],1)
self.assertEqual(b[1],0)
self.assertTrue(all(b[i] == i for i in range(2,self.sz)))
def test_20_new_from_dict_2(self):
perm_dict = { 0:1, 1:0,2:3, 3:2}
perm = permutation(self.sz,perm_dict)
self.assertEqual(perm[0],1)
self.assertEqual(perm[1],0)
self.assertEqual(perm[2],3)
self.assertEqual(perm[3],2)
self.assertTrue(all(perm[i] == i for i in range(4,self.sz)))
def test_40_permutate_dict_2(self):
perm_ = {0:1, 1:0, 2:3, 3:2}
perm = permutation(self.sz,perm_)
a = ['a', 'b', 'c', 'd']
b = perm(a)
self.assertEqual(b[0],'b')
self.assertEqual(b[1],'a')
self.assertEqual(b[2],'d')
self.assertEqual(b[3],'c')
def test_50_permutate_permutation2(self):
id = permutation(self.sz)
perm_list = [ 0, 1 ]
perm1 = permutation(self.sz,perm_list)
perm_list = [ 1, 2 ]
perm2 = permutation(self.sz,perm_list)
perm_list = [ 0 ,2 , 1]
perm3 = permutation(self.sz,perm_list)
perm_list = [ 0, 1, 2 ]
perm4 = permutation(self.sz,perm_list,complete=True)
a = perm1(perm2)
self.assertEqual(a, perm3)
b = perm2(perm1)
self.assertEqual(b, perm4)
def test_50_permutate_permutation3(self):
id = permutation(self.sz)
perm_d = {0:1,1:0,2:3,3:2}
perm = permutation(self.sz,perm_d)
perm_list = [ 0, 1 ]
perm1 = permutation(self.sz,perm_list)
perm_list = [ 2 , 3]
perm2 = permutation(self.sz,perm_list)
a = perm1(perm2)
a = perm1(perm2)
self.assertEqual(a, perm)
b = perm2(perm1)
self.assertEqual(b, perm)
self.assertEqual(a,b)
def variations(list_for_variations, k, repetition=False):
per = []
for c in combinations(list_for_variations, k, repetition):
actual_permutations = permutation(c)
if repetition:
for x in actual_permutations:
count = actual_permutations.count(x)
if count > 1:
for y in range(count - 1):
actual_permutations.remove(x)
per.extend(actual_permutations)
return per
def frame_encryption(results, image, diffusion_matrices):
layers = [image[:, :, 0], image[:, :, 1], image[:, :, 2]]
encrypted_layers = []
for layer in layers:
i = 0
permuted_matrix = perm.permutation(results[i], results[(i + 1) % 3],
layer)
encrypted_matrix = diff.diffusion_process(results[i],
results[(i + 1) % 3],
permuted_matrix,
diffusion_matrices[i])
encrypted_layers.append(encrypted_matrix)
i += 1
return np.dstack(tuple(encrypted_layers))
def ennet(args):
'''
'''
network_file = args.network
enhancer_file = args.enhancer
snp_file = args.mutation
# do some args checking here
# preprocess
G = preprocess.preprocess(network_file, enhancer_file)
# escore
G = escore.escore(snp_file, G, args.r, args.p0_meth)
# permutation test
G = permutation.permutation(G, args.permutation, args.threads)
# report results
report(G, args.output)
logger.info('All done. Cheers')
def shortest_route(self):
"""Return the shortest route.
Returns:
shortest route
"""
perms = permutation(self.n)
index_min = 0
d_min = 0
for i in range(self.n):
d_min += self.d[perms[0][i]][perms[0][(i + 1) % self.n]]
for index, perm in enumerate(perms):
d = 0
for i in range(self.n):
d += self.d[perm[i]][perm[(i + 1) % self.n]]
if d < d_min:
d_min = d
index_min = index
return perms[index_min]
def test_00_identity(self):
id=permutation(self.sz,complete=True)
self.assertTrue(all(id[i] == i for i in range(self.sz)))
def final_permutation(input):
return permutation(input, final_permutation_array)
def parity_drop(input):
if len(input) != 64:
raise Exception("Wrong dimension")
return permutation(input, parity_drop_array)
def straight_p_box(input):
if len(input) != 32:
raise Exception("Wrong dimension")
return permutation(input, straight_p_box_array)
def initial_permutation(input):
return permutation(input, initial_permutation_array)
def test_90_exception_list_size_2(self):
perm_list = [ 0, 1 ]
perm = permutation(self.sz,perm_list)
a = [ i for i in range(self.sz+1) ]
with self.assertRaises(Exception):
perm(a)
def test_50_permutate_permutation(self):
perm_list = [ 0, 1 ]
id = permutation(self.sz)
perm1 = permutation(self.sz,perm_list)
a = perm1(perm1)
self.assertEqual(a, id)
def test_permutation_with_large_integers(self):
assert permutation(15, 13) == 653837184000
assert permutation(20, 10) == 670442572800
assert permutation(25, 17) == 384702630042931200000
assert permutation(30, 25) == 2210440498434925488635904000000
def __init__(self, vars, idx):
self.vars = vars
self.idx = idx
self.permutation = permutation.permutation(vars, idx)
self.pairwise_swaps = permutation.pairwise_swaps(vars, self.permutation)
def des(plaintext_hexstr, key_hexstr, mode = 'encrypt'):
"""Encrypt a plaintext_bin with the key_bin, Or Decrypt a cipher_bin with the key_bin
"""
plaintext_bin = binary.hexstr_binary(plaintext_hexstr) # get the string's 64bits binary code
key_bin = binary.hexstr_binary(key_hexstr) # get the string's 64bits binary code
#############################################################
#############################################################
# To get the turn_key 1-16
#############################################################
#############################################################
# permuted choice 1
after_permuted_choice_1 = permutation.permutation(key_bin, table.permuted_choice_1)
#print 'After permuted choice 1 is:', binary.format(after_permuted_choice_1)
#print 'The len of after_permuted_choice_1 is', len(after_permuted_choice_1)
C_0 = after_permuted_choice_1[:28]
D_0 = after_permuted_choice_1[28:]
#print 'C_0 is: ', binary.format(C_0, 7)
#print 'D_0 is: ', binary.format(D_0, 7)
C_1 = C_0
D_1 = D_0
turn_key = []
# get the turn_key by turn 16 times
for times in range(16):
# circle shift left 1 or 2 bit(s)
C_1 = binary.circle_shift_left(C_1, table.shift_table[times])
D_1 = binary.circle_shift_left(D_1, table.shift_table[times])
#print 'C_1 shift left', table.shift_table[times], 'bits is: ', C_1
#print 'D_1 shift left', table.shift_table[times], 'bits is: ', D_1
after_permuted_choice_2 = permutation.permutation(C_1+D_1, table.permuted_choice_2) # permuted choice 2
turn_key.append(after_permuted_choice_2)
#print 'The turn_key[', times + 1, '] is:', binary.format(after_permuted_choice_2, 6)
#print 'The len of after_permuted_choice_2 is:', len(after_permuted_choice_2)
#print 'The turn key is:', turn_key
#print len(turn_key)
# #####################################################
# #####################################################
# Encrypt the Data
# #####################################################
# #####################################################
# Do the initial permutation
after_init_perm = permutation.permutation(plaintext_bin, table.initial_permutation)
#print 'After initial permutation is:', binary.format(after_init_perm)
L_0 = after_init_perm[:32]
R_0 = after_init_perm[32:]
#print 'The L_0 is:', binary.format(L_0)
#print 'The R_0 is:', binary.format(R_0)
R_1 = R_0
# judging is the mode
if mode == 'encrypt':
range_type = range(16)
elif mode == 'decrypt':
range_type = range(15, -1, -1)
# do the 16 tiems turn
for i in range_type:
temp = R_1
#print 'Round:', i+1
# Expansion R_1 from 32bits to 48bits, using the expansion table
E = permutation.permutation(R_1, table.expansion) # now, E is 48bits
#print 'E :', binary.format(E, 6)
#print 'KS :', binary.format(turn_key[i], 6)
# Xor E with turn_key[i]
R_xor_turnkey = binary.xor_bybit(E, turn_key[i])
#print 'E xor KS:', binary.format(R_xor_turnkey, 6)
# S box permutation
s_box = permutation.s_box(R_xor_turnkey)
#print 'Sbox:', binary.format(s_box, 4)
# P permutation
P = permutation.permutation(s_box, table.permutation_p)
#print 'P :', binary.format(P)
# Xor P with L_0
R_1 = binary.xor_bybit(L_0, P)
L_0 = temp # L[i] = R[i+1]
#print 'The L[',i+1, ']:', binary.format(L_0)
#print 'The R[',i+1,']:', binary.format(R_1)
#print
final = R_1 + L_0 # exchange the left 32bits with right 32bits
#print 'R[16]L[16]:', binary.format(final)
# do the inverse initial permutation
output = permutation.permutation(final, table.inverse_initial_permutation)
#print 'Output:', binary.format(output)
# Turn binary code to hexdecimal
output_hex = []
for i in range(0, 64, 4):
#print output[i:i+4]
output_hex.append(hex(int(output[i:i+4],2))[-1])
if mode == 'encrypt':
#print 'The encryped hexdecimal is:', ''.join(output_hex)
return ''.join(output_hex)
else:
#print 'The decrypted hexdecimal is:', ''.join(output_hex)
#decrypt_text = binascii.a2b_hex(''.join(output_hex))
#print 'The decrypted text is:', decrypt_text
#return decrypt_text
return ''.join(output_hex)
def test_80_expand(self):
id = permutation(self.sz)
id.expand()
for i in range(id.maxsize):
self.assertTrue(id.permutation.has_key(i),msg='{} should be present '.format(i))
self.assertEqual(id.permutation[i],i)
def test_80_collapse(self):
id = permutation(self.sz,complete=True)
id.collapse()
for i in range(id.maxsize):
self.assertFalse(id.permutation.has_key(i),msg='{} should not be present '.format(i))
def test_permutation_with_small_integers(self):
# permutation should return the product n*(n-1)*...*(n-m+1) for n >= m > 0
assert permutation(10, 0) == 1 # base case
assert permutation(10, 1) == 10 # base case
assert permutation(10, 2) == 10*9
assert permutation(10, 3) == 10*9*8
assert permutation(10, 4) == 10*9*8*7
assert permutation(10, 5) == 10*9*8*7*6
assert permutation(10, 6) == 10*9*8*7*6*5
assert permutation(10, 7) == 10*9*8*7*6*5*4
assert permutation(10, 8) == 10*9*8*7*6*5*4*3
assert permutation(10, 9) == 10*9*8*7*6*5*4*3*2
assert permutation(10, 10) == 10*9*8*7*6*5*4*3*2*1
def test_10_new_from_list(self):
perm_list = [ 0, 1 ]
perm = permutation(self.sz,perm_list)
self.assertEqual(perm[0],1)
self.assertEqual(perm[1],0)
self.assertTrue(all(perm[i] == i for i in range(2,self.sz)))
def compression_p_box(input):
return permutation(input, key_compression_array)
def test_20_new_from_dict_1(self):
perm_dict = { 0:1, 1:0,}
perm = permutation(self.sz,perm_dict)
self.assertEqual(perm[0],1)
self.assertEqual(perm[1],0)
self.assertTrue(all(perm[i] == i for i in range(2,self.sz)))
import permutation
def answer(coins, amount):
total = 0
for i in range(0, len(coins)):
total += amount // coins[i]
if amount >= coins[i]:
amount = amount % coins[i]
#print(f'i: {i}, coin selected: {coins[i]}, total coins: {total} , remaining amount: {amount}')
if amount == 0:
return total
return -1
array = [8, 5, 3]
amount = 18
coin_lists = permutation.permutation(array)
outputs = []
for coins in coin_lists:
outputs.append(answer(coins, amount))
print(outputs)
def test_permutation_with_negative_integers_m(self):
# permutation should raise a ValueError for n < 0
with self.assertRaises(ValueError, msg='function undefined for m < 0'):
permutation(1, -1)
permutation(5, -5)
def expansion_p_box(input):
if len(input) != 32:
raise Exception("Wrong dimension")
return permutation(input, expansion_p_box_array)
def test_permutation_with_integers_m_larger_than_integers_n(self):
# permutation should raise a ValueError for n < 0
with self.assertRaises(ValueError, msg='function undefined for n <= m'):
permutation(4, 5)
permutation(3, 7)
def test_permutation_with_floating_point_numbers(self):
# permutation should raise a ValueError for non-integer n
with self.assertRaises(ValueError, msg='function undefined for float'):
permutation(2.0, 1)
permutation(3.14159, 3)
permutation(9, 3.14159)
def __init__(self, vars, idx):
self.vars = vars
self.idx = idx
self.permutation = permutation.permutation(vars, idx)
self.pairwise_swaps = permutation.pairwise_swaps(
vars, self.permutation)
def image_encrypt(src_img, key):
chen_system = chaosSystem3d(key)
per_img = permutation(src_img, chen_system)
cipher = diffusion(per_img, chen_system)
return cipher
