def test_combinatorics(self):
"""Ensure a proper enumeration"""
p = mi.powerset([1, 2, 3])
self.assertEqual(
list(p),
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
)
def permutator(set_1, set_2):
"""Write the definition of the permutation operator given by the two sets.
Args:
set_1 (list): The list of the left-hand-side qp labels.
set_2 (list): The list of the right-hand-side qp labels.
Returns:
(str): The LaTeX expression for the permutation operator.
>>> print(permutator([1, 2], [3])) # doctest: +NORMALIZE_WHITESPACE
P(k_{1}k_{2}/k_{3}) &= 1 - P_{k_{1} k_{3}} - P_{k_{2} k_{3}} \\\\\n
"""
perm_op = 'P(%s/%s) &= 1 ' % ("".join(
'k_{%i}' % label for label in set_1), "".join('k_{%i}' % label
for label in set_2))
perm_counter = 0
# Combine all possible subsets of both sets
for subset_1, subset_2 in product(powerset(set_1), powerset(set_2)):
# Ensure each qp state has a permutation partner, exclude the empty set
if (len(subset_1) == len(subset_2)) and (len(subset_1) > 0):
# Run through all permutations of the first subset
for permutation in permutations(subset_1):
perm_op += '+ ' if len(subset_1) % 2 == 0 else '- '
for elem in zip(permutation, subset_2):
perm_op += 'P_{k_{%i} k_{%i}} ' % elem
perm_counter += 1
# Avoid permutators lines being too long
if perm_counter >= 10:
perm_op += '\\\\\n &\\phantom{=} '
perm_counter = 0
if perm_op.endswith('\\\\\n &\\phantom{=} '):
perm_op = perm_op[:-len(' &\\phantom{=} ')]
else:
perm_op += "\\\\\n"
return perm_op
def main(inp):
inp = inp.strip()
mem = {}
for l in inp.split("\n"):
tokens = l.split()
if p := parse("mask = {}", l):
mask = p[0]
else:
add, value = parse("mem[{:d}] = {:d}", l)
add |= int(tr(mask, "X", "0"), 2)
add &= ~int(tr(mask, "1X", "01"), 2)
xs = [35 - i for i, x in enumerate(mask) if x == "X"]
for subset in powerset(xs):
val = add + sum(map(pow, repeat(2), subset))
mem[val] = value
def floaters(address, mask):
addresses = set()
xs = {match.start() for match in re.finditer('X', mask)}
x_combos = more_itertools.powerset(xs)
address = f'{address:0>36b}'
for combo in x_combos:
new_address = list(address)
for x in xs:
if x in combo:
new_address[x] = '1'
else:
new_address[x] = '0'
new_address = int(''.join(new_address))
addresses.add(new_address)
return addresses
def generate_images(extracted_content_path=EXTRACTED_CONTENT_PATH, output_file_prefix="", output_path=OUTPUT_PATH,
all_combinations=False, separate=False, background_layer=False, output_type='jpg'):
lsr_content = json_file_to_object( f"{extracted_content_path}/Contents.json")
width = lsr_content['properties']['canvasSize']['width']
height = lsr_content['properties']['canvasSize']['height']
num_layers = len(lsr_content['layers'])
combinations = [[i for i in range(1, num_layers + 1)]]
if all_combinations:
combinations = [list(subset) for subset in list(more_itertools.powerset(combinations[0])) if subset]
if background_layer:
combinations = [subset for subset in combinations if num_layers in subset]
elif separate:
combinations = [[i] for i in range(1, num_layers + 1)]
for combination in combinations:
img = Image.new('RGBA', (width, height))
for layer_num in combination[::-1]:
layer = lsr_content['layers'][layer_num - 1]
layer_name = layer['filename']
layer_content = json_file_to_object(f"{extracted_content_path}/{layer_name}/Contents.json")
layer_width = layer_content['properties']['frame-size']['width']
layer_height = layer_content['properties']['frame-size']['height']
layer_center_x = layer_content['properties']['frame-center']['x']
layer_center_y = layer_content['properties']['frame-center']['y']
layer_image_set_content = json_file_to_object(
f"{extracted_content_path}/{layer_name}/Content.imageset/Contents.json")
for image in layer_image_set_content['images']:
image_path = f"{extracted_content_path}/{layer_name}/Content.imageset/{image['filename']}"
img.alpha_composite(Image.open(image_path).convert('RGBA'),
(int(layer_center_x - layer_width/2), int(layer_center_y - layer_height/2)))
try:
os.makedirs(output_path)
except OSError as e:
if e.errno != errno.EEXIST:
raise
combination_str = ','.join([str(i) for i in combination])
if output_type == 'jpg':
img = img.convert('RGB')
img.save(f"{output_path}/{output_file_prefix}({combination_str}).{output_type}")
def make_fair_teams(self) -> Solution:
minimum = 20 * self.valuator.valueof(Division.C)
optimum_solution = Solution(Team([], 0), Team([], 0))
viable_solutions = list((set_, self._complem(set_))
for set_ in powerset(self.players)
if 1 <= len(set_) <= 5)
for players1, players2 in viable_solutions:
val1, val2 = self._values_of_teams(players1, players2)
diff = abs(val2 - val1)
if diff < minimum:
minimum = diff
optimum_solution.team1.players = list(players1)
optimum_solution.team2.players = list(players2)
optimum_solution.team1.value = val1
optimum_solution.team2.value = val2
return optimum_solution
def get_plausible_sets(board, pieces):
piece_power_set = more_itertools.powerset(pieces)
plausibleSets = []
for aSet in piece_power_set:
sum_of_set = {}
for item in aSet:
this_pieces_spots = num_spots_in_piece(pieces[item])
for piece_type in this_pieces_spots:
if piece_type in sum_of_set:
sum_of_set[piece_type] += this_pieces_spots[piece_type]
else:
sum_of_set[piece_type] = this_pieces_spots[piece_type]
if has_necessary_num_pieces(board, sum_of_set):
plausibleSet = {}
myIter = 0
for item in aSet:
plausibleSet[myIter] = pieces[item]
myIter += 1
plausibleSets.append(plausibleSet)
return plausibleSets
def find_matching_complex(G, edge_labels=None):
"""
Finds the matching complex of a given graph G
@params
G = networkx graph object storing the graph to find a matching complex of. To create this from an
edge list, simply do:
G = networkx.Graph()
G.add_edges_from(edge_list)
edge_labels = List of names to give each of the edges in the matching.
@returns
maximal_matchings = A list of tuples for each face in the matching complex. e.g. a 1-tuple specifies a vertex, a 2-tuple an edge,
a 3-tuple a triangle, a 4-tuple a tetrahedron, etc
"""
if edge_labels is None:
edge_labels = {e: e for e in enumerate(G.edges())}
matchings = set([])
# find all possible matchings: improve this code if necessary
for edge_set in mitl.powerset(G.edges()):
if nx.algorithms.matching.is_matching(G, edge_set):
matchings.add(tuple([edge_labels[e] for e in edge_set]))
maximal_matchings = set()
for match in matchings:
to_remove = set()
for max_match in maximal_matchings:
if set(match).issubset(set(max_match)): break
if set(max_match).issubset(set(match)): to_remove.add(max_match)
else:
maximal_matchings.add(match)
maximal_matchings = maximal_matchings - to_remove
return maximal_matchings
def power_list(data):
"""
:param data: an iterable
:return: power set of the data as a list (excluding the empty list).
:rtype: list
>>> l = [1, 2, 3]
>>> power_list(l)
[(1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
>>> for x in power_list([(0.0, 2.0), (4.0, 5.5), (6.0, 7.25)]):
... print(x)
((0.0, 2.0),)
((4.0, 5.5),)
((6.0, 7.25),)
((0.0, 2.0), (4.0, 5.5))
((0.0, 2.0), (6.0, 7.25))
((4.0, 5.5), (6.0, 7.25))
((0.0, 2.0), (4.0, 5.5), (6.0, 7.25))
"""
assert type(data) == list
power_list = powerset(data)
return [x for x in power_list if len(x) != 0]
def FindIntegrableConditions(S, context):
result = list(S)
if len(result) == 1:
return []
vars = list(range(len(context._independent)))
monomials = [(_, derivative_to_vec(_.Lder(), context)) for _ in result]
ms = tuple([_[1] for _ in monomials])
m0 = []
def map_old_to_new(l):
return context._independent[vars.index(l)]
# multiplier-collection is our M
multiplier_collection = []
for dp, monom in monomials:
# S1
# damned! Variables are messed up!
_multipliers, _nonmultipliers = vec_multipliers(monom, ms, vars)
multiplier_collection.append(
(dp, [map_old_to_new(_) for _ in _multipliers],
[map_old_to_new(_) for _ in _nonmultipliers]))
result = []
for e1, e2 in product(multiplier_collection, repeat=2):
if e1 == e2: continue
for n in e1[2]:
for m in islice(powerset(e2[1]), 1, None):
if eq(adiff(e1[0].Lder(), context, n),
adiff(e2[0].Lder(), context, *m)):
# integrability condition
# don't need leading coefficients because in DPs
# it is always 1
c = adiff(e1[0].expression(), context, n) - \
adiff(e2[0].expression(), context, *m)
result.append(c)
return result
def test_combinatorics(self):
"""Ensure a proper enumeration"""
p = mi.powerset([1, 2, 3])
self.assertEqual(list(p), [(), (1, ), (2, ), (3, ), (1, 2), (1, 3),
(2, 3), (1, 2, 3)])
from more_itertools import powerset
from numpy import ediff1d
def ps_sorter(tup):
l = len(tup)
d = ediff1d(tup).tolist()
return l, d
ps = powerset([1,2,3,4])
ps = sorted(ps, key=ps_sorter)
for x in ps:
print(x)
def get_states(self):
"""Return list of all states. A state has the format (x, (a, b)) where x is the index of the current position
and (a, b) a sorted tuple of the pick position that have been visited"""
return [(cor, tuple(sorted(ppc))) for cor in self.corridors
for ppc in powerset(self.pick_pts)]
def main() -> None:
lines = aoc.get_lines(14)
memory: Dict[int, int] = {}
mask1s = 0b_0000_0000_0000_0000_0000_0000_0000_0000_0000
mask0s = 0b_1111_1111_1111_1111_1111_1111_1111_1111_1111
line_regex = re.compile(r"^([a-z]+)(?:\[(.+?)\])? = (.+)$")
for line in lines:
command, argument, value = line_regex.match(line).groups()
if command == "mem":
memory[int(argument)] = (int(value) & mask0s) | mask1s
elif command == "mask":
mask0s = 0
mask1s = 0
for character in value:
mask0s <<= 1
mask1s <<= 1
if character == "X":
mask0s |= 1
mask1s |= 0
elif character == "1":
mask0s |= 1
mask1s |= 1
elif character == "0":
mask0s |= 0
mask1s |= 0
else:
assert False, f"Invalid character {character} in mask"
else:
assert False, f"Invalid command {command}"
print(sum(memory.values()))
############################################################################
mask1s = 0b_0000_0000_0000_0000_0000_0000_0000_0000_0000
mask0s = 0b_1111_1111_1111_1111_1111_1111_1111_1111_1111
floats: List[int] = []
memory = {}
for line in lines:
command, argument, value = line_regex.match(line).groups()
if command == "mem":
write_value = int(value)
address = int(argument)
newline = "\n"
for floating_masks in more_itertools.powerset(floats):
mask = reduce(lambda a, b: a | b, floating_masks, 0)
local_address = ((int(argument) & mask0s) | mask1s) | mask
memory[local_address] = write_value
elif command == "mask":
mask0s = 0
mask1s = 0
floats = []
float_index = 0b_1_0000_0000_0000_0000_0000_0000_0000_0000_0000
for character in value:
mask0s <<= 1
mask1s <<= 1
float_index >>= 1
if character == "X":
mask0s |= 0
mask1s |= 0
floats.append(float_index)
elif character == "1":
mask0s |= 1
mask1s |= 1
elif character == "0":
mask0s |= 1
mask1s |= 0
else:
assert False, f"Invalid character {character} in mask"
else:
assert False, f"Invalid command {command}"
print(sum(memory.values()))
def all_coalitions(self):
return powerset(range(self.N))
b |= ormask
a = int(a[4:-1])
memory[a] = b
print(sum(memory.values()))
memory = dict()
for line in program:
a, b = line.split(' = ')
if a == 'mask':
ormask, andmask = 0, 0
maskstr = b[::-1]
for c in range(36):
if maskstr[c] == '1':
ormask |= 2**c
elif maskstr[c] == 'X':
andmask ^= 2**c
else:
a = int(a[4:-1])
a |= ormask
a &= ~andmask
bitlist = []
for c in range(36):
if maskstr[c] == 'X':
bitlist.append(c)
masks = [
sum(map(lambda x: 2**x, s))
for s in more_itertools.powerset(bitlist)
]
for addr in [a | mask for mask in masks]:
memory[addr] = int(b)
print(sum(memory.values()))
def test_empty(self):
p = list(mi.powerset([]))
self.assertEqual(p, [()])
def general_cluster_statmech_model(regObj,
lowAffinityOcc=None,
conc=16,
consensusKd=16,
concO=0.6):
"""
This method takes as input a regulatory element (module) object of binding sites
with their different properties (spacing, scores, etc.), as well as a concentration parameter,
and returns the mean occupancy of transcription factor to the binding sites. It
works by assuming that non-overlapping sites bind transcription factor independently,
and it deals with dependent (overlapping) binding sites by first identifying
all of the possible bound states of the system, followed by determining the
weighted multiplicities (relative to unbound state) based on Philips PBOC 2nd edition.
Then the mean occ. is calculated as a weighted average of the probability of occupancy of
each state (ratio of the state's rel. weighted multiplicity to the partition function (also
rel.), and by the number of transcription factors that are bound in that state.
Based on PBOC - 2nd, p.270, equation 6.112:
delE (change in energy with binding, relative to solution) in units Boltzmann constant*T (1/beta) = ln(Kd/concO)
When calculating occupancy, I first convert Kds into this delE value in terms of Kb*T
lowAffinityOcc: float
If specified, this means we only care about the mean occupancy coming from low-affinity sites,
which have Kd values above the threshold ratio stored in this variable. In order to implement
this, for independent binding sites, we skip the occupancy contribution if the site's Kd is
below this threshold. For overlapping clusters, we multiply each state's weighted rel. mult.
by the number of low-affinity binding sites instead of the total number of binding sites, before
dividing by the partition function.
Returns
-------
Mean occupancy of the input regulatory module.
"""
aggOcc = 0 # aggregate occupancy, which will accumulate independently from
# the modules (single sites and overlapping clusters)
# iterate over spacings list, separate into different cases if it's an
# overlapping site (dependent) or non-overlapping site (independent)
i = 0
while i < len(regObj.startPos):
# -------------- if it's a non-overlapping site, just assume independent binding and add its occupancy to aggOcc
if i == len(
regObj.spacing
): # account for the last site (note: we'd only arrive here if it's not part of an ovlp cluster (but can't check spacing),
# so it's fine not to check, and just assume non-overlapping)
if lowAffinityOcc: # see parameter definition
if regObj.siteAffinities[i] >= lowAffinityOcc:
fracOcc = single_site_statmech_model(
regObj.siteAffinities[i], conc, consensusKd, concO)
aggOcc = aggOcc + fracOcc
else: # note: this gets skipped if lowAffinityOcc=True, but site affinity < lowAffinityOcc, and therefore higher affinity non-ovlp sites are not added
fracOcc = single_site_statmech_model(regObj.siteAffinities[i],
conc, consensusKd, concO)
aggOcc = aggOcc + fracOcc
elif regObj.spacing[
i] >= 0: # this is only fine if never end here with index corresponding to the final member of an ovlp cluster (else it would trigger)
if lowAffinityOcc:
if regObj.siteAffinities[i] >= lowAffinityOcc:
fracOcc = single_site_statmech_model(
regObj.siteAffinities[i], conc, consensusKd, concO)
aggOcc = aggOcc + fracOcc
else:
fracOcc = single_site_statmech_model(regObj.siteAffinities[i],
conc, consensusKd, concO)
aggOcc = aggOcc + fracOcc
else: # -------------- must be an overlapping site (negative spacing), note that an ovlp cluster can't start on the last site
start = i
allCombosList = [
] # list of tuples of all combos of sites (powerset)
eachSitesOverlaps = [
] # list of lists (one corresponding to each site), identifying which sites overlap
while regObj.spacing[
i] < 0: #find the last site in the overlapping cluster
i += 1
if i == len(
regObj.spacing
): #if we're on the last member of both the ovlp cluster and also the entire reg element
break
end = i
#identify all binding sites that overlap with each binding site (create a separate list for each site), and append these to eachSitesOverlaps
for j in range(start,
end + 1): #for a given site j in the ovlp cluster
tempList = []
for k in range(start,
end + 1): #do the other sites k in the cluster
if k is not j: #ignoring that site j itself
if (k < j and regObj.endPos[k] >= regObj.startPos[j]
) or (k > j and regObj.startPos[k] <=
regObj.endPos[j]): #overlap with site j?
tempList.append(
k
) #for each site j, append all sites k that do overlap, into tempList
if tempList:
eachSitesOverlaps.append(
tempList
) #then append this list of sites overlapping with j to eachSitesOverlaps, and move to next site j+1
allCombosList = list(
powerset(np.arange(start, end + 1))
) #generate all possible combinations of sites (including states impossible due to binding exclusivity)
possibleStates = restrict_to_possible_states(
allCombosList, eachSitesOverlaps
) #list of possible states (sites that con be concurrently occupied in the ovlp cluster)
# iterate over possible states and generate a relative boltzmann-weighted multiplicity for each, by summing the delta binding energies (relative to Esol)
aggWeightedMeanOcc = 0 # Accumulate the numerator in the: weighted average (Pocc) mean occupancy calculation (note that unbound state is multiplied by 0 sites)
aggPartitionFunction = 0 # Accumulate the denominator (note that the unbound state results in +1)
for y in range(len(possibleStates)):
aggDelE = 0
if lowAffinityOcc:
numLowAffSites = 0
numSites = len(possibleStates[y])
for z in range(numSites):
siteIndex = possibleStates[y][
z] # index (in regEle object) of current site in current binding state
aggDelE = aggDelE + math.log(
regObj.siteAffinities[siteIndex] * consensusKd / concO
) # iterate and sum the deltaEnergy terms for that state
if lowAffinityOcc and (regObj.siteAffinities[siteIndex] >=
lowAffinityOcc):
numLowAffSites += 1
relMultOvlp = ((conc / concO)**numSites) * math.exp(
-aggDelE
) # calculate the weighted relative multiplicity term for that state (see PBOC or notes for derivation)
aggPartitionFunction = aggPartitionFunction + relMultOvlp
if lowAffinityOcc:
aggWeightedMeanOcc = aggWeightedMeanOcc + numLowAffSites * relMultOvlp
else:
aggWeightedMeanOcc = aggWeightedMeanOcc + numSites * relMultOvlp
meanOcc = aggWeightedMeanOcc / aggPartitionFunction # do the mean occupancy calculation
aggOcc = aggOcc + meanOcc # add the occupancy from the ovlp cluster to the occupancy for the overall regulatory element
# -------------- after we're done with the case (non-ovlp site or ovlp cluster), move on to the next site
i += 1
return aggOcc
def get_states(self):
"""Return list of all states. A state has the format (x, (a, b)) where x is the index of the current position
and (a, b) a sorted tuple of the pick positions that have been visited"""
return [(*cc, tuple(sorted(ppc)))
for cc in product(self.corridors, repeat=self.n_agents)
for ppc in powerset(self.pick_pts)]
None:
lambda s, _: [{}],
jax._src.lax.lax.copy_p:
lambda s, _: [{}],
ad.zeros_like_p:
lambda s, _: [{}],
lax.neg_p:
lambda s, _: [{}],
lax.transpose_p:
lambda s, _: [{
'permutation': p
} for p in itertools.permutations(range(len(s)))],
lax.reduce_sum_p:
lambda s, _: [{
'axes': p
} for p in more_itertools.powerset(range(len(s)))],
lax.reduce_window_sum_p:
lambda s, _: [{
'base_dilation': b_d,
'padding': p,
'window_dilation': w_dl,
'window_dimensions': w_dd,
'window_strides': w_s
} for b_d in _hypercube(len(s))[:3]
for p in map(tuple, ([[]] if len(s) == 0 else [
[(0, 0) for _ in range(len(s))],
[(i, i // 2 + 1) for i in range(len(s))],
[(i // 2 + 1, i) for i in range(len(s))],
])) for w_dl in _hypercube(len(s))[:3]
for w_dd in _hypercube(len(s))[:3]
for w_s in _hypercube(len(s))[:3]],
from more_itertools import powerset list(powerset(['col1', 'col2', 'col3']))
east
take space law space brochure
west
south
east
south
east
take weather machine
west
south
take manifold
west
take mouse
north
north
'''
#Droid(memory).run(initial_commands)
items = {
command[5:]
for command in initial_commands.splitlines() if command.startswith('t')
}
commands = initial_commands.splitlines() + [f'drop {item}' for item in items]
for combo in powerset(items):
additional_commands = [f'take {item}' for item in combo
] + ['east'] + [f'drop {item}' for item in combo]
commands.extend(additional_commands)
commands = '\n'.join(commands) + '\n'
Droid(memory).run(commands)
"toi",
"gp",
"icf",
"g_pp",
"a1_pp",
"a2_pp",
"points_pp",
"toi_pp",
"gp_pp",
"isf_pp",
"iff_pp",
"season_next",
"pos_D",
"pos_D/F",
"pos_F",
"toi_gp",
"sh_percent",
"sh_percent_pp",
"avg_goals_season",
"avg_sh_perc",
"sh_perc_diff",
"g_avg_past_2_seasons",
]
feature_combos = list(more_itertools.powerset(test_cols))
import pickle
with open("column_combos", "wb") as fp: # Pickling
pickle.dump(feature_combos, fp)
def powerset_max_length(candidates, length):
return filter(lambda s: len(s) <= length, powerset(candidates))
def train_parallel(env,
n_proc,
update_interval,
cache_size,
n_episodes,
n_steps,
l_rate,
d_rate,
max_e_rate,
min_e_rate,
e_d_rate,
r_threshold=None):
"""Perform parallel q-learning on env."""
# Split up environment grid according to number of processes
corridors_split = np.array_split(env.corridors, n_proc)
possible_actions_split = list(
split_into(env.possible_actions, [len(c) for c in corridors_split]))
states_split = list(
split_into(env.states, [
len(c) * len(list(powerset(env.pick_pts))) for c in corridors_split
]))
ray.init() # start up ray
main = Main.remote(env=env, n_proc=n_proc,
r_threshold=r_threshold) # define main process
workers = [
Worker.options(name="worker" + str(i)).remote(
env=env,
states=states_slice,
possible_actions=actions_slice,
corridors=corridors_slice,
id=i,
grid_size=env.grid_size,
start_global=env.start,
pick_pts_global=env.pick_pts,
main=main,
update_interval=update_interval,
cache_size=cache_size,
n_episodes=n_episodes,
n_steps=n_steps,
l_rate=l_rate,
d_rate=d_rate,
max_e_rate=max_e_rate,
min_e_rate=min_e_rate,
e_d_rate=e_d_rate)
for i, (states_slice, actions_slice, corridors_slice) in enumerate(
zip(states_split, possible_actions_split, corridors_split))
] # define all workers
s = time.time()
rewards = ray.get([worker.train.remote() for worker in workers
]) # start local training process for all workers
# Since the workers do not step through the episodes synchronously, the reward value that they received from the
# global q-table at given update intervals can differ. Therefore, take the maximum value of all workers, as this
# presents the actual best optimal path at that moment.
rewards_final = list(map(max, zip(*rewards)))
exec_time = time.time() - s
q_table_final = ray.get(
main.send_q_table.remote()) # get final q-table from main process
ray.shutdown() # shutdown ray
actions_final, _ = q_table_to_action_list(
q_table_final, env) # get final action list from q-table
return actions_final, rewards_final, exec_time
def values(self):
return (set(v) for v in mitt.powerset('abc'))
