我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用itertools.permutations()。
def __shuffleTerms(self, terms): new_terms = [] delimiter = '.*' for term in terms: if term is not None: term['original'] = term['term'] if term['shuffle']: perms = itertools.permutations(term['term'].split(delimiter)) for perm in perms: new_terms.append({ 'term': delimiter.join(perm), 'humanterm': term['humanterm'], 'original': term['original'] }); else: new_terms.append(term) return new_terms
def stats2(sarray, names=None): """Calculate means and (co)variances for structured array data.""" if names is None: names = sarray.dtype.names nvar = len(names) data = tuple(sarray[name] for name in names) cov = np.cov(data) nondiag_cov = list(cov[i, j] for i, j in permutations(range(nvar), 2)) names_ave = list('ave_' + name for name in names) names_var = list('var_' + name for name in names) names_cov = list( 'cov_' + n1 + "_" + n2 for n1, n2 in permutations(names, 2)) out = dict(zip(names_ave, np.mean(data, axis=1))) out.update(zip(names_var, cov.diagonal())) out.update(zip(names_cov, nondiag_cov)) NamedStats = namedtuple('Stats2', names_ave + names_var + names_cov) return NamedStats(**out)
def solve(s): '''Find solutions to alphametic equations. >>> solve('SEND + MORE == MONEY') 9567 + 1085 == 10652 ''' words = findall('[A-Za-z]+', s) chars = set(''.join(words)) # characters to be substituted assert len(chars) <= 10 # there are only ten possible digits firsts = set(w[0] for w in words) # first letters of each of word chars = ''.join(firsts) + ''.join(chars - firsts) n = len(firsts) # chars[:n] cannot be assigned zero for perm in permutations('0123456789', len(chars)): if '0' not in perm[:n]: trans = maketrans(chars, ''.join(perm)) equation = s.translate(trans) try: if eval(equation): print equation except ArithmeticError: pass
def createSequences(self, fromPosition, toPosition): """ using the permutation of all functions to generate sequences @param fromPosition start position/index/value @param toPosition end position/index/value """ self.sequences = set() for r in range(1,len(self.registeredFunctions)): for functions in itertools.permutations(self.registeredFunctions, r): position = fromPosition sequence = [] while position <= toPosition: value = position for function in functions: value = function(value) sequence.append(value) position += 1 self.sequences.add(Sequence(sequence[0:], self.combineFunctions(functions)))
def dateformats(): "Yield all combinations of valid date formats." years = ("%Y",) months = ("%b", "%B") days = ("%d",) times = ("%I%p", "%I:%M%p", "%H:%M", "") for year in years: for month in months: for day in days: for args in ((day, month), (month, day)): date = " ".join(args) for time in times: for combo in permutations([year, date, time]): yield " ".join(combo).strip()
def get_children(p, s, length): children = set() if length < 0: return children for subset in permutations(s, length): setsubset = set(subset) append = True for node in children: if setsubset == node.s: append = False break n = Node(setsubset, p) n.children = get_children(n, setsubset, length-1) if append: children.add(n) return children
def get_children(p, s, length): children = set() if length < 0: return children for subset in permutations(s, length): setsubset = set(subset) append = True for node in children: if setsubset == node.s: append = False break if append: n = Node(setsubset, p) n.children = get_children(n, setsubset, length-1) children.add(n) return children
def fHighDotOperator(stack, z, mode): if mode == 1: # num def subfactorial(n): soFar = [1, 0] if n < 0: raise ValueError("can't comput subfactorial of negative number") if n < 2: return soFar[n] i = 2 while i <= n: soFar.append((i-1)*(soFar[i-1]+soFar[i-2])) i += 1 return soFar[-1] stack.append(subfactorial(int(z))) elif mode == 2: # str stack.append([''.join(p) for p in itertools.permutations(z) if all(''.join(p)[i] != z[i] for i in range(len(z)))]) elif mode == 3: # list stack.append([list(p) for p in itertools.permutations(z) if all(list(p)[i] != z[i] for i in range(len(z)))]) else: monadNotImplemented(mode, '') # ?
def relation_layer(self, net): ops = self.ops #hack shape = ops.shape(net) input_size = shape[1]*shape[2]*shape[3] netlist = self.split_by_width_height(net) permutations = self.permute(netlist, 2) permutations = self.fully_connected_from_list(permutations) net = ops.concat(permutations, axis=3) #hack bs = ops.shape(net)[0] net = ops.reshape(net, [bs, -1]) net = ops.linear(net, input_size) net = ops.reshape(net, shape) return net
def testGetBackwardOpsChain(self): # a -> b -> c a = tf.placeholder(tf.float32) b = tf.sqrt(a) c = tf.square(b) for n in range(4): for seed_tensors in permutations([a, b, c], n): if c in seed_tensors: truth = [a.op, b.op, c.op] elif b in seed_tensors: truth = [a.op, b.op] elif a in seed_tensors: truth = [a.op] else: truth = [] self.assertEqual(get_backward_ops(seed_tensors), truth) self.assertEqual(get_backward_ops([c], treat_as_inputs=[b]), [c.op]) self.assertEqual( get_backward_ops([b, c], treat_as_inputs=[b]), [c.op]) self.assertEqual( get_backward_ops([a, c], treat_as_inputs=[b]), [a.op, c.op])
def enumerateStereoIsomers(mol): out = [] chiralCentres = Chem.FindMolChiralCenters(mol, includeUnassigned=True) #return the molecule object when no chiral centres where identified if chiralCentres == []: return [mol] #All bit permutations with number of bits equals number of chiralCentres elements = _spam(len(chiralCentres)) for isoId,element in enumerate(elements): for centreId,i in enumerate(element): atomId = chiralCentres[centreId][0] if i == 0: mol.GetAtomWithIdx(atomId).SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW) elif i == 1: mol.GetAtomWithIdx(atomId).SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW) outmol = copy(mol) utils.log("Enumerated ", Chem.MolToSmiles(mol, isomericSmiles=True)) out.append(outmol) return out
def test_is_ancestor(self): git = self.rorepo.git if git.version_info[:3] < (1, 8, 0): raise SkipTest("git merge-base --is-ancestor feature unsupported") repo = self.rorepo c1 = 'f6aa8d1' c2 = '763ef75' self.assertTrue(repo.is_ancestor(c1, c1)) self.assertTrue(repo.is_ancestor("master", "master")) self.assertTrue(repo.is_ancestor(c1, c2)) self.assertTrue(repo.is_ancestor(c1, "master")) self.assertFalse(repo.is_ancestor(c2, c1)) self.assertFalse(repo.is_ancestor("master", c1)) for i, j in itertools.permutations([c1, 'ffffff', ''], r=2): self.assertRaises(GitCommandError, repo.is_ancestor, i, j)
def get_chunk_dic(objflag): countchecker(len(objflag)) storepath = finalsavepath(paths.results_path, pystrs.CHUNK_prefix, mybuildtime(), pyoptions.filextension, paths.results_file_name) with open(storepath, "a") as f: for item in itertools.permutations(objflag): item = filterforfun("".join(item), head=pyoptions.head, tail=pyoptions.tail, lenght_is_filter=pyoptions.args_pick, minlen=pyoptions.minlen, maxlen=pyoptions.maxlen, regex_is_filter=True, regex=pyoptions.filter_regex, encode_is_filter=True, encode=pyoptions.encode, occur_is_filter=True, letter_occur=pyoptions.letter_occur, digital_occur=pyoptions.digital_occur, special_occur=pyoptions.special_occur, types_is_filter=True, letter_types=pyoptions.letter_types, digital_types=pyoptions.digital_types, special_types=pyoptions.special_types, ) if item: f.write(item + pyoptions.CRLF) finishprinter(finishcounter(storepath), storepath)
def test_duplicate_values(self): UNIMPORTANT_VALUE = 57 panel = pd.Panel( UNIMPORTANT_VALUE, items=['a', 'b', 'b', 'a'], major_axis=['c'], minor_axis=['d'], ) unused = ExplodingObject() axis_names = ['items', 'major_axis', 'minor_axis'] for axis_order in permutations((0, 1, 2)): transposed = panel.transpose(*axis_order) with self.assertRaises(ValueError) as e: PanelBarReader(unused, transposed, 'daily') expected = ( "Duplicate entries in Panel.{name}: ['a', 'b'].".format( name=axis_names[axis_order.index(0)], ) ) self.assertEqual(str(e.exception), expected)
def get_reg_swaps(live_regs): """Given all the registers' live subsets, check which of them can be swapped. Returns a list with Swap objects.""" swaps = set() # filter out any registers that are not used reg_vals = filter(lambda x: not x.dont_touch(), live_regs.values()) for reg, other in itertools.permutations(reg_vals, 2): for subset in reg.subsets: if subset.no_swap: continue # print "ASDASD", reg, subset swap_subset = other.get_swap_subset(subset, reg) if swap_subset != None and swap_subset.size == 0: print "BUG: empty subset in get_swap_subset" continue if swap_subset != None: swaps.add(Swap(reg, other, swap_subset)) return list(swaps)
def _all_string_prefixes(): # The valid string prefixes. Only contain the lower case versions, # and don't contain any permuations (include 'fr', but not # 'rf'). The various permutations will be generated. _valid_string_prefixes = ['b', 'r', 'u', 'br'] if py_version >= 36: _valid_string_prefixes += ['f', 'fr'] if py_version <= 27: # TODO this is actually not 100% valid. ur is valid in Python 2.7, # while ru is not. _valid_string_prefixes.append('ur') # if we add binary f-strings, add: ['fb', 'fbr'] result = set(['']) for prefix in _valid_string_prefixes: for t in _itertools.permutations(prefix): # create a list with upper and lower versions of each # character for u in _itertools.product(*[(c, c.upper()) for c in t]): result.add(''.join(u)) return result
def create_set(categories, outfile): """ Creates a test-set .txt file for use in word2vec. Conforms to word2vec specs, from the google code repository: https://code.google.com/archive/p/word2vec/ :param categories: The categories and words in the categories: {NAME: [[tuple_1],[tuple_2],...,[tuple_n]]} :param outfile: The file to which to write the text. :return: None """ with open(outfile, 'w', encoding='utf8') as f: for k, v in categories.items(): f.write(u": {0}\n".format(k)) for x in permutations([" ".join(x).lower() for x in v], 2): f.write(u"{0}\n".format(" ".join(x)))
def csg_check(self, li, writer): m = writer(self._m) r = uncurry(writer(self._r)) old_value = None mapped = map(m, li) if self._flattened: mapped = flatten(mapped) for permuted in itertools.permutations(mapped): if self._keyed: reduced = [] for k, v in collect(permuted): reduced.append( (k, reduce(r, v)) ) else: reduced = reduce(r, permuted) if isinstance(reduced, list): return sorted(reduced) if old_value and (reduced != old_value): return False else: old_value = reduced return True
def prepare_all_flow_specifications(self): flow_specs = [] flow_match = Match(is_wildcard=True) #flow_match["ethernet_type"] = 0x0800 for src_host_id, dst_host_id in permutations(self.ng.host_ids, 2): if src_host_id == dst_host_id: continue fs = FlowSpecification(src_host_id, dst_host_id, flow_match) fs.ng_src_host = self.ng.get_node_object(src_host_id) fs.ng_dst_host = self.ng.get_node_object(dst_host_id) fs.mn_src_host = self.mininet_obj.get(src_host_id) fs.mn_dst_host = self.mininet_obj.get(dst_host_id) flow_specs.append(fs) return flow_specs
def genMod(digitnum = 5): pool = range(digitnum) # The repeating part must be 3 or multiple of 3 # The repeating part cannot include the last digit tset = set(range(digitnum-1)) repeats = itertools.combinations(range(digitnum-1), 3) for r in repeats: rset = set(r) oset = tset - rset for i in r: pool[i] = '{0}' odigits = itertools.permutations('0123456789', len(oset)) for o in odigits: idx = 0 for i in oset: pool[i] = o[idx] idx += 1 for last in ['1','3','7','9']: pool[-1] = last if pool[0] != '0': yield ''.join(pool)
def worker(): patterns = genpattern() digits = itertools.combinations(range(10),4) med = 0 abcd = None targets = None for d in digits: res = set() perm = itertools.permutations(d) for p in perm: for pat in patterns: exp = pat % p try: r = eval(exp) if int(r)==r: res.add(int(r)) except: pass n = maxn(res) if n > med: med = n abcd = d targets = res return sorted(abcd), med, targets
def permutation(current, indices): """ Permutes a certain section of a list and returns all permutations -current: current list/input list -indices: All indices to be permuted (assumes that all indices sequential) """ indices.sort() permuter = [current[a] for a in indices] permutations = [list(x) for x in list(itertools.permutations(permuter))] temp1 = current[:min(indices)] temp2 = current[max(indices)+1:] alllist = [] for i in permutations: alllist.append(temp1 + i + temp2) return alllist
def test_afw_to_nfa_conversion_language(self): """ Test a correct afw conversion to nfa comparing the language read by the two automaton """ nfa_01 = AFW.afw_to_nfa_conversion(self.afw_afw_to_nfa_test_01) # automata_IO.nfa_to_dot(nfa_01, 'afw_to_nfa_01') i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) # print(word) afw_acceptance = AFW.afw_word_acceptance( self.afw_afw_to_nfa_test_01, word) nfa_acceptance = NFA.nfa_word_acceptance(nfa_01, word) self.assertEqual(afw_acceptance, nfa_acceptance) i += 1
def test_afw_to_nfa_conversion_language_bis_bis(self): """ Test a correct afw conversion to nfa comparing the language read by the two automaton """ nfa_01 = AFW.afw_to_nfa_conversion(self.afw_nonemptiness_check_test_2) # automata_IO.nfa_to_dot(nfa_01, 'afw_to_nfa_strange') i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) # print(word) afw_acceptance = AFW.afw_word_acceptance( self.afw_nonemptiness_check_test_2, word) nfa_acceptance = NFA.nfa_word_acceptance(nfa_01, word) self.assertEqual(afw_acceptance, nfa_acceptance) i += 1
def test_afw_to_nfa_conversion_language_bis(self): """ Test a correct afw conversion to nfa comparing the language read by the two automaton. Here we take a nfa, we covert it to afw and back to nfa, then the original and final nfa are compared trough the language read. """ original_nfa_to_afw = AFW.nfa_to_afw_conversion( self.nfa_afw_to_nfa_test_01) nfa_01 = AFW.afw_to_nfa_conversion(original_nfa_to_afw) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) # print(word) original_nfa_acceptance = NFA.nfa_word_acceptance( self.nfa_afw_to_nfa_test_01, word) nfa_acceptance = NFA.nfa_word_acceptance(nfa_01, word) self.assertEqual(original_nfa_acceptance, nfa_acceptance) i += 1
def test_afw_completion(self): """ Tests a correct afw completion comparing the language read, that must be the same""" original = copy.deepcopy(self.afw_completion_test_01) AFW.afw_completion(self.afw_completion_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance = AFW.afw_word_acceptance(original, word) completed_acceptance = AFW.afw_word_acceptance( self.afw_completion_test_01, word) self.assertEqual(original_acceptance, completed_acceptance) i += 1
def test_afw_complementation(self): """ Test a correct afw complementation comparing the language read, that must be discording""" afw_complemented = AFW.afw_complementation( self.afw_complementation_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) afw_acceptance = AFW.afw_word_acceptance( self.afw_complementation_test_01, word) complement_acceptance = AFW.afw_word_acceptance( afw_complemented, word) self.assertNotEqual(afw_acceptance, complement_acceptance) i += 1
def test_afw_union_equals(self): """ Tests a correct afw union with the same afw """ AFW.rename_afw_states(self.afw_union_1_test_01, 'a_') union = AFW.afw_union(self.afw_union_1_test_01, self.afw_union_1_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_union_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_union_1_test_01, word) union_acceptance = AFW.afw_word_acceptance(union, word) self.assertEqual( original_acceptance_1 or original_acceptance_2, union_acceptance) i += 1
def test_afw_union_empty_states_1(self): """ Tests a afw union where the first afw is empty """ union = AFW.afw_union(self.afw_union_test_empty, self.afw_union_1_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_union_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_union_test_empty, word) union_acceptance = AFW.afw_word_acceptance(union, word) self.assertEqual( original_acceptance_1 or original_acceptance_2, union_acceptance) i += 1
def test_afw_union_empty_states_2(self): """ Tests a afw union where the second afw is empty """ union = AFW.afw_union(self.afw_union_1_test_01, self.afw_union_test_empty) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_union_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_union_test_empty, word) union_acceptance = AFW.afw_word_acceptance(union, word) self.assertEqual( original_acceptance_1 or original_acceptance_2, union_acceptance) i += 1
def test_afw_intersection_disjoint(self): """ Tests a correct afw intersection with completely disjoint afws """ AFW.rename_afw_states(self.afw_intersection_2_test_01, 'a_') intersection = AFW.afw_intersection(self.afw_intersection_1_test_01, self.afw_intersection_2_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_intersection_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_intersection_2_test_01, word) intersection_acceptance = AFW.afw_word_acceptance(intersection, word) self.assertEqual( original_acceptance_1 and original_acceptance_2, intersection_acceptance) i += 1
def test_afw_intersection_equals(self): """ Tests a correct afw intersection with the same afw """ AFW.rename_afw_states(self.afw_intersection_1_test_01, 'a_') intersection = AFW.afw_intersection(self.afw_intersection_1_test_01, self.afw_intersection_1_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_intersection_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_intersection_1_test_01, word) intersection_acceptance = AFW.afw_word_acceptance(intersection, word) self.assertEqual( original_acceptance_1 and original_acceptance_2, intersection_acceptance) i += 1
def test_afw_intersection_empty_states_1(self): """ Tests a afw intersection where the first afw is empty """ intersection = AFW.afw_intersection(self.afw_intersection_test_empty, self.afw_intersection_1_test_01) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_intersection_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_intersection_test_empty, word) intersection_acceptance = AFW.afw_word_acceptance(intersection, word) self.assertEqual( original_acceptance_1 and original_acceptance_2, intersection_acceptance) i += 1
def test_afw_intersection_empty_states_2(self): """ Tests a afw intersection where the second afw is empty """ intersection = AFW.afw_intersection(self.afw_intersection_1_test_01, self.afw_intersection_test_empty) i = 0 last = 7 while i <= last: base = list(itertools.repeat('a', i)) base += list(itertools.repeat('b', i)) # build all permutation of 'a' and 'b' till length i word_set = set(itertools.permutations(base, i)) for word in word_set: word = list(word) original_acceptance_1 = AFW.afw_word_acceptance( self.afw_intersection_1_test_01, word) original_acceptance_2 = AFW.afw_word_acceptance( self.afw_intersection_test_empty, word) intersection_acceptance = AFW.afw_word_acceptance(intersection, word) self.assertEqual( original_acceptance_1 and original_acceptance_2, intersection_acceptance) i += 1
def find_anagrams(word, dictionary): """Find all anagrams for a word. This function only runs as fast as the test for membership in the 'dictionary' container. It will be slow if the dictionary is a list and fast if it's a set. Args: word: String of the target word. dictionary: Container with all strings that are known to be actual words. Returns: List of anagrams that were found. Empty if none were found. """ permutations = itertools.permutations(word, len(word)) possible = (''.join(x) for x in permutations) found = {word for word in possible if word in dictionary} return list(found)
def countArrangement(self, N): """ :type N: int :rtype: int """ def judge(num, pos): if not (num % pos) or not (pos % num): return True return False from itertools import permutations seq = range(1, N + 1) seq_len = len(seq) count = 0 for arrangement in (permutations(seq, seq_len)): for index, ele in enumerate(arrangement, 1): res = judge(ele, index) if not res: break else: count += 1 return count
def step_2(self): ''' STEP 2: Set-Up Puzzle - Extract Variable Names - Populate Event Space ''' first = self._find_first() i = first # print ('first var is ', self.prompt_text[first]) # print ('PROMPT', self.prompt_pairs) # print () self.vars = self._collect_vars(i) #print ('generating permutations...') perms = list(itertools.permutations(self.vars)) print ('Possible permutations of {} variables: {}'.format(len(self.vars), len(perms))) self.permutations = perms # before any rules self.viable = perms # viable candidates after rule(s) #print () return self.vars
def _winnow_all(self): ''' Apply all the rules to the pool of conceivable permutations. Winnow out those that satisfy all the rules. Return: the winnowed pool as a list ''' pool = self.viable print ("With {} variables, the pool starts with {} permutations...".format(len(self.vars), len(pool))) for i, rule in enumerate(self.rules): print (" ", " ".join(rule.text_list)) pool = self._winnow_one(rule.output, pool) print ("After rule {} pool size shrunk down to {}".format(i, len(pool))) print () if len(pool)<10: # if the remaining pool is small, go ahead and print it print(pool) return pool
def test_equals_block_order_different_dtypes(self): # GH 9330 mgr_strings = [ "a:i8;b:f8", # basic case "a:i8;b:f8;c:c8;d:b", # many types "a:i8;e:dt;f:td;g:string", # more types "a:i8;b:category;c:category2;d:category2", # categories "c:sparse;d:sparse_na;b:f8", # sparse ] for mgr_string in mgr_strings: bm = create_mgr(mgr_string) block_perms = itertools.permutations(bm.blocks) for bm_perm in block_perms: bm_this = BlockManager(bm_perm, bm.axes) self.assertTrue(bm.equals(bm_this)) self.assertTrue(bm_this.equals(bm))
def test_hf_state_plane_wave_basis_lowest_single_determinant_state(self): grid_length = 7 dimension = 1 spinless = True n_particles = 4 length_scale = 2.0 grid = Grid(dimension, grid_length, length_scale) hamiltonian = jellium_model(grid, spinless) hamiltonian_sparse = get_sparse_operator(hamiltonian) hf_state = hartree_fock_state_jellium(grid, n_particles, spinless, plane_wave=True) HF_energy = expectation(hamiltonian_sparse, hf_state) for occupied_orbitals in permutations( [1] * n_particles + [0] * (grid_length - n_particles)): state_index = numpy.sum(2 ** numpy.array(occupied_orbitals)) HF_competitor = csr_matrix(([1.0], ([state_index], [0])), shape=(2 ** grid_length, 1)) self.assertLessEqual( HF_energy, expectation(hamiltonian_sparse, HF_competitor))
def permutations(iterable): pool = list(iterable) n = len(pool) indices = list(range(n)) cycles = list(range(n, n-r, -1)) yield tuple(pool[i] for i in indices[:r]) while n: for i in reversed(range(r)): cycles[i] -= 1 if cycles[i] == 0: indices[i:] = indices[i+1:] + indices[i:i+1] cycles[i] = n - i else: j = cycles[i] indices[i], indices[-j] = indices[-j], indices[i] yield tuple(pool[i] for i in indices[:r]) break else: return
def _validate_options(cls, options): """Validate the mutually exclusive options. Return `True` iff only zero or one of `BASE_ERROR_SELECTION_OPTIONS` was selected. """ for opt1, opt2 in \ itertools.permutations(cls.BASE_ERROR_SELECTION_OPTIONS, 2): if getattr(options, opt1) and getattr(options, opt2): log.error('Cannot pass both {0} and {1}. They are ' 'mutually exclusive.'.format(opt1, opt2)) return False if options.convention and options.convention not in conventions: log.error("Illegal convention '{0}'. Possible conventions: {1}" .format(options.convention, ', '.join(conventions.keys()))) return False return True
def find_routes(primaries, currencies, pairs): """ Find all permutations of trade routes for pairs """ discovered = [] for c in currencies: for p in permutations(c, 3): # We want to end with the beginning currency p = p + (p[0],) if not p in discovered and \ has_two_primary(primaries, p) and \ valid_pairs(pairs, p): discovered.append(p) yield p
def main(): count = 0 start = time.time() for i in itertools.permutations(range(1, 10), 9): if cube3(i): count += 1 flag = 1 print('result %d:' % (count)) for k in i: print('%d ' % (k), end = '') if not(flag % 3): print() flag += 1 end = time.time() print('time:', end - start) print('total:', count)
def gen_passwords(wordset, minlen, maxlen, permute, skip): combinations, skip = drop_combinations(skip, wordset, permute) variations = [] for combination in combinations: if (len(''.join(combination)) < minlen or len(''.join(combination)) > maxlen): continue if permute: permutations, skip = drop_permutations(skip, combination) for permutation in permutations: variations = chain(variations, leet_word(''.join(permutation))) else: variations = chain(variations, leet_word(''.join(combination))) try: drop(skip, variations) except AttributeError: return yield from variations
def test_drop_permutations(): combination = ('ha', 'bc', 'de') varnum = variations_number(''.join(combination)) permutations, iteration = drop_permutations(0, combination) assert (list(permutations) == [('ha', 'bc', 'de'), ('ha', 'de', 'bc'), ('bc', 'ha', 'de'), ('bc', 'de', 'ha'), ('de', 'ha', 'bc'), ('de', 'bc', 'ha')]) assert iteration == 0 permutations, iteration = drop_permutations(varnum-1, combination) assert (list(permutations) == [('ha', 'bc', 'de'), ('ha', 'de', 'bc'), ('bc', 'ha', 'de'), ('bc', 'de', 'ha'), ('de', 'ha', 'bc'), ('de', 'bc', 'ha')]) assert iteration == varnum-1 permutations, iteration = drop_permutations(varnum+1, combination) assert (list(permutations) == [ ('ha', 'de', 'bc'), ('bc', 'ha', 'de'), ('bc', 'de', 'ha'), ('de', 'ha', 'bc'), ('de', 'bc', 'ha')]) assert iteration == 1
def multipath_computation(self): edges = [] self.mp_config = {} for dpid, switch in self.dpid_to_switch.iteritems(): # Updating the capacity_maxflow variable which will be # modified by the algorithm with the realtime monitored capacity for port_no, port in switch.ports.iteritems(): port.capacity_maxflow = port.capacity # Adding the edge switches to a list if switch.edge_port: edges.append(switch) # Calculate forwarding paths between all edges couples logger.info('%s', self.dpid_to_switch) for edge_couple in itertools.permutations(edges, 2): self.calculate_multipath(edge_couple[0], edge_couple[1]) self.create_flow_rules(edge_couple[0], edge_couple[1]) logger.info('-' * 20)
def _all_string_prefixes(): # The valid string prefixes. Only contain the lower case versions, # and don't contain any permuations (include 'fr', but not # 'rf'). The various permutations will be generated. _valid_string_prefixes = ['b', 'r', 'u', 'f', 'br', 'fr'] # if we add binary f-strings, add: ['fb', 'fbr'] result = set(['']) for prefix in _valid_string_prefixes: for t in _itertools.permutations(prefix): # create a list with upper and lower versions of each # character for u in _itertools.product(*[(c, c.upper()) for c in t]): result.add(''.join(u)) return result
