def doIt(infile):
f = open(infile)
n = int(f.readline())
for i in range(1,n+1):
n, k = f.readline().split(' ')
n, k = int(n), int(k)
a, b, c, r = f.readline().split(' ')
a, b, c, r = int(a), int(b), int(c), int(r)
m = [a]
prev = a
for j in range(1, k):
e = (b*prev+c)%r
m.append(e)
prev = e
msorted = m[:]
msorted.sort()
for j in range(k, n):
for l in range(n):
if contains(msorted, l) == False:
break
m.append(l)
x = m.pop(0)
del msorted[index(msorted, x)]
bisect.insort_left(msorted, l)
ans = m[-1]
print("Case #{0}: {1}".format(i, ans))
def add(self, individual: Individual):
"""Add an Individaul to the population."""
if individual.total_error is None:
self.unevaluated.append(individual)
else:
insort_left(self.evaluated, individual)
return self
def __add(self, member, score):
""" Private method to add the member and score to the sorted set.
This trusts that the member does not already exist in the sorted set.
"""
bisect.insort_left(self._members, (member, score))
bisect.insort_left(self._scores, (score, member))
def connect(self, func, filter=None, priority=0, count=0):
""" Add a listener for the event.
Parameters
----------
cls : class
The class of events for which the listener is registered.
func : callable
A callable to be called when the event is emitted. The function
should expect one argument which is the event instance which was
emitted.
filter : dict
Filters to match for before calling the listener. The listener is
called only when the event matches all of the filter .
Filter specification:
- key: string which is extended name of an attribute of the
event instance. For example string 'source.name' will be
the attribute `event.source.name`
- value: the value of the specified attribute.
priority : int
The priority of the listener. Higher priority listeners are called
before lower priority listeners.
count : int
A unique integer to break a tie in priority. This is generally
an incremental number assigned by EventManager in order of
registration.
Note
----
Reconnecting an already connected listener will disconnect the
old listener. This may have rammifications in changing the filters
and the priority.
The filtering is added so that future optimizations can be done
on specific events with large number of handlers. For example there
should be a fast way to filter key events to specific listeners rather
than iterating through all listeners.
"""
id = self.get_id(func)
if id in self._priority_info:
# Ensure a function is connected only once.
# Reconnecting will update its sequence and filters.
self._disconnect(id)
with self._priority_list_lock:
sub = self._get_notifier(func, self._listener_deleted)
if filter:
self._listener_filters[id] = filter
for key in filter:
self._filter_keys.add(key)
key = (-priority, count, sub)
bisect.insort_left(self._priority_list, key)
self._priority_info[id] = key
def get_tree_freq_from(filename, chunk_size=1):
if chunk_size == 1:
f = open(filename, 'rb') # input file
a = bytearray(f.read()) # creates an array of bytes with contents of 'filename'
c = Counter(a) # counts the occurrences of each byte in the given file
c_ord = sorted(c.iteritems(), key=operator.itemgetter(1))
L = get_list_from_dict(c_ord) # list of node objects that will remain sorted during the algorithm
for e in L:
print e,
print
n = len(L)
for i in xrange(n-1):
new_node = HuffmanNode('*') # non-terminal node.
new_node.left = L.pop(0) # take the the two with the lowest frequency
print 'poping(L):', new_node.left
new_node.right = L.pop(0)
print 'poping(R):', new_node.right
new_node.freq = new_node.left.freq + new_node.right.freq
bisect.insort_left(L, new_node) # append the new node in the right place so the list will remain sorted.
print '->Insering:', new_node
print 'New list:'
for e in L:
print e,
print
return L.pop(0) # returns the root of the huffman tree
#print 'Most freq.:', c_ord[len(c_ord)-1] # shows the most frequent byte
#print 'Least freq.:', c_ord[0] # shows the least frequent byte
else: # @TODO: compression using blocks of bytes as words for higer compression ratio com bigger files.
pass
def add(self, playerStat):
if id(playerStat) in self.__playerId :
return False
key = self.key(playerStat.playerId)
bisect.insort_left(self.__playerStats, [key, playerStat])
self.__playerId[id(playerStat)] = playerStat
return True
def redo(self):
part = self.part
id_num = self.id_num
origin_pt = self.origin_pt
self.old_limits = part.getVirtualHelixOriginLimits()
# Set direction to (0, 0, 1) for now
vh = part._createHelix(id_num, origin_pt, self.direction, self.length, self.color)
if self.safe: # update all neighbors
if not self.neighbors:
self.neighbors = list(
part._getVirtualHelixOriginNeighbors(id_num, self.threshold))
neighbors = self.neighbors
part.vh_properties.loc[id_num, 'neighbors'] = str(list(neighbors))
for neighbor_id in neighbors:
nneighbors = literal_eval(
part.getVirtualHelixProperties(neighbor_id, 'neighbors')
)
bisect.insort_left(nneighbors, id_num)
part.vh_properties.loc[neighbor_id, 'neighbors'] = str(list(nneighbors))
else:
neighbors = self.neighbors
if self.keys is not None:
'''NOTE: DON'T bother UndoCommand-ing this because the helix is
deleted on the undo. Causes a segfault on MacOS if you do
'''
part._setVirtualHelixProperties(id_num,
self.keys, self.values,
emit_signals=False)
part.resetCoordinates(id_num)
part.partVirtualHelixAddedSignal.emit(part, id_num, vh, neighbors)
def getDirEntries(self):
""" returns dictionary of dir entries, keyed by dir name """
entriesDict = {}
# First, we grab a dir listing of the target, setting entry attributes
for entryName in self.entries:
if entryName == rdiffDataDirName: continue
entryPath = joinPaths(self.repo, self.dirPath, entryName)
newEntry = dirEntry(entryName, os.path.isdir(entryPath), os.lstat(entryPath)[6], True,
[self._getLastChangedBackupTime(entryName)])
entriesDict[entryName] = newEntry
# Go through the increments dir. If we find any files that didn't exist in dirPath (i.e. have been deleted), add them
for entryFile in self.incrementEntries:
entry = incrementEntry(entryFile)
entryName = entry.getFilename()
if entry.shouldShowIncrement() or entry.isMissingIncrement():
entryDate = entry.getDate()
if not entry.isSnapshotIncrement():
if entry.isMissingIncrement():
entryDate = self._getFirstBackupAfterDate(entry.getDate())
else:
entryDate = entry.getDate()
if not entryName in entriesDict.keys():
entryPath = joinPaths(self.repo, rdiffIncrementsDirName, self.dirPath, entryName)
newEntry = dirEntry(entryName, os.path.isdir(entryPath), 0, False, [entryDate])
entriesDict[entryName] = newEntry
else:
if not entryDate in entriesDict[entryName].changeDates:
bisect.insort_left(entriesDict[entryName].changeDates, entryDate)
return entriesDict
def dump_subset(self,filename,append=False,verbose=False):
"""
dump a textual representation of the decoded
data in the currently loaded subset to a file.
If `append=True`, append to an existing file
(otherwise over-write file).
If `verbose=True`, more complete but harder to read info is written.
`ncepbufr.open.load_subset` must be called before
trying to print the decoded subset using `ncepbufr.open.dump_subset`.
"""
lunout = random.choice(_funits)
if not append:
iret = _bufrlib.fortran_open(filename,lunout,'formatted','rewind')
else:
iret = _bufrlib.fortran_open(filename,lunout,'formatted','append')
if iret != 0:
msg='error opening %s' % filename
if not verbose:
_bufrlib.ufdump(self.lunit,lunout)
else:
_bufrlib.ufbdmp(self.lunit,lunout)
iret = _bufrlib.fortran_close(lunout)
if iret == 0:
bisect.insort_left(_funits,lunout)
else:
raise IOError('error closing %s' % filename)
def get_index(self, requestContext):
matches = []
for root, _, files in walk(settings.WHISPER_DIR):
root = root.replace(settings.WHISPER_DIR, '')
for base_name in files:
if fnmatch.fnmatch(base_name, '*.wsp'):
match = join(root, base_name).replace('.wsp', '').replace('/', '.').lstrip('.')
bisect.insort_left(matches, match)
# unlike 0.9.x, we're going to use os.walk with followlinks
# since we require Python 2.7 and newer that supports it
if RRDReader.supported:
for root, _, files in walk(settings.RRD_DIR, followlinks=True):
root = root.replace(settings.RRD_DIR, '')
for base_name in files:
if fnmatch.fnmatch(base_name, '*.rrd'):
absolute_path = join(settings.RRD_DIR, root, base_name)
base_name = splitext(base_name)[0]
metric_path = join(root, base_name)
rrd = RRDReader(absolute_path, metric_path)
for datasource_name in rrd.get_datasources(absolute_path):
match = join(metric_path, datasource_name).replace('.rrd', '').replace('/', '.').lstrip('.')
if match not in matches:
bisect.insort_left(matches, match)
return matches
def inval(self, oid, tid):
if tid == z64:
# This is part of startup cache verification: forget everything
# about this oid.
self._remove_noncurrent_revisions(oid)
if oid in self.evicted:
del self.evicted[oid]
cur_tid = self.current.get(oid)
if cur_tid is None:
# We don't have current data, so nothing more to do.
return
# We had current data for oid, but no longer.
self.invals += 1
self.total_invals += 1
del self.current[oid]
if tid == z64:
# Startup cache verification: forget this oid entirely.
self._remove(oid, cur_tid)
return
# Our current data becomes non-current data.
# Add the validity range to the list of non-current data for oid.
assert cur_tid < tid
L = self.noncurrent.setdefault(oid, [])
bisect.insort_left(L, (cur_tid, tid))
# Update the end of oid's validity range in its CircularCacheEntry.
e = self.key2entry[oid, cur_tid]
assert e.end_tid == z64
e.end_tid = tid
def write(self, oid, size, start_tid, end_tid, evhit=0):
if end_tid == z64:
# Storing current revision.
if oid in self.current: # we already have it in cache
if evhit:
import pdb; pdb.set_trace()
raise ValueError('WTF')
return
self.current[oid] = start_tid
self.writes += 1
self.total_writes += 1
self.add(oid, size, start_tid)
return
if evhit:
import pdb; pdb.set_trace()
raise ValueError('WTF')
# Storing non-current revision.
L = self.noncurrent.setdefault(oid, [])
p = start_tid, end_tid
if p in L:
return # we already have it in cache
bisect.insort_left(L, p)
self.writes += 1
self.total_writes += 1
self.add(oid, size, start_tid, end_tid)
def main():
n = int(input())
a = list(map(int, input().split()))
d = Counter(a)
min_value = min(a)
h = math.log(n, 2)
if len(set(a)) != n or d[min_value] != h + 1:
print("NO1")
return 0
num_key = defaultdict(list)
for key, num in d.items():
if num > h + 1:
print("NO2")
return 0
bisect.insort_left(num_key[num], key)
ans = [0] * len(a)
if not dfs(0, min_value, h + 1, num_key, ans):
print("NO3")
return
print("YES")
print(*ans)
return 0
def weights_matrix(x_query, X, alpha):
if isinstance(x_query, np.matrix):
x_query = x_query.A
m = len(X) # number of data points
r = int(round(alpha * m)) # size of local region
W = np.identity(m) # skeleton for weights matrix
sorted_list = []
for i,row in enumerate(X):
delta_norm = vector_norm(row - x_query)
insort_left(sorted_list, delta_norm)
W[i][i] = delta_norm
# computing normalization constant based on alpha
h_i = 1 / sorted_list[r - 1]
# normalizing weights matrix
W = W * h_i
# applying tricube weight function to weights matrix
for i in range(0, len(W)):
W[i][i] = (1 - (W[i][i] ** 3)) ** 3 if W[i][i] < 1 else 0
return np.mat(W)
def setdefault(self, key, value):
"""If key is in the dictionary, returns its value;
otherwise adds the key with the given value which is also
returned
>>> d = SortedDict(dict(s=1, a=2, n=3, i=4, t=5, y=6))
>>> d.setdefault("n", 99)
3
>>> d.values()
[2, 4, 3, 1, 5, 6]
>>> d.setdefault("r", -20)
-20
>>> d.items()[2:]
[('n', 3), ('r', -20), ('s', 1), ('t', 5), ('y', 6)]
>>> d.setdefault("@", -11)
-11
>>> d.setdefault("z", 99)
99
>>> d.setdefault("m", 50)
50
>>> d.keys()
['@', 'a', 'i', 'm', 'n', 'r', 's', 't', 'y', 'z']
"""
if key not in self.__dict:
bisect.insort_left(self.__keys, key)
return self.__dict.setdefault(key, value)
def __sort_registry(self, svc_ref):
"""
Sorts the registry, after the update of the sort key of given service
reference
:param svc_ref: A service reference with a modified sort key
"""
with self.__svc_lock:
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Remove current references
bundle_services = self.__bundle_svc[svc_ref.get_bundle()]
idx = bisect.bisect_left(bundle_services, svc_ref)
del bundle_services[idx]
for spec in svc_ref.get_property(OBJECTCLASS):
# Use bisect to remove the reference (faster)
spec_refs = self.__svc_specs[spec]
idx = bisect.bisect_left(spec_refs, svc_ref)
del spec_refs[idx]
# ... use the new sort key
svc_ref.update_sort_key()
bisect.insort_left(bundle_services, svc_ref)
for spec in svc_ref.get_property(OBJECTCLASS):
# ... and insert it again
spec_refs = self.__svc_specs[spec]
bisect.insort_left(spec_refs, svc_ref)
def construct_db(assets_dir):
## Creating a database of text labels from game assets dir given
## the database has a following structure:
## {"section": { "label" :
## { "files were it used" : [list of fields were it used in file] } } }
print("Scanning assets at " + assets_dir)
db = dict()
db[""] = dict()
foi = list()
endings = tuple(files_of_interest.keys())
for subdir, dirs, files in walk(assets_dir):
for thefile in files:
if thefile.endswith(endings):
foi.append(normpath(join(subdir, thefile)))
with Pool() as p:
r = p.imap_unordered(parseFile, foi)
for chunk in r:
for sec, val, fname, path in chunk:
if sec not in db:
db[sec] = dict()
if val not in db[sec]:
db[sec][val] = dict()
filename = normpath(relpath(abspath(fname), abspath(assets_dir)))
if filename not in db[sec][val]:
db[sec][val][filename] = list()
if path not in db[sec][val][filename]:
insort_left(db[sec][val][filename], path)
return db
def insert(self, srtkey_hndl, allkeyonly=False):
"""
Insert a node. Given is a tuple (sortkey, handle), and this is added
in the correct place, while the hndl2index map is updated.
Returns the path of the inserted row
:param srtkey_hndl: the (sortkey, handle) tuple that must be inserted
:type srtkey_hndl: sortkey key already transformed by self.sort_func, object handle
:Returns: path of the row inserted in the treeview
:Returns type: Gtk.TreePath or None
"""
if srtkey_hndl[1] in self._hndl2index:
print(('WARNING: Attempt to add row twice to the model (%s)' %
srtkey_hndl[1]))
return
if not self._identical:
bisect.insort_left(self._fullhndl, srtkey_hndl)
if allkeyonly:
#key is not part of the view
return None
insert_pos = bisect.bisect_left(self._index2hndl, srtkey_hndl)
self._index2hndl.insert(insert_pos, srtkey_hndl)
#make sure the index map is updated
for srt_key,hndl in self._index2hndl[insert_pos+1:]:
self._hndl2index[hndl] += 1
self._hndl2index[srtkey_hndl[1]] = insert_pos
#update self.__corr so it remains correct
if self._reverse:
self.__corr = (len(self._index2hndl) - 1, -1)
return Gtk.TreePath((self.real_path(insert_pos),))
def translocate_brownian(self):
# if self.on_promoter:
# if random.uniform(0.0, 1.0) <= self.Pforward:
# newdraw = random.uniform(0.0,1.0)
# moves = self.forward_moves
# bisect.insort_left(moves, [newdraw, newdraw])
# self.position += moves[zip(*moves)[1].index(newdraw) + 1][1]
# return
# else:
draw = random.uniform(0.0, 1.0)
if draw <= self.Pforward:
if self.frontblocked:
return
if len(self.forward_moves) > 1:
newdraw = random.uniform(0.0,1.0)
moves = self.forward_moves
bisect.insort_left(moves, [newdraw, newdraw])
self.position += moves[zip(*moves)[1].index(newdraw) + 1][1]
return
elif self.Pforward < draw <= self.Pforward + self.Pbackward:
if self.backblocked:
return
if len(self.backward_moves) > 1:
newdraw = random.uniform(0.0,1.0)
moves = self.backward_moves
bisect.insort_left(moves, [newdraw, newdraw])
self.position -= moves[zip(*moves)[1].index(newdraw) + 1][1]
return
else:
return
def on_time_step(self, t, dt):
if self._next_spike_time is None:
self._next_spike_time = t
if self._pivot.get_next_spike_time() is None:
self._pivot.on_time_step(t, dt)
elif self._next_spike_time > t + 1.5 * dt:
return False
else:
self._spikes_history.append(t + dt)
while len(self._event_buffer) < self._ideal_buffer_size:
while self._last_pivot_index >= len(self._pivot.get_spikes_history()):
t0 = t
while t0 + dt < self._pivot.get_next_spike_time():
t0 += dt
old_len = len(self._pivot.get_spikes_history())
self._pivot.on_time_step(t0, dt)
assert old_len + 1 == len(self._pivot.get_spikes_history())
prev = self._pivot.get_spikes_history()[self._last_pivot_index - 1] if self._last_pivot_index > 0 else 0.0
bisect.insort_left(self._event_buffer, self._pivot.get_spikes_history()[self._last_pivot_index] - prev)
self._last_pivot_index += 1
pivot_next_time = self._pivot.get_spikes_history()[
bisect.bisect_left(self._pivot.get_spikes_history(), self._next_spike_time + dt)
]
to_pivot_time = pivot_next_time - self._next_spike_time
assert to_pivot_time > 0
correlation_coefficient = self._deviation.next_event()
idx = self.choose_event_index(self._event_buffer, to_pivot_time, correlation_coefficient)
assert idx >= 0 and idx < len(self._event_buffer)
# assert abs(self._next_spike_time + self._event_buffer[idx] - pivot_next_time) < 0.0001
self._next_spike_time += self._event_buffer[idx]
self._event_buffer.pop(idx)
assert self._next_spike_time > t + dt
return True
def setMenu(self, component, menu, label, help, index=999999):
"""Set pulldown menu data."""
if menu not in self.menuNames:
self.menuNames.append(menu)
if menu not in self.menus:
self.menus[menu] = []
bisect.insort_left(self.menus[menu], (index, component, label, help))
def add(self, fn, rootdir):
pf = _PicFile(fn,rootdir)
samefile = self.findsamefile(pf)
#根据MD5去找
if samefile:
pf.exif=samefile.exif
#更新其日期而已这样后面才能找到
if len(self.groups)==0:
self.groups.append(_PicGroup.newone(self.path,pf))
return
for g in self.groups:
if pf<=g:
#如果pf比第一个组还要小，那么就加入到第一个组了
#如果pf在两个组中间，则添加到后一个组里面
#如果pf比任何一个组都要大，则添加到最后一个组
break
re, refpf = g.add(pf)
if re=="Old":
gprint(DIM+"O")
self.old.append( (pf,refpf) )
elif re=="Overwrite":
gprint(YELLOW+"W")
self.overwrite.append( (pf,refpf) )
else: #'New'
self.md5dict[pf.size].append( pf )
gprint(GREEN+"N")
if(g.count()>=self.max):
ng=g.split()
if ng is not None:
bisect.insort_left(self.groups,ng)
def hhistplot(counter, highlighted, indent = "", pipe = sys.stdout, w = 20):
BLOCK = "█"
LEFT_HALF_BLOCK = "▌"
try:
W, H = os.get_terminal_size()
except (OSError, AttributeError):
W, H = 80, 24
plot_w = min(w, W - 10 - len(indent))
scale = plot_w / max(counter.values())
data = sorted(counter.items())
if highlighted != None and highlighted not in counter:
bisect.insort_left(data, (highlighted, 0))
header_width = max(len(str(value)) for _, value in data)
for key, value in data:
label = str(key)
bar_size = int(value * scale)
header = indent + "[" + str(value).rjust(header_width) + "] "
bar = (BLOCK * bar_size if bar_size > 0 else LEFT_HALF_BLOCK) + " "
label_avail_space = W - 2 - len(bar) - len(header)
if len(label) > label_avail_space:
label = label[:label_avail_space - 3] + "..."
line = bar + label
if key == highlighted:
line = color.highlight(line, color.term.PLAIN, color.term.RED)
pipe.write(header + line + "\n")
def register(
self, bundle, classes, properties, svc_instance, factory, prototype
):
"""
Registers a service.
:param bundle: The bundle that registers the service
:param classes: The classes implemented by the service
:param properties: The properties associated to the service
:param svc_instance: The instance of the service
:param factory: If True, the given service is a service factory
:param prototype: If True, the given service is a prototype service
factory (the factory argument is considered True)
:return: The ServiceRegistration object
"""
with self.__svc_lock:
# Prepare properties
service_id = self.__next_service_id
self.__next_service_id += 1
properties[OBJECTCLASS] = classes
properties[SERVICE_ID] = service_id
properties[SERVICE_BUNDLEID] = bundle.get_bundle_id()
# Compute service scope
if prototype:
properties[SERVICE_SCOPE] = SCOPE_PROTOTYPE
elif factory:
properties[SERVICE_SCOPE] = SCOPE_BUNDLE
else:
properties[SERVICE_SCOPE] = SCOPE_SINGLETON
# Force to have a valid service ranking
try:
properties[SERVICE_RANKING] = int(properties[SERVICE_RANKING])
except (KeyError, ValueError, TypeError):
properties[SERVICE_RANKING] = 0
# Make the service reference
svc_ref = ServiceReference(bundle, properties)
# Make the service registration
svc_registration = ServiceRegistration(
self.__framework, svc_ref, properties, self.__sort_registry
)
# Store service information
if prototype or factory:
self.__svc_factories[svc_ref] = (svc_instance, svc_registration)
# Also store factories, as they must appear like any other service
self.__svc_registry[svc_ref] = svc_instance
for spec in classes:
spec_refs = self.__svc_specs.setdefault(spec, [])
bisect.insort_left(spec_refs, svc_ref)
# Reverse map, to ease bundle/service association
bundle_services = self.__bundle_svc.setdefault(bundle, set())
bundle_services.add(svc_ref)
return svc_registration
def getnum():
for c in A:
bisect.insort_left(result, c)
while len(A) > 0:
minvalue = min(A)
A.remove(minvalue)
tm_ti = time.clock()
keypos = bisect.bisect_right(result, minvalue)
cp_result = copy.copy(result[keypos:])
tm_ti = time.clock()
for c in cp_result:
tmp = c | minvalue
use_tmp = gmpy2.digits(tmp, 2)
use_tmp = "0" * (genroot.prp_num - len(use_tmp)) + use_tmp
if (genroot.getsup(use_tmp))[1] < sup_f:
continue
if tmp == c:
continue
if tmp >= MAXVALUE:
break
pos = bisect.bisect_right(result, tmp)
if result[pos - 1] != tmp:
bisect.insort_left(result, tmp)
print("Topology numbers:", len(result), 'used time for sort:%.3f seconds' % (time.clock() - tm_ti))
def add_message(self, room_id, message):
assert room_id in self.volt
entry = self.volt[room_id]
bisect.insort_left(entry, message) #Tempolary. O(n), slow.
self.volt[room_id] = entry
def __init__(self, db, filename):
Binary.__init__(self)
self.db = db
self.pe = PE2(filename, fast_load=True)
self.__data_sections = []
self.__data_sections_content = []
self.__exec_sections = []
self.set_arch_name()
base = self.pe.OPTIONAL_HEADER.ImageBase
for s in self.pe.sections:
start = base + s.VirtualAddress
is_data = self.__section_is_data(s)
is_exec = self.__section_is_exec(s)
if is_data or is_exec:
bisect.insort_left(self._sorted_sections, start)
self._abs_sections[start] = SectionAbs(
s.Name.decode().rstrip(' \0'),
start,
s.Misc_VirtualSize,
s.SizeOfRawData,
is_exec,
is_data,
s.get_data())
def _add_handler(
self, pattern, handler_class, path=None, kwargs=None, priority=100, code_filename=None, code_lineno=None
):
if not self.handlers:
host_pattern = re.compile(r".*$")
handlers = []
self.handlers.append((host_pattern, handlers))
else:
host_pattern, handlers = self.handlers[0]
assert host_pattern.pattern == ".*$"
assert pattern is not None and handler_class is not None
urlspec = OrderedURLSpec(
priority,
pattern,
handler_class,
path=path,
kwargs=kwargs,
code_filename=code_filename,
code_lineno=code_lineno,
)
bisect.insort_left(handlers, urlspec)
def zincrby(self, member, amount=1):
""" Finds member in the sorted set and increments its score.
If no member is found, then member is insert and given a score of
``amount``.
"""
i = bisect.bisect_left(self._members, (member, None))
try:
# Check if the next member is the same. If it is, then update the score
if self._members[i][0] == member:
j = self._scores.index((self._members[i][1], self._members[i][0]))
new_score = self._members[i][1] + amount
self._scores[j] = (new_score, member)
self._members[i] = (member, new_score)
elif self._members[i + 1][0] == member:
j = self._scores.index((self._members[i + 1][1], self._members[i + 1][0]))
new_score = self._members[i][1] + amount
self._scores[j] = (new_score, member)
self._members[i + 1] = (member, new_score)
else:
new_score = amount
self._members.insert(i, (member, amount))
bisect.insort_left(self._scores, (amount, member))
except IndexError:
new_score = amount
self._members.insert(i, (member, amount))
bisect.insort_left(self._scores, (amount, member))
return new_score
def redo(self):
part = self.part
id_num = self.id_num
origin_pt = self.origin_pt
# need to always reserve an id
vh = part._createHelix(id_num, origin_pt, (0, 0, 1), self.length, self.color)
if self.safe: # update all neighbors
if not self.neighbors:
self.neighbors = part._getVirtualHelixOriginNeighbors(id_num, self.threshold)
neighbors = self.neighbors
part.vh_properties.loc[id_num, 'neighbors'] = str(list(neighbors))
for neighbor_id in neighbors:
nneighbors = literal_eval(
part.getVirtualHelixProperties(neighbor_id, 'neighbors')
)
bisect.insort_left(nneighbors, id_num)
part.vh_properties.loc[neighbor_id, 'neighbors'] = str(list(nneighbors))
else:
neighbors = self.neighbors
if self.keys is not None:
part.setVirtualHelixProperties(id_num,
self.keys, self.values,
safe=False)
part.resetCoordinates(id_num)
part.partVirtualHelixAddedSignal.emit(part, id_num, vh, neighbors)
def simulate_population(population, NRUNS, fixed_parameters, stylized_facts_real_life):
"""
Simulate a population of parameter spaces for the sim-fin model
:param population: population of parameter spaces used to simulate model
:param number_of_runs: number of times the simulation should be run
:param simulation_time: amount of days which will be simulated for each run
:param fixed_parameters: dictionary of parameters which will not be changed
:return: simulated population, average population fitness
"""
simulated_population = []
for idx, individual in enumerate(population):
# combine individual parameters with fixed parameters
parameters = individual.parameters.copy()
params = fixed_parameters.copy()
params.update(parameters)
stylized_facts = {'autocorrelation': np.inf, 'kurtosis': np.inf, 'autocorrelation_abs': np.inf,
'hurst': np.inf, 'av_dev_from_fund': np.inf}
# simulate the model
#traders = []
obs = []
for seed in range(NRUNS):
traders, orderbook = init_objects.init_objects(params, seed)
traders, orderbook = simfinmodel.sim_fin_model(traders, orderbook, params, seed)
# traders.append(traders)
obs.append(orderbook)
# store simulated stylized facts
mc_prices, mc_returns, mc_autocorr_returns, mc_autocorr_abs_returns, mc_volatility, mc_volume, mc_fundamentals = organise_data(obs)
mc_dev_fundamentals = (mc_prices - mc_fundamentals) / mc_fundamentals
mean_autocor = []
mean_autocor_abs = []
mean_kurtosis = []
long_memory = []
#long_memory_deviation_fundamentals = []
av_deviation_fundamental = []
for col in mc_returns:
mean_autocor.append(np.mean(mc_autocorr_returns[col][1:])) #correct?
mean_autocor_abs.append(np.mean(mc_autocorr_abs_returns[col][1:]))
mean_kurtosis.append(mc_returns[col][2:].kurtosis())
long_memory.append(hurst(mc_prices[col][2:]))
av_deviation_fundamental.append(np.mean(mc_dev_fundamentals[col][1:]))
#long_memory_deviation_fundamentals.append(hurst(mc_dev_fundaments[col][2:]))
#stylized_facts['autocorrelation'] = np.mean(mean_autocor)
stylized_facts['kurtosis'] = np.mean(mean_kurtosis)
stylized_facts['autocorrelation_abs'] = np.mean(mean_autocor_abs)
stylized_facts['hurst'] = np.mean(long_memory)
stylized_facts['av_dev_from_fund'] = np.mean(av_deviation_fundamental)
# create next generation individual
cost = cost_function(stylized_facts_real_life, stylized_facts)
next_gen_individual = Individual(parameters, stylized_facts, cost)
# insert into next generation population, lowest score (best) to the left
bisect.insort_left(simulated_population, next_gen_individual)
average_population_fitness = average_fitness(simulated_population)
return simulated_population, average_population_fitness
def insort(self, arr):
bisect.insort_left(self._arrs, arr)
def add_article(self, article: Article):
insort_left(self._articles, article)
self._articles_index[article.id] = article
def add_major(self, state: State) -> None:
# NOTE: major means the interval stubs
self.add(state)
bisect.insort_left(self.major_index, state.index)
def append(self, value):
'''
Add a new value to the internal list of values.
'''
with self._s:
bisect.insort_left(self._d, value)
def add(self, item: Asset):
"""
Add asset to bank
:return: Nothing
"""
bisect.insort_left(self.asset_list, item)
complexity_relationship =\
['MAX_Complexity',
'MAX_Complexity_1',
'MAX_Complexity_3',
'MAX_Complexity_6',
'MAX_Complexity_12']
# complexity variables
for variable in complexity_relationship:
input_data.loc[:, variable] = input_data.loc[:, variable].astype(int)
# transform categorical variable using Label encoder
list_label_enc = []
for column in categorical_variables:
le = preprocessing.LabelEncoder()
le.fit(input_data[column].astype(str))
le_classes = le.classes_.tolist()
bisect.insort_left(le_classes, '<unknown>')
le.classes_ = le_classes
list_label_enc.append(le)
input_data[column] = le.transform(input_data[column].astype(str))
default_values_for_missing = \
default_values_for_missing.append(
{'column_name': variable,
'value': le.classes_.index('<unknown>')},
ignore_index=True)
print(default_values_for_missing)
# save encoders list to disk
with open(root_folder + model_object_folder + encoders_pickle_file,
"wb") as pickle_encoders_file:
pickle.dump(list_label_enc, pickle_encoders_file)
def recordTweet(self, tweetName: str, time: int) -> None:
bisect.insort_left(self.user[tweetName], time)
def append(self, line_info):
# self.__lines.append(line_info)
insort_left(self.__lines, line_info)
def _find_series(self, tags, requestContext=None):
selector = None
selector_cnt = None
filters = []
# loop through tagspecs, look for best spec to use as selector
for tagspec in tags:
(tag, operator, spec) = self.parse_tagspec(tagspec)
if operator == '=':
matches_empty = spec == ''
if not matches_empty:
cnt = self.r.scard('tags:' + tag + ':values:' + spec)
if not selector or selector[1] != '=' or selector_cnt > cnt:
if selector:
filters.append(selector)
selector = (tag, operator, spec)
selector_cnt = cnt
continue
filters.append((tag, operator, spec))
elif operator == '=~':
pattern = re.compile(spec)
matches_empty = bool(pattern.match(''))
if not matches_empty and (not selector or selector[1] != '='):
cnt = self.r.scard('tags:' + tag + ':values')
if not selector or selector_cnt > cnt:
if selector:
filters.append(selector)
selector = (tag, operator, pattern)
selector_cnt = cnt
continue
filters.append((tag, operator, pattern))
elif operator == '!=':
matches_empty = spec != ''
if not matches_empty and (not selector or selector[1] != '='):
cnt = self.r.scard('tags:' + tag + ':values')
if not selector or selector_cnt > cnt:
if selector:
filters.append(selector)
selector = (tag, operator, spec)
selector_cnt = cnt
continue
filters.append((tag, operator, spec))
elif operator == '!=~':
pattern = re.compile(spec)
matches_empty = not pattern.match('')
if not matches_empty and (not selector or selector[1] != '='):
cnt = self.r.scard('tags:' + tag + ':values')
if not selector or selector_cnt > cnt:
if selector:
filters.append(selector)
selector = (tag, operator, pattern)
selector_cnt = cnt
continue
filters.append((tag, operator, pattern))
else:
raise ValueError("Invalid operator %s" % operator)
if not selector:
raise ValueError("At least one tagspec must not match the empty string")
# get initial list of series
(tag, operator, spec) = selector
# find list of values that match the tagspec
values = None
if operator == '=':
values = [spec]
elif operator == '=~':
# see if we can identify a literal prefix to filter by in redis
match = None
m = re.match('([a-z0-9]+)([^*?|][^|]*)?$', spec.pattern)
if m:
match = m.group(1) + '*'
values = [value for value in self.r.sscan_iter('tags:' + tag + ':values', match=match) if spec.match(value) is not None]
elif operator == '!=':
values = [value for value in self.r.sscan_iter('tags:' + tag + ':values') if value != spec]
elif operator == '!=~':
values = [value for value in self.r.sscan_iter('tags:' + tag + ':values') if spec.match(value) is None]
# if this query matched no values, just short-circuit since the result of the final intersect will be empty
if not values:
return []
results = []
# apply filters
operators = ['=','!=','=~','!=~']
filters.sort(key=lambda a: operators.index(a[1]))
for series in self.r.sunion(*['tags:' + tag + ':values:' + value for value in values]):
parsed = self.parse(series)
matched = True
for (tag, operator, spec) in filters:
value = parsed.tags.get(tag, '')
if (
(operator == '=' and value != spec) or
(operator == '=~' and spec.match(value) is None) or
(operator == '!=' and value == spec) or
(operator == '!=~' and spec.match(value) is not None)
):
matched = False
break
if matched:
bisect.insort_left(results, series)
return results
myset = {"apple", "banana", "cherry"}
myset = set([1,2,3])
set1 | set2 #union, set1.union(set2); intersection: &; difference: -;
from collections import defaultdict
d = defaultdict(list) #list: [], int: 0
d = defaultdict(lambda: "Not Present")
d["a"] = 1
d["b"]
########binary search###############
import bisect
a = [1,3,5]
bisect.bisect_left(a, 2) #1. log(n)
a.insert(1,2) #a = [1,2,3,5]
bisect.insort_left(a, 2) # for insert,
####priority queue with heapq
import heapq
lo = []
hi = []
heapq.heapify(lo) #n*log(n), in place change, lo[0] is the smallest one, lo.pop(0)
heapq._heapify_max(hi)
heapq._heapreplace_max(a, 7)
heapq._heappop_max(a)
def _heappush_max(heap, item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
heapq.heappush(lo, value) #log(n) for push and pop
def simulate_population_msm(population, NRUNS, fixed_parameters, stylized_facts_real_life, weights):
"""
Simulate a population of parameter spaces for the sim-fin model
:param population: population of parameter spaces used to simulate model
:param number_of_runs: number of times the simulation should be run
:param simulation_time: amount of days which will be simulated for each run
:param fixed_parameters: dictionary of parameters which will not be changed
:return: simulated population, average population fitness
"""
simulated_population = []
for idx, individual in enumerate(population):
# combine individual parameters with fixed parameters
parameters = individual.parameters.copy()
params = fixed_parameters.copy()
params.update(parameters)
# simulate the model
obs = []
for seed in range(NRUNS):
traders, orderbook = init_objects.init_objects(params, seed)
traders, orderbook = simfinmodel.sim_fin_model(traders, orderbook, params, seed)
obs.append(orderbook)
# store simulated stylized facts
mc_prices, mc_returns, mc_autocorr_returns, mc_autocorr_abs_returns, mc_volatility, mc_volume, mc_fundamentals = organise_data(obs)
first_order_autocors = []
autocors1 = []
autocors5 = []
mean_abs_autocor = []
kurtoses = []
spy_abs_auto10 = []
spy_abs_auto25 = []
spy_abs_auto50 = []
spy_abs_auto100 = []
cointegrations = []
for col in mc_returns:
first_order_autocors.append(autocorrelation_returns(mc_returns[col][1:], 25))
autocors1.append(mc_returns[col][1:].autocorr(lag=1))
autocors5.append(mc_returns[col][1:].autocorr(lag=5))
mean_abs_autocor.append(autocorrelation_abs_returns(mc_returns[col][1:], 25))
kurtoses.append(mc_returns[col][2:].kurtosis())
spy_abs_auto10.append(mc_returns[col][1:].abs().autocorr(lag=10))
spy_abs_auto25.append(mc_returns[col][1:].abs().autocorr(lag=25))
spy_abs_auto50.append(mc_returns[col][1:].abs().autocorr(lag=50))
spy_abs_auto100.append(mc_returns[col][1:].abs().autocorr(lag=100))
cointegrations.append(cointegr(mc_prices[col][1:], mc_fundamentals[col][1:])[0])
stylized_facts_sim = np.array([
np.mean(first_order_autocors),
np.mean(autocors1),
np.mean(autocors5),
np.mean(mean_abs_autocor),
np.mean(kurtoses),
np.mean(spy_abs_auto10),
np.mean(spy_abs_auto25),
np.mean(spy_abs_auto50),
np.mean(spy_abs_auto100),
np.mean(cointegrations)
])
# create next generation individual
cost = quadratic_loss_function(stylized_facts_sim, stylized_facts_real_life, weights)
next_gen_individual = Individual(parameters, stylized_facts_sim, cost)
# insert into next generation population, lowest score (best) to the left
bisect.insort_left(simulated_population, next_gen_individual)
average_population_fitness = average_fitness(simulated_population)
return simulated_population, average_population_fitness
def track(self, x: int) -> None:
bisect.insort_left(self.stream, x)
from bisect import bisect_left, bisect_right, insort_left, insort_right
from string import ascii_lowercase
from heapq import heappush, heappop, heapify
from collections import Counter, defaultdict
from itertools import product
T = int(input())
for it in range(T):
n = int(input())
a = list(map(int, input().split()))
ans = [1] * n
qpp = []
cnt = n
for i in range(n):
insort_left(qpp,a[i]) #qpp: [0..i] 共 i+1个
#target: ans[i-1] + 1
#i-target+1 = i-ans[i-1]
if i and qpp[i - ans[i-1]] >= ans[i-1] + 1:
ans[i] = ans[i-1] + 1
else:
ans[i] = ans[i-1]
cnt -= 1
print("Case #%d:"%it, end="")
for num in ans:
print(" %d"%num, end="")
print()
def add_movie(self, movie: Movie):
if isinstance(movie, Movie):
# self._movies.append(movie)
insort_left(self._movies, movie)
self._movie_index[movie.id] = movie
#maintain a sorted list in sorted order while mutating it import bisect #adding values by finding position then inserting. Or just shortcut insort l = [x for x in range(10)] l.insert(bisect.bisect_left(l, 2.5), 2.5) bisect.insort_left(l, 3.5) print(l)
def add_bid(self, price, volume, agent):
"""Add a bid to the (price low-high, age young-old) sorted bids book"""
bid = Order(order_type='b', owner=agent, price=price, volume=volume)
bisect.insort_left(self.bids, bid)
self.update_bid_ask_spread('bid')
return bid
import bisect
N = int(input())
B = list(map(int, input().split()))
B_index = sorted([(b, _index) for _index, b in enumerate(B)])
complete = []
ans = 0
for i, (val, _index) in enumerate(B_index):
left = _index - bisect.bisect_left(complete, _index)
right = N - left - i - 1
ans += min(left, right)
bisect.insort_left(complete, _index)
print(ans)
def add(self, e):
# add the event at the proper (sorted) spot.
bisect.insort_left(self.lst, e)
path.append(v)
q.extend([x for x in d[v][::-1] if x not in path])
for j in path:
print j,
def bfs(d, start, path=[]):
q = deque()
q.append(start)
while q:
v = q.popleft()
if v not in path:
path.append(v)
q.extend([x for x in d[v] if x not in path])
for j in path:
print j,
r = lambda: sys.stdin.readline()
a, b, c = map(int, r().split())
d = {}
for i in xrange(1, a + 1):
d[i] = []
for i in xrange(0, b):
x, y = map(int, r().split())
bisect.insort_left(d[x], y)
bisect.insort_left(d[y], x)
dfs(d, c)
print ''
bfs(d, c)
def neighboring(self, alignment_info, j_pegged=None):
"""
Determine the neighbors of ``alignment_info``, obtained by
moving or swapping one alignment point
:param j_pegged: If specified, neighbors that have a different
alignment point from j_pegged will not be considered
:type j_pegged: int
:return: A set neighboring alignments represented by their
``AlignmentInfo``
:rtype: set(AlignmentInfo)
"""
neighbors = set()
l = len(alignment_info.src_sentence) - 1 # exclude NULL
m = len(alignment_info.trg_sentence) - 1
original_alignment = alignment_info.alignment
original_cepts = alignment_info.cepts
for j in range(1, m + 1):
if j != j_pegged:
# Add alignments that differ by one alignment point
for i in range(0, l + 1):
new_alignment = list(original_alignment)
new_cepts = deepcopy(original_cepts)
old_i = original_alignment[j]
# update alignment
new_alignment[j] = i
# update cepts
insort_left(new_cepts[i], j)
new_cepts[old_i].remove(j)
new_alignment_info = AlignmentInfo(
tuple(new_alignment),
alignment_info.src_sentence,
alignment_info.trg_sentence,
new_cepts,
)
neighbors.add(new_alignment_info)
for j in range(1, m + 1):
if j != j_pegged:
# Add alignments that have two alignment points swapped
for other_j in range(1, m + 1):
if other_j != j_pegged and other_j != j:
new_alignment = list(original_alignment)
new_cepts = deepcopy(original_cepts)
other_i = original_alignment[other_j]
i = original_alignment[j]
# update alignments
new_alignment[j] = other_i
new_alignment[other_j] = i
# update cepts
new_cepts[other_i].remove(other_j)
insort_left(new_cepts[other_i], j)
new_cepts[i].remove(j)
insort_left(new_cepts[i], other_j)
new_alignment_info = AlignmentInfo(
tuple(new_alignment),
alignment_info.src_sentence,
alignment_info.trg_sentence,
new_cepts,
)
neighbors.add(new_alignment_info)
return neighbors
def add(self, num):
bisect.insort_left(self._numbers, num)
n = int(input())
EP = []
S = []
for i in range(n):
a, b, c, d = map(int, input().split())
if a == c: # y軸と平行
EP.append(EndPoint(Vector2(a, min(b, d)), i, 0)) # bottom
EP.append(EndPoint(Vector2(a, max(b, d)), i, 3)) # top
S.append([Vector2(a, max(b, d)), Vector2(a, min(b, d))])
else: # x軸と平行
EP.append(EndPoint(Vector2(min(a, c), b), i, 1)) # left
EP.append(EndPoint(Vector2(max(a, c), b), i, 2)) # right
S.append([Vector2(min(a, c), b), Vector2(max(a, c), b)])
EP = sorted(EP, key=lambda x: (x.p.y, x.st))
BT = []
cnt = 0
for e in EP:
if e.st == 3: # top
indx = bisect.bisect_left(BT, e.p.x)
BT.pop(indx)
# BT.remove(e.p.x)
elif e.st == 0: # bottom
bisect.insort_left(BT, e.p.x)
elif e.st == 1: # left
l = bisect.bisect_left(BT, S[e.seg][0].x)
r = bisect.bisect_right(BT, S[e.seg][1].x)
cnt += r-l
print(cnt)
'USER_COUNTY_NAME','USER_COUNTRY_CODE','USER_CONTINENT_CODE',
'USER_TIME_ZONE','USER_REGION_CODE','USER_CITY_NAME',
'REVISION_TAGS', 'ip_prefix', 'revision_comment_category',
'revision_comment_property'
]
label_encoders = {}
for attrib in attributes_to_encode:
print 'loading %s encoder' % attrib
with open('./models/'+attrib+'_label_encoder.bin', 'rb') as f:
label_encoders[attrib] = cPickle.load(f)
for attrib in attributes_to_encode:
le = label_encoders[attrib]
classes = le.classes_.tolist()
bisect.insort_left(classes, 'other')
le.classes_ = classes
print 'mapping'
for attrib in attributes_to_encode:
classes = label_encoders[attrib].classes_
df[attrib] = df[attrib].map(lambda s: 'other' if s not in classes else s)
print 'encoding attributes'
for attrib in attributes_to_encode:
print 'encoding %s' % attrib
le = label_encoders[attrib]
df[attrib] = le.transform(df[attrib])
print 'done with %s' % attrib
print 'creating new df'
def find_k_best_moves(U, frame_array, index, i, count, M, start):
# display update
details = {
"process_id": os.getpid(),
"bacterium_index": i + 1,
"bacteria_count": len(U),
"universe_index": index + 1,
"universe_count": count,
"current_runtime": time.time() - start
}
safe_print("[PID: {process_id}] find_k_best_moves: "
"Bacterium {bacterium_index} of {bacteria_count} in "
"Universe {universe_index} of {universe_count} "
"({current_runtime:.2f} sec)".format(**details))
# Find best moves for each bacterium in U
bacterium = U[i]
bacterium.v = np.zeros(2)
bacterium.w = np.zeros(2)
k_best_moves = []
U_copy = deepcopy_list(U)
dx_space = np.linspace(-Config.MAX_X_MOTION, Config.MAX_X_MOTION,
Config.MAX_X_RESOLUTION)
dy_space = np.linspace(-Config.MAX_Y_MOTION, Config.MAX_Y_MOTION,
Config.MAX_Y_RESOLUTION)
dtheta_space = np.linspace(-Config.MAX_ROTATION, Config.MAX_ROTATION,
Config.MAX_ROTATION_RESOLUTION)
dlength_space = np.linspace(Config.MIN_LENGTH_INCREASE,
Config.MAX_LENGTH_INCREASE,
Config.LENGTH_INCREASE_RESOLUTION)
split_ratio_space = np.linspace(Config.SPLIT_RATIO_BEGINNING,
Config.SPLIT_RATIO_END,
Config.SPLIT_RATIO_RESOLUTION)
for dx in dx_space:
for dy in dy_space:
for dtheta in dtheta_space:
for dlength in dlength_space:
bacterium_copy = deepcopy(bacterium)
bacterium_copy.pos += np.array([dx, dy, 0])
bacterium_copy.theta += dtheta
bacterium_copy.length += dlength
bacterium_copy.update()
temp = U_copy[i]
U_copy[i] = bacterium_copy
collisionEventsHandler.run2(U_copy, i, M)
U_copy[i] = temp
c = cost(frame_array, [bacterium_copy])
bisect.insort_left(k_best_moves,
(c, dx, dy, dtheta, dlength))
# splitting
to_insert = []
for c, dx, dy, dtheta, dlength in k_best_moves:
bacterium_copy = deepcopy(bacterium)
bacterium_copy.pos += np.array([dx, dy, 0])
bacterium_copy.theta += dtheta
bacterium_copy.length += dlength
bacterium_copy.update()
if bacterium_copy.length > Config.MAX_LENGTH_BEFORE_SPLIT:
for split_ratio in split_ratio_space:
bacterium_copy_2 = deepcopy(bacterium_copy)
new_bacterium = split(bacterium_copy_2, split_ratio)
if (bacterium_copy_2.length < Config.MIN_LENGTH
or new_bacterium.length < Config.MIN_LENGTH):
continue
c = cost(frame_array, [bacterium_copy_2, new_bacterium]) + 5
to_insert.append((c, dx, dy, dtheta, dlength, split_ratio))
for e in to_insert:
bisect.insort_left(k_best_moves, e)
# result extracted from k_best_moves
results = [e[1:] for e in k_best_moves]
return (index, i, results)
while lo < hi:
mid = (lo+hi)//2
if a[mid] < x: lo = mid+1
else: hi = mid
return lo
def bisect_right(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if x < a[mid]: hi = mid
else: lo = mid+1
return lo
'''
import bisect
help(bisect)
a = [0,1,1,3,4]
print(len(a))
print(bisect.bisect_left(a, 1))
print(bisect.bisect_right(a, 1))
print(bisect.bisect_left(a, -1))
print(bisect.bisect_left(a, 10))
bisect.insort_left(a, 6)
print(a)
def _eliminationOrder_OLD(gm, orderMethod=None, nExtra=-1, cutoff=inf, priority=None, target=None):
"""Find an elimination order for a graphical model
Args:
gm (GraphModel): A graphical model object
method (str): Heuristic method; one of {'minfill','wtminfill','minwidth','wtminwidth','random'}
nExtra (int): Randomly select eliminated variable from among the best plus nExtra; this adds
randomness to the order selection process. 0 => randomly from best; -1 => no randomness (default)
cutoff (float): Quit early if ``score`` exceeds a user-supplied cutoff value (returning ``target, cutoff``)
target (list): If the identified order is better than cutoff, write it directly into passed ``target`` list
priority (list, optional): Optional list of variable priorities; lowest priority variables are
eliminated first. Useful for mixed elimination models, such as marginal MAP inference tasks.
Returns:
list: The identified elimination order
float: The "score" of this ordering
Using ``target`` and ``cutoff`` one can easily search for better orderings by repeated calls:
>>> ord, score = eliminationOrder(model, 'minfill', nExtra=2, cutoff=score, target=ord)
"""
import bisect
orderMethod = 'minfill' if orderMethod is None else orderMethod.lower()
priority = [1 for x in gm.X] if priority is None else priority
if orderMethod == 'minfill': score = lambda adj,Xj: sum([0.5*len(adj[Xj]-adj[Xk]) for Xk in adj[Xj]])
elif orderMethod == 'wtminfill': score = lambda adj,Xj: sum([(adj[Xj]-adj[Xk]).nrStatesDouble() for Xk in adj[Xj]])
elif orderMethod == 'minwidth': score = lambda adj,Xj: len(adj[Xj])
elif orderMethod == 'wtminwidth': score = lambda adj,Xj: adj[Xj].nrStatesDouble()
elif orderMethod == 'random': score = lambda adj,Xj: np.random.rand()
else: raise ValueError('Unknown ordering method: {}'.format(orderMethod))
adj = [ VarSet([Xi]) for Xi in gm.X ]
for Xi in gm.X:
for f in gm.factorsWith(Xi, copy=False):
adj[Xi] |= f.vars
# initialize priority queue of scores using e.g. heapq or sort
scores = [ (priority[Xi],score(adj,Xi),Xi) for Xi in gm.X ]
reverse = scores[:]
scores.sort()
totalSize = 0.0
_order = [0 for Xi in gm.X]
for idx in range(gm.nvar):
pick = 0
Pi,Si,Xi = scores[pick]
if nExtra >= 0:
mx = bisect.bisect_right(scores, (Pi,Si,gm.X[-1])) # get one past last equal-priority & score vars
pick = min(mx+nExtra, len(scores)) # then pick a random "near-best" variable
pick = np.random.randint(pick)
Pi,Si,Xi = scores[pick]
del scores[pick]
_order[idx] = Xi.label # write into order[idx] = Xi
totalSize += adj[Xi].nrStatesDouble()
if totalSize > cutoff: return target,cutoff # if worse than cutoff, quit with no changes to "target"
fix = VarSet()
for Xj in adj[Xi]:
adj[Xj] |= adj[Xi]
adj[Xj] -= [Xi]
fix |= adj[Xj] # shouldn't need to fix as much for min-width?
for Xj in fix:
Pj,Sj,Xj = reverse[Xj]
jPos = bisect.bisect_left(scores, (Pj,Sj,Xj))
del scores[jPos] # erase (Pj,Sj,Xj) from heap
reverse[Xj] = (Pj,score(adj,Xj),Xj)
bisect.insort_left(scores, reverse[Xj]) # add (Pj,score(adj,Xj),Xj) to heap & update reverse lookup
if not (target is None):
target.extend([None for i in range(len(target),len(_order))]) # make sure order is the right size
for idx in range(gm.nvar): target[idx]=_order[idx] # copy result if completed without quitting
return _order,totalSize
def add_child(self, child):
bisect.insort_left(self.chields, child)
def add(self, state: State) -> None:
self.index_to_state[state.index] = state
bisect.insort_left(self.ordered_index, state.index)
def add_movie(self, movie: Movie):
insort_left(self._movies, movie)
self._movies_index[movie.rank] = movie