def create_entries(self, lines, scope):
entries = []
for line in lines:
speed = float(re.search(r"Spe:(.*);", line).group(1))
latitude = float(re.search(r"Lat:(.*); Lon:", line).group(1))
longitude = float(re.search(r"Lon:(.*); Y:", line).group(1))
seconds = int(re.search(r"S:(.*); Spe:", line).group(1))
minutes = int(re.search(r"Mi:(.*); S:", line).group(1))
hours = int(re.search(r"H:(.*); Mi:", line).group(1))
entry = Entry(speed, latitude, longitude, seconds, minutes, hours, line)
if scope is None:
entries.append(entry)
elif scope.within(entry):
entries.append(entry)
duplicate_entries = []
non_duplicate_entries = []
for entry_index in range(1, len(entries)):
if entries[entry_index] == entries[entry_index - 1]:
duplicate_entries.append(entries[entry_index])
else:
non_duplicate_entries.append(entries[entry_index])
if duplicate_entries:
print "Duplicate entries: %d between %s" % (len(duplicate_entries), duplicate_entries[0].line)
else:
print "No duplicate entries!"
self.entries = non_duplicate_entries
print "Entries: %d" % len(self.entries)
def fillScaleAndTooltip(addressInfoMap, max_count):
"""Fills the tooltip, proportion, and zindex attributes of the given AddressInfo objects.
Uses fixed min_scale and max_scale values.
Args:
addressInfoMap (map{address: AddressInfo}): The AddressInfo to be processed.
max_count (int): The max_count so far encountered (if the data are processed in batches), 1 initially.
Returns:
The current max_count which also considers the processed AddressInfo objects.
"""
for info in addressInfoMap.values():
tooltipSnippets = ["<a href=\"http://www.bandzone.cz%s\" >%s</a>\n" % ( fan.profileUrl, fan.fullName) \
for fan in info.fans]
info.tooltip = ", ".join(tooltipSnippets)
# update the max_count if necessary
if info.count > max_count:
max_count = info.count
# employed scale parameters
min_scale = 0.4
max_scale = 2
(scale_factor, logarithm_base) = compute_scale_factors(max_count, min_scale, max_scale)
for info in addressInfoMap.values():
if logarithm_base == 1:
info.proportion = 1
else:
info.proportion = math.log(scale_factor * (1 + float(info.count)) / float(max_count), logarithm_base)
# the greater count, the lower z-index (smaller markers will be in front of the bigger ones)
info.zindex = max_count - info.count
return max_count
def launch_run(result_path, events_list, network_graph, dst_ls, dst_lb_ls,
l2bm_theta_obj_dict, theta_inits, no_of_groups, run_number):
f = open(
result_path + str(no_of_groups) + '-' + str(run_number) +
str('-ev_list.txt'), "w")
for r, e in events_list:
f.writelines(json.dumps(e.__dict__) + '\n')
f.close()
e_list = []
# lines = [line.rstrip('\n') for line in open('event_list.txt')]
# for l in lines:
# m = eval(l)
# me = MulticastEvent(m['t_index'], m['t_source'], m['t_bandwidth'], m['recv_node'], m['ev_time'], m['ev_type'])
# r_a = m['ev_time']
# e_list.append((r_a, me))
pool = Pool(len(theta_inits) + 2)
algo_names = []
algo_names.append('dst')
algo_names.append('dst-lb')
# args = [('l2bm-10', nw_g_l2bm_10, events_list, l2bm_10_ls)]
args = [('dst', network_graph.copy(), events_list, dst_ls)]
# args = [('dst', network_graph.copy(), events_list, dst_ls),
# ('dst-lb', network_graph.copy(), events_list, dst_lb_ls)]
for theta in theta_inits:
algo_n = 'l2bm-' + str(theta)
algo_names.append(algo_n)
args.append((algo_n, network_graph.copy(), events_list,
l2bm_theta_obj_dict[theta]))
results = pool.map(execute_sched_on_algo, args)
pool.close()
pool.join()
for a_n, r in itertools.izip(algo_names, results):
g, rr, br, bn, tn, bw_map, receivers_accept_ratio, bw_ratio, bw_map_ratio, total_bw_request_map = r
r_p = result_path + '/' + a_n + '/' + str(no_of_groups) + '/run' + str(
run_number)
mkdir(r_p)
edge_str = ''
for u, v, d in g.edges(data=True):
if str(u).startswith('h') or str(v).startswith('h'):
continue
edge_str += '(' + u + ',' + v + ')=' + str(
float(d['capacity']) - float(d['bandwidth'])) + ','
with open(r_p + '/link-bw-stats.txt', "w") as link_stat_file:
link_stat_file.writelines(edge_str)
with open(r_p + '/other-results.txt', "w") as results_file:
results_file.writelines("receiver-requests-accept=" + str(rr) +
'\n')
results_file.writelines("bandwidth-accept=" + str(br) + '\n')
results_file.writelines("branch-nodes=" + str(bn) + '\n')
results_file.writelines("total-tree-nodes=" + str(tn) + '\n')
results_file.writelines("bandwidth-accept-map=" +
json.dumps(bw_map) + '\n')
results_file.writelines("receivers-accept-ratio=" +
str(receivers_accept_ratio) + '\n')
results_file.writelines("bandwidth-accept-ratio=" + str(bw_ratio) +
'\n')
results_file.writelines("bandwidth-accept-map-ratio=" +
json.dumps(bw_map_ratio) + '\n')
results_file.writelines("total-bandwidth-request-map=" +
json.dumps(total_bw_request_map) + '\n')
def create_entries(self, lines, scope):
entries = []
for line in lines:
speed = float(re.search(r'Spe:(.*);', line).group(1))
latitude = float(re.search(r'Lat:(.*); Lon:', line).group(1))
longitude = float(re.search(r'Lon:(.*); Y:', line).group(1))
seconds = int(re.search(r'S:(.*); Spe:', line).group(1))
minutes = int(re.search(r'Mi:(.*); S:', line).group(1))
hours = int(re.search(r'H:(.*); Mi:', line).group(1))
entry = Entry(speed, latitude, longitude, seconds, minutes, hours,
line)
if scope is None:
entries.append(entry)
elif (scope.within(entry)):
entries.append(entry)
duplicate_entries = []
non_duplicate_entries = []
for entry_index in range(1, len(entries)):
if entries[entry_index] == entries[entry_index - 1]:
duplicate_entries.append(entries[entry_index])
else:
non_duplicate_entries.append(entries[entry_index])
if duplicate_entries:
print "Duplicate entries: %d between %s" % (
len(duplicate_entries), duplicate_entries[0].line)
else:
print "No duplicate entries!"
self.entries = non_duplicate_entries
print "Entries: %d" % len(self.entries)
def main(name, sx, sy, sz):
rospy.init_node('Hector', name)
robot = Robot(name)
hedef = robot.goto_point(float(sx), float(sy), float(sz))
if hedef == True:
pass
def set(self, new_x, new_y, new_orientation):
if new_x < 0 or new_x >= world_size:
raise ValueError, 'X coordinate out of bound'
if new_y < 0 or new_y >= world_size:
raise ValueError, 'Y coordinate out of bound'
if new_orientation < 0 or new_orientation >= 2 * pi:
raise ValueError, 'Orientation must be in [0..2pi]'
self.x = float(new_x)
self.y = float(new_y)
self.orientation = float(new_orientation)
def _get_size_from_memory(self, memory):
res = re.match(r'(\d+)(.*)', memory.lower())
if not res:
raise InputErrorException('InvalidMemory')
if res.group(2) in ['mb', 'm', '']:
size = float(res.group(1)) / 128
elif res.group(2) in ['gb', 'g']:
size = float(res.group(1)) * 2 ** 10 / 128
else:
raise InputErrorException('InvalidMemory')
final_size = int(math.ceil(size))
if final_size != size:
print >> sys.stderr, 'Memory size has to be a multiple of 128MB and has been rounded up to {0}MB.'.format(final_size * 128)
return final_size
def _get_size_from_memory(self, memory):
res = re.match(r'(\d+)(.*)', memory.lower())
if not res:
raise InputErrorException('InvalidMemory')
if res.group(2) in ['mb', 'm', '']:
size = float(res.group(1)) / 128
elif res.group(2) in ['gb', 'g']:
size = float(res.group(1)) * 2 ** 10 / 128
else:
raise InputErrorException('InvalidMemory')
final_size = int(math.ceil(size))
if final_size != size:
print >> sys.stderr, 'Memory size has to be a multiple of 128MB and has been rounded up to {0}MB.'.format(final_size * 128)
return final_size
def _get_size_from_memory(self, memory):
res = re.match(r"(\d+)(.*)", memory.lower())
if not res:
raise InputErrorException("InvalidMemory")
if res.group(2) in ["mb", "m", ""]:
size = float(res.group(1)) / 128
elif res.group(2) in ["gb", "g"]:
size = float(res.group(1)) * 2 ** 10 / 128
else:
raise InputErrorException("InvalidMemory")
final_size = int(math.ceil(size))
if final_size != size:
print >> sys.stderr, "Memory size has to be a multiple of 128MB and has been rounded up to {0}MB.".format(
final_size * 128
)
return final_size
def __init__(self,
dtype_or_func=None,
default=None,
missing_values=None,
locked=False):
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
ttype = np.bool
else:
# Is the input a np.dtype ?
try:
self.func = None
ttype = np.dtype(dtype_or_func).type
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func('0')
except ValueError:
default = None
ttype = self._getsubdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(ttype, deftype):
_status = i
self.default = default or default_def
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to smthg more robust
if self.func == self._mapper[1][1]:
self.func = lambda x: int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([''])
else:
self.missing_values = set(list(missing_values) + [''])
#
self._callingfunction = self._strict_call
self.type = ttype
self._checked = False
def below(self, limit, attribute):
total = 0
for entry in self.entries:
value = getattr(entry, attribute)
if float(value) <= limit:
total += 1
return total
def handleWritingClassTest():
from __builtin__ import int
from __builtin__ import float
hwLabels = []
trainingFileList = listdir('trainingDigits')
numTrainingFiles = len(trainingFileList)
trainingMatrix = zeros((numTrainingFiles, 1024))
for i in range(numTrainingFiles):
fileNameStr = trainingFileList[i]
fileStr = fileNameStr.split('.')[0]
savedNum = int(fileStr.split('_')[0])
hwLabels.append(savedNum)
trainingMatrix[i, :] = image2Vector('trainingDigits/%s' % fileNameStr)
testFileList = listdir('testDigits')
errorCount = 0.0
numTests = len(testFileList)
for i in range(numTests):
fileNameStr = testFileList[i]
fileStr = fileNameStr.split('.')[0]
savedNum = int(fileStr.split('_')[0])
vectorUnderTest = image2Vector('testDigits/%s' % fileNameStr)
classifierResult = classify0(vectorUnderTest, trainingMatrix, hwLabels,
3)
print 'the classifier came back with: %d, the real answer is: %d' % (
classifierResult, savedNum)
if (classifierResult != savedNum):
errorCount += 1.0
print('\nthe total number of tests: %d, the total number of errors: %d\n' %
(numTests, errorCount))
print('\nthe total error rate is: %s' % (errorCount / float(numTests)))
def infinity():
global infinity, nan
try:
infinity = float('inf')
except:
import struct
infinity = struct.unpack('!d','\x7f\xf0\x00\x00\x00\x00\x00\x00')[0]
nan = infinity / infinity
def __init__(self, dtype_or_func=None, default=None, missing_values=None,
locked=False):
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
ttype = np.bool
else:
# Is the input a np.dtype ?
try:
self.func = None
ttype = np.dtype(dtype_or_func).type
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func('0')
except ValueError:
default = None
ttype = self._getsubdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(ttype, deftype):
_status = i
self.default = default or default_def
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to smthg more robust
if self.func == self._mapper[1][1]:
self.func = lambda x : int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([''])
else:
self.missing_values = set(list(missing_values) + [''])
#
self._callingfunction = self._strict_call
self.type = ttype
self._checked = False
def digits_change(self, cr):
if self.digits_compute:
t = self.digits_compute(cr)
self._symbol_set=('%s', lambda x: ('%.'+str(t[1])+'f') % (__builtin__.float(x or 0.0),))
self.digits = t
# new customized fields
computation = self.digits_compute(cr, computation=True)
self.computation = computation
def eval(r, p):
sum = 0.0
for i in range(len(p)): # calculate mean error
dx = (p[i].x - r.x +
(world_size / 2.0)) % world_size - (world_size / 2.0)
dy = (p[i].y - r.y +
(world_size / 2.0)) % world_size - (world_size / 2.0)
err = sqrt(dx * dx + dy * dy)
sum += err
return sum / float(len(p))
def control_help(self):
if self.insanpose != None:
ax = self.insanpose.x
ay = self.insanpose.y
az = self.insanpose.z
rvalue = True
with open('/home/yigit/catkin_ws/src/quadro_demo/src/swarm-robotics/communication/comm.txt') as openfileobject:
for line in openfileobject:
if line != None and line != '\n':
px, py, pz = line.split()
x = float(px)
y = float(py)
z = float(pz)
p = (abs(ax-x)**2) + (abs(ay-y)**2) + (abs(az-z)**2)
r = math.sqrt(p)
if r < 1:
rvalue = False
return rvalue
def get_valid_lines(self, lines):
hdop_valid_entries = []
position_valid_entries = []
first_reliable = None
for line in lines:
value = int(line.split(";")[0].split(":")[1])
if value < 900:
hdop_valid_entries.append(line)
if (value < 200) and first_reliable is None:
first_reliable = line
for line in hdop_valid_entries:
latitude = float(line.split(";")[1].split(":")[1])
longitude = float(line.split(";")[2].split(":")[1])
reliable_latitude = float(first_reliable.split(";")[1].split(":")[1])
reliable_longitude = float(first_reliable.split(";")[2].split(":")[1])
if (abs(latitude - reliable_latitude) > 2.0) or (abs(longitude - reliable_longitude) > 2.0):
print "prblematic latitude/longitude at %s" % line
else:
position_valid_entries.append(line)
return position_valid_entries
def __call__(self, reflections):
'''
Select the reflections
:param reflections: The reflections
:return: The selection as a mask
'''
import __builtin__
if self.column == 'intensity.sum.i_over_sigma':
I = reflections['intensity.sum.value']
V = reflections['intensity.sum.variance']
mask1 = V > 0
I = I.select(mask1)
V = V.select(mask1)
data = I / flex.sqrt(V)
elif self.column == 'intensity.prf.i_over_sigma':
I = reflections['intensity.prf.value']
V = reflections['intensity.prf.variance']
mask1 = V > 0
I = I.select(mask1)
V = V.select(mask1)
data = I / flex.sqrt(V)
else:
mask1 = None
data = reflections[self.column]
if type(data) == double:
value = __builtin__.float(self.value)
elif type(data) == int:
value = __builtin__.int(self.value)
elif type(data) == size_t:
value = __builtin__.int(self.value)
elif type(data) == std_string:
value = self.value
elif type(data) == vec3_double:
raise RuntimeError("Comparison not implemented")
elif type(data) == vec2_double:
raise RuntimeError("Comparison not implemented")
elif type(data) == mat3_double:
raise RuntimeError("Comparison not implemented")
elif type(data) == int6:
raise RuntimeError("Comparison not implemented")
elif type(data) == shoebox:
raise RuntimeError("Comparison not implemented")
else:
raise RuntimeError('Unknown column type')
mask2 = self.op(data, self.value)
if mask1 is not None:
mask1.set_selected(size_t(range(len(mask1))).select(mask1), mask2)
else:
mask1 = mask2
return mask1
def __call__(self, reflections):
'''
Select the reflections
:param reflections: The reflections
:return: The selection as a mask
'''
import __builtin__
if self.column == 'intensity.sum.i_over_sigma':
I = reflections['intensity.sum.value']
V = reflections['intensity.sum.variance']
mask1 = V > 0
I = I.select(mask1)
V = V.select(mask1)
data = I / flex.sqrt(V)
elif self.column == 'intensity.prf.i_over_sigma':
I = reflections['intensity.prf.value']
V = reflections['intensity.prf.variance']
mask1 = V > 0
I = I.select(mask1)
V = V.select(mask1)
data = I / flex.sqrt(V)
else:
mask1 = None
data = reflections[self.column]
if isinstance(data, double):
value = __builtin__.float(self.value)
elif isinstance(data, int):
value = __builtin__.int(self.value)
elif isinstance(data, size_t):
value = __builtin__.int(self.value)
elif isinstance(data, std_string):
value = self.value
elif isinstance(data, vec3_double):
raise RuntimeError("Comparison not implemented")
elif isinstance(data, vec2_double):
raise RuntimeError("Comparison not implemented")
elif isinstance(data, mat3_double):
raise RuntimeError("Comparison not implemented")
elif isinstance(data, int6):
raise RuntimeError("Comparison not implemented")
elif isinstance(data, shoebox):
raise RuntimeError("Comparison not implemented")
else:
raise RuntimeError('Unknown column type')
mask2 = self.op(data, self.value)
if mask1 is not None:
mask1.set_selected(size_t(range(len(mask1))).select(mask1), mask2)
else:
mask1 = mask2
return mask1
def float_processor(data):
if not isinstance(data, __builtin__.float) and not coerce:
raise DataTypeError('float')
else:
try:
data = __builtin__.float(data)
except (ValueError, TypeError):
raise DataTypeError('float')
check_bounds(data, min=min, max=max)
return data
def move(self, turn, forward):
if forward < 0:
raise ValueError, 'Robot cant move backwards'
# turn, and add randomness to the turning command
orientation = self.orientation + float(turn) + random.gauss(
0.0, self.turn_noise)
orientation %= 2 * pi
# move, and add randomness to the motion command
dist = float(forward) + random.gauss(0.0, self.forward_noise)
x = self.x + (cos(orientation) * dist)
y = self.y + (sin(orientation) * dist)
x %= world_size # cyclic truncate
y %= world_size
# set particle
res = robot()
res.set(x, y, orientation)
res.set_noise(self.forward_noise, self.turn_noise, self.sense_noise)
return res
def insan_takibi(threadName, self):
ex = self.pose.x
ey = self.pose.y
if self.hedefyerdegisimi > 0.1:
completed = False
while not completed:
eu = self.euler[2]
eus = format(eu, '.2f')
eu = float(eus)
x = self.newlaser.x
y = self.newlaser.y
x = x - (math.cos(self.newlaser.angle) * 1.0)
y = y - (math.sin(self.newlaser.angle) * 1.0)
comp = goto_point(self,True, x, y, 1.8, self.newlaser.betwangle)
if comp == True and self.hedefyerdegisimi < 0.1:
completed = True
self.takip = False
self.kacmazamani = time.time()
self.takip2 = False
return
if self.hedefyerdegisimi < 0.1:
eu = self.euler[2]
eus = format(eu, '.2f')
eu = float(eus)
x = self.newlaser.x + (math.cos(eu) * self.newlaser.mindist)
y = self.newlaser.y + (math.sin(eu) * self.newlaser.mindist)
cmp = goto_point(self,False, x, y, 3.0, 0.0)
self.kacmazamani = time.time()
self.takip = False
self.takip2 = False
def get_valid_lines(self, lines):
hdop_valid_entries = []
position_valid_entries = []
first_reliable = None
for line in lines:
value = int(line.split(';')[0].split(':')[1])
if value < 900:
hdop_valid_entries.append(line)
if (value < 200) and first_reliable is None:
first_reliable = line
for line in hdop_valid_entries:
latitude = float(line.split(';')[1].split(':')[1])
longitude = float(line.split(';')[2].split(':')[1])
reliable_latitude = float(
first_reliable.split(';')[1].split(':')[1])
reliable_longitude = float(
first_reliable.split(';')[2].split(':')[1])
if ((abs(latitude - reliable_latitude) > 2.0)
or (abs(longitude - reliable_longitude) > 2.0)):
print 'prblematic latitude/longitude at %s' % line
else:
position_valid_entries.append(line)
return position_valid_entries
def log_from_now(self, app_name, deployment_name, type_):
last_time = datetime.now() - timedelta(seconds=10)
while True:
logEntries = []
try:
logEntries = self.api.read_log(app_name, deployment_name, type_, last_time=last_time)
except GoneError:
raise InputErrorException("WrongApplication")
if len(logEntries) > 0:
last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
print_log_entries(logEntries, type_)
time.sleep(1)
def pauses(self):
pauses = []
candidate = None
for entry in self.entries:
if float(entry.speed) < pause_speed_limit:
if candidate is None:
candidate = self.Pause(entry)
if candidate.long_enough(entry) and candidate not in pauses:
pauses.append(candidate)
else:
candidate = None
pause_entries = []
for pause in pauses:
pause_entries += self.get_pause_entries(pause)
return pauses, pause_entries
def pauses(self):
pauses = []
candidate = None
for entry in self.entries:
if float(entry.speed) < pause_speed_limit:
if candidate is None:
candidate = self.Pause(entry)
if candidate.long_enough(entry) and candidate not in pauses:
pauses.append(candidate)
else:
candidate = None
pause_entries = []
for pause in pauses:
pause_entries += self.get_pause_entries(pause)
return pauses, pause_entries
def calculate_upper_bound(self, node):
if node.weight > self.capacity:
return 0
else:
bound = node.value
w_tot = node.weight
item_index = node.level
while item_index < self.num_items and w_tot + self.items[item_index]['weight'] <= self.capacity:
bound += self.items[item_index]['value']
w_tot += self.items[item_index]['weight']
item_index += 1
if item_index < self.num_items:
bound += float(self.capacity - w_tot)/self.items[item_index]['weight'] * self.items[item_index]['value']
return bound
class float(_column):
_type = 'float'
_symbol_c = '%s'
_symbol_f = lambda x: __builtin__.float(x or 0.0)
_symbol_set = (_symbol_c, _symbol_f)
_symbol_get = lambda self,x: x or 0.0
def __init__(self, string='unknown', digits=None, digits_compute=None, **args):
_column.__init__(self, string=string, **args)
self.digits = digits
self.digits_compute = digits_compute
def digits_change(self, cr):
if self.digits_compute:
t = self.digits_compute(cr)
self._symbol_set=('%s', lambda x: ('%.'+str(t[1])+'f') % (__builtin__.float(x or 0.0),))
self.digits = t
def rachunek(zamowienie):
menimoje=open("slownik.txt","r")
for linia in menimoje:
linia=linia.strip('\n').split(' ')
for i in xrange(0,len(linia)/2):
slownik={}
klucz=linia[2*i]
wartosci=linia[(2*i)+1]
wart=float(wartosci)
print klucz+": "+wartosci
print wart
cena=0.00
for linia in menimoje:
for klu in zamowienie:
if klu in linia:
cena+=linia[klu]
return cena
def execute_sched_on_algo(args):
total_bw_request_map = {}
total_receivers_request = 0
total_bw_request = 0.0
algo_name = args[0]
print algo_name
nw_g = args[1]
e_l = args[2]
tree_objs = args[3]
receiver_accept = 0
bw_accept = 0
bw_accept_map = {}
bw_accept_map_ratio = {}
bw = 0
# print 'execute_sched_on_algo'
for r_a, event in e_l:
ret = True
# print json.dumps(event.__dict__)
if event.ev_type == 'join':
tree = tree_objs[event.t_index]
# print 'add node - > '+event.recv_node
ret = tree.add_node(nw_g, event.recv_node)
bw = tree.bandwidth
total_receivers_request += 1
total_bw_request += float(bw)
if total_bw_request_map.has_key(str(tree.bandwidth)):
total_bw_request_map[str(tree.bandwidth)] += 1
else:
total_bw_request_map[str(tree.bandwidth)] = 1
if ret:
receiver_accept += 1
bw_accept += float(bw)
if bw_accept_map.has_key(str(bw)):
bw_accept_map[str(bw)] += 1
else:
bw_accept_map[str(bw)] = 1
for bw, num in total_bw_request_map.iteritems():
if bw_accept_map.has_key(str(bw)):
bw_accept_map_ratio[str(bw)] = float(
bw_accept_map[str(bw)]) / float(num)
else:
bw_accept_map_ratio[str(bw)] = 0
tn = 0
bn_l = []
for t in tree_objs:
bn_l.append(t.branch_nodes())
tn += t.tree_nodes()
return (nw_g, receiver_accept, bw_accept, bn_l, tn, bw_accept_map,
float(receiver_accept) / float(total_receivers_request),
bw_accept / total_bw_request, bw_accept_map_ratio,
total_bw_request_map)
def log(self, args):
"""
Show the log.
"""
#noinspection PyTupleAssignmentBalance
app_name, deployment_name = self.parse_app_deployment_name(args.name)
if not deployment_name:
raise InputErrorException('NoDeployment')
last_time = None
while True:
#noinspection PyUnusedLocal
logEntries = []
try:
logEntries = self.api.read_log(
app_name,
deployment_name,
args.type,
last_time=last_time)
except GoneError:
raise InputErrorException('WrongApplication')
if len(logEntries) > 0:
last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
if args.type == 'worker' and args.wrk_id:
logEntries = filter(lambda entry:
entry['wrk_id'] == args.wrk_id, logEntries)
if args.filter:
if args.type in ["error", "worker"]:
logEntries = filter(
lambda entry: re.search(
re.compile(args.filter, re.IGNORECASE),
entry['message']),
logEntries)
if args.type == 'access':
logEntries = filter(lambda entry:
re.search(
re.compile(args.filter, re.IGNORECASE),
entry['first_request_line'] +
entry['referer'] +
entry['user_agent'] +
entry['remote_host']),
logEntries)
print_log_entries(logEntries, args.type)
time.sleep(2)
def log(self, args):
"""
Show the log.
"""
#noinspection PyTupleAssignmentBalance
app_name, deployment_name = self.parse_app_deployment_name(args.name)
if not deployment_name:
raise InputErrorException('NoDeployment')
last_time = None
while True:
#noinspection PyUnusedLocal
logEntries = []
try:
logEntries = self.api.read_log(
app_name,
deployment_name,
args.type,
last_time=last_time)
except GoneError:
raise InputErrorException('WrongApplication')
if len(logEntries) > 0:
last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
if args.type == 'worker' and args.wrk_id:
logEntries = filter(lambda entry:
entry['wrk_id'] == args.wrk_id, logEntries)
if args.filter:
if args.type in ["error", "worker"]:
logEntries = filter(
lambda entry: re.search(
re.compile(args.filter, re.IGNORECASE),
entry['message']),
logEntries)
if args.type == 'access':
logEntries = filter(lambda entry:
re.search(
re.compile(args.filter, re.IGNORECASE),
entry['first_request_line'] +
entry['referer'] +
entry['user_agent'] +
entry['remote_host']),
logEntries)
print_log_entries(logEntries, args.type)
time.sleep(2)
def integer_processor(data):
if not isinstance(data, (int, long)) and not coerce:
raise DataTypeError('integer')
else:
try:
data = int(data)
except (ValueError, TypeError):
if isinstance(data, basestring):
# int() won't convert floats that are strings,
# so try float()ing them first
try:
data = int(__builtin__.float(data))
except (ValueError, TypeError):
raise DataTypeError('integer')
else:
raise DataTypeError('integer')
check_bounds(data, min=min, max=max)
return data
def log(self, args):
"""
Show the log.
"""
app_name, deployment_name = self.parse_app_deployment_name(args.name)
if not deployment_name:
deployment_name = "default"
last_time = None
while True:
logEntries = []
try:
logEntries = self.api.read_log(app_name, deployment_name, args.type, last_time=last_time)
except GoneError:
raise InputErrorException("WrongApplication")
if len(logEntries) > 0:
last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
if args.type == "worker" and args.wrk_id:
logEntries = filter(lambda entry: entry["wrk_id"] == args.wrk_id, logEntries)
if args.filter:
if args.type in ["error", "worker"]:
logEntries = filter(
lambda entry: re.search(re.compile(args.filter, re.IGNORECASE), entry["message"]),
logEntries,
)
if args.type == "access":
logEntries = filter(
lambda entry: re.search(
re.compile(args.filter, re.IGNORECASE),
entry["first_request_line"]
+ entry["referer"]
+ entry["user_agent"]
+ entry["remote_host"],
),
logEntries,
)
print_log_entries(logEntries, args.type)
time.sleep(2)
def send_help(threadName, self, dist):
if self.pose != None:
x = self.pose.x
y = self.pose.y
z = self.pose.z
eu = self.euler[2]
eus = format(eu, '.2f')
eu = float(eus)
self.insanpose = self.pose
self.insanpose.x = self.pose.x + (math.cos(eu) * dist)
self.insanpose.y = self.pose.y + (math.sin(eu) * dist)
self.insanpose.z = 0
try:
if control_help(self) is True:
fo = open("/home/yigit/catkin_ws/src/quadro_demo/src/swarm-robotics/communication/comm.txt", "a")
filestring = "\n%.10f %.10f %.10f" % ( (x), (y), (z))
fo.write(filestring)
fo.close()
else:
pass
except:
pass
def nonneg_float(value):
value = __builtin__.float(value)
if value < 0:
raise ValueError
return value
def set_normalizer(self, obj, value):
return __builtin__.float(value)
def validator(self, obj, value):
try:
__builtin__.float(value)
return True
except:
return False
def set_normalizer(self, obj, value):
return __builtin__.float(value)
def average(self, attribute, entries):
total = 0
for entry in entries:
value = getattr(entry, attribute)
total += float(value)
return total / len(entries)
tm_start = time.time()
#sys.stderr.write("=====> DFZ DEBUG: test starts at " + str(tm_start) + "\n")
end_of_interaction = 0
while (end_of_interaction != 1):
header = sys.stdin.readline().rstrip()
if (header != "0"):
#We receive a message from the SciDB instance:
num_lines = int(header) #how many lines did we get?
#Collect all lines into a list:
input_lines = []
for i in range(0, num_lines):
line = sys.stdin.readline().rstrip()
f = float(line)
input_lines.append(f)
#construct the values into a numpy array for MRI
# data = np.reshape(np.asarray(input_lines, dtype=np.float32), (145, 174, 145, 9))
# sys.stderr.write("=====> DFZ DEBUG: data convertion completed.\n")
#start MRI app
#masking
# mask = nib.load(DATA_LOC + 'mask.nii.gz').get_data()
# sys.stderr.write("=====> DFZ DEBUG: mask loaded.\n")
#denosing
# sigma = estimate_sigma(data)
# sys.stderr.write("=====> DFZ DEBUG: sigma calculated.\n")
def validator(self, obj, value):
try:
__builtin__.float(value)
return True
except:
return False
def __init__(self, dtype_or_func=None, default=None, missing_values=None,
locked=False):
# Convert unicode (for Py3)
if isinstance(missing_values, unicode):
missing_values = asbytes(missing_values)
elif isinstance(missing_values, (list, tuple)):
missing_values = asbytes_nested(missing_values)
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
dtype = np.dtype('bool')
else:
# Is the input a np.dtype ?
try:
self.func = None
dtype = np.dtype(dtype_or_func)
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func(asbytes('0'))
except ValueError:
default = None
dtype = self._getdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(dtype.type, deftype):
_status = i
if default is None:
self.default = default_def
else:
self.default = default
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to
# something more robust.
if self.func == self._mapper[1][1]:
if issubclass(dtype.type, np.uint64):
self.func = np.uint64
elif issubclass(dtype.type, np.int64):
self.func = np.int64
else:
self.func = lambda x : int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([asbytes('')])
else:
if isinstance(missing_values, bytes):
missing_values = missing_values.split(asbytes(","))
self.missing_values = set(list(missing_values) + [asbytes('')])
#
self._callingfunction = self._strict_call
self.type = self._dtypeortype(dtype)
self._checked = False
self._initial_default = default
def digits_change(self, cr):
if self.digits_compute:
t = self.digits_compute(cr)
self._symbol_set=('%s', lambda x: ('%.'+str(t[1])+'f') % (__builtin__.float(x or 0.0),))
self.digits = t
def processMsg(self, msgId):
if msgId == -1:
return False
if msgId == self.TICK_PRICE:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
price = self.readDouble()
size = 0
if version >= 2:
size = self.readInt()
canAutoExecute = 0
if version >= 3:
canAutoExecute = self.readInt()
self.eWrapper().tickPrice(tickerId, tickType, price, canAutoExecute)
if version >= 2:
sizeTickType = -1
if tickType == 1:
sizeTickType = 0
elif tickType == 2:
sizeTickType = 3
elif tickType == 4:
sizeTickType = 5
if sizeTickType != -1:
self.eWrapper().tickSize(tickerId, sizeTickType, size)
elif msgId == self.TICK_SIZE:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
size = self.readInt()
self.eWrapper().tickSize(tickerId, tickType, size)
elif msgId == self.TICK_OPTION_COMPUTATION:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
impliedVol = self.readDouble()
if impliedVol < 0:
impliedVol = Double.MAX_VALUE
delta = self.readDouble()
if abs(delta) > 1:
delta = Double.MAX_VALUE
modelPrice = float()
pvDividend = float()
if tickType == TickType.MODEL_OPTION:
modelPrice = self.readDouble()
pvDividend = self.readDouble()
else:
modelPrice = pvDividend = Double.MAX_VALUE
self.eWrapper().tickOptionComputation(tickerId, tickType, impliedVol, delta, modelPrice, pvDividend)
elif msgId == self.TICK_GENERIC:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
value = self.readDouble()
self.eWrapper().tickGeneric(tickerId, tickType, value)
elif msgId == self.TICK_STRING:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
value = self.readStr()
self.eWrapper().tickString(tickerId, tickType, value)
elif msgId == self.TICK_EFP:
version = self.readInt()
tickerId = self.readInt()
tickType = self.readInt()
basisPoints = self.readDouble()
formattedBasisPoints = self.readStr()
impliedFuturesPrice = self.readDouble()
holdDays = self.readInt()
futureExpiry = self.readStr()
dividendImpact = self.readDouble()
dividendsToExpiry = self.readDouble()
self.eWrapper().tickEFP(
tickerId,
tickType,
basisPoints,
formattedBasisPoints,
impliedFuturesPrice,
holdDays,
futureExpiry,
dividendImpact,
dividendsToExpiry,
)
elif msgId == self.ORDER_STATUS:
version = self.readInt()
id = self.readInt()
status = self.readStr()
filled = self.readInt()
remaining = self.readInt()
avgFillPrice = self.readDouble()
permId = 0
if version >= 2:
permId = self.readInt()
parentId = 0
if version >= 3:
parentId = self.readInt()
lastFillPrice = 0
if version >= 4:
lastFillPrice = self.readDouble()
clientId = 0
if version >= 5:
clientId = self.readInt()
whyHeld = None
if version >= 6:
whyHeld = self.readStr()
self.eWrapper().orderStatus(
id, status, filled, remaining, avgFillPrice, permId, parentId, lastFillPrice, clientId, whyHeld
)
elif msgId == self.ACCT_VALUE:
version = self.readInt()
key = self.readStr()
val = self.readStr()
cur = self.readStr()
accountName = None
if version >= 2:
accountName = self.readStr()
self.eWrapper().updateAccountValue(key, val, cur, accountName)
elif msgId == self.PORTFOLIO_VALUE:
version = self.readInt()
contract = Contract()
if version >= 6:
contract.m_conId = self.readInt()
contract.m_symbol = self.readStr()
contract.m_secType = self.readStr()
contract.m_expiry = self.readStr()
contract.m_strike = self.readDouble()
contract.m_right = self.readStr()
if version >= 7:
contract.m_multiplier = self.readStr()
contract.m_primaryExch = self.readStr()
contract.m_currency = self.readStr()
if version >= 2:
contract.m_localSymbol = self.readStr()
position = self.readInt()
marketPrice = self.readDouble()
marketValue = self.readDouble()
averageCost = 0.0
unrealizedPNL = 0.0
realizedPNL = 0.0
if version >= 3:
averageCost = self.readDouble()
unrealizedPNL = self.readDouble()
realizedPNL = self.readDouble()
accountName = None
if version >= 4:
accountName = self.readStr()
if (version == 6) and (self.m_parent.serverVersion() == 39):
contract.m_primaryExch = self.readStr()
self.eWrapper().updatePortfolio(
contract, position, marketPrice, marketValue, averageCost, unrealizedPNL, realizedPNL, accountName
)
elif msgId == self.ACCT_UPDATE_TIME:
version = self.readInt()
timeStamp = self.readStr()
self.eWrapper().updateAccountTime(timeStamp)
elif msgId == self.ERR_MSG:
version = self.readInt()
if version < 2:
msg = self.readStr()
self.m_parent.error(msg)
else:
id = self.readInt()
errorCode = self.readInt()
errorMsg = self.readStr()
self.m_parent.error(id, errorCode, errorMsg)
elif msgId == self.OPEN_ORDER:
version = self.readInt()
order = Order()
order.m_orderId = self.readInt()
contract = Contract()
if version >= 17:
contract.m_conId = self.readInt()
contract.m_symbol = self.readStr()
contract.m_secType = self.readStr()
contract.m_expiry = self.readStr()
contract.m_strike = self.readDouble()
contract.m_right = self.readStr()
contract.m_exchange = self.readStr()
contract.m_currency = self.readStr()
if version >= 2:
contract.m_localSymbol = self.readStr()
order.m_action = self.readStr()
order.m_totalQuantity = self.readInt()
order.m_orderType = self.readStr()
order.m_lmtPrice = self.readDouble()
order.m_auxPrice = self.readDouble()
order.m_tif = self.readStr()
order.m_ocaGroup = self.readStr()
order.m_account = self.readStr()
order.m_openClose = self.readStr()
order.m_origin = self.readInt()
order.m_orderRef = self.readStr()
if version >= 3:
order.m_clientId = self.readInt()
if version >= 4:
order.m_permId = self.readInt()
if version < 18:
self.readBoolFromInt()
else:
order.m_outsideRth = self.readBoolFromInt()
order.m_hidden = self.readInt() == 1
order.m_discretionaryAmt = self.readDouble()
if version >= 5:
order.m_goodAfterTime = self.readStr()
if version >= 6:
self.readStr()
if version >= 7:
order.m_faGroup = self.readStr()
order.m_faMethod = self.readStr()
order.m_faPercentage = self.readStr()
order.m_faProfile = self.readStr()
if version >= 8:
order.m_goodTillDate = self.readStr()
if version >= 9:
order.m_rule80A = self.readStr()
order.m_percentOffset = self.readDouble()
order.m_settlingFirm = self.readStr()
order.m_shortSaleSlot = self.readInt()
order.m_designatedLocation = self.readStr()
order.m_auctionStrategy = self.readInt()
order.m_startingPrice = self.readDouble()
order.m_stockRefPrice = self.readDouble()
order.m_delta = self.readDouble()
order.m_stockRangeLower = self.readDouble()
order.m_stockRangeUpper = self.readDouble()
order.m_displaySize = self.readInt()
if version < 18:
self.readBoolFromInt()
order.m_blockOrder = self.readBoolFromInt()
order.m_sweepToFill = self.readBoolFromInt()
order.m_allOrNone = self.readBoolFromInt()
order.m_minQty = self.readInt()
order.m_ocaType = self.readInt()
order.m_eTradeOnly = self.readBoolFromInt()
order.m_firmQuoteOnly = self.readBoolFromInt()
order.m_nbboPriceCap = self.readDouble()
if version >= 10:
order.m_parentId = self.readInt()
order.m_triggerMethod = self.readInt()
if version >= 11:
order.m_volatility = self.readDouble()
order.m_volatilityType = self.readInt()
if version == 11:
receivedInt = self.readInt()
order.m_deltaNeutralOrderType = "NONE" if (receivedInt == 0) else "MKT"
else:
order.m_deltaNeutralOrderType = self.readStr()
order.m_deltaNeutralAuxPrice = self.readDouble()
order.m_continuousUpdate = self.readInt()
if self.m_parent.serverVersion() == 26:
order.m_stockRangeLower = self.readDouble()
order.m_stockRangeUpper = self.readDouble()
order.m_referencePriceType = self.readInt()
if version >= 13:
order.m_trailStopPrice = self.readDouble()
if version >= 14:
order.m_basisPoints = self.readDouble()
order.m_basisPointsType = self.readInt()
contract.m_comboLegsDescrip = self.readStr()
if version >= 15:
if version >= 20:
order.m_scaleInitLevelSize = self.readIntMax()
order.m_scaleSubsLevelSize = self.readIntMax()
else:
self.readIntMax()
order.m_scaleInitLevelSize = self.readIntMax()
order.m_scalePriceIncrement = self.readDoubleMax()
if version >= 19:
order.m_clearingAccount = self.readStr()
order.m_clearingIntent = self.readStr()
if version >= 20:
if self.readBoolFromInt():
underComp = UnderComp()
underComp.m_conId = self.readInt()
underComp.m_delta = self.readDouble()
underComp.m_price = self.readDouble()
contract.m_underComp = underComp
orderState = OrderState()
if version >= 16:
order.m_whatIf = self.readBoolFromInt()
orderState.m_status = self.readStr()
orderState.m_initMargin = self.readStr()
orderState.m_maintMargin = self.readStr()
orderState.m_equityWithLoan = self.readStr()
orderState.m_commission = self.readDoubleMax()
orderState.m_minCommission = self.readDoubleMax()
orderState.m_maxCommission = self.readDoubleMax()
orderState.m_commissionCurrency = self.readStr()
orderState.m_warningText = self.readStr()
self.eWrapper().openOrder(order.m_orderId, contract, order, orderState)
elif msgId == self.NEXT_VALID_ID:
version = self.readInt()
orderId = self.readInt()
self.eWrapper().nextValidId(orderId)
elif msgId == self.SCANNER_DATA:
contract = ContractDetails()
version = self.readInt()
tickerId = self.readInt()
numberOfElements = self.readInt()
## for-while
ctr = 0
while ctr < numberOfElements:
rank = self.readInt()
if version >= 3:
contract.m_summary.m_conId = self.readInt()
contract.m_summary.m_symbol = self.readStr()
contract.m_summary.m_secType = self.readStr()
contract.m_summary.m_expiry = self.readStr()
contract.m_summary.m_strike = self.readDouble()
contract.m_summary.m_right = self.readStr()
contract.m_summary.m_exchange = self.readStr()
contract.m_summary.m_currency = self.readStr()
contract.m_summary.m_localSymbol = self.readStr()
contract.m_marketName = self.readStr()
contract.m_tradingClass = self.readStr()
distance = self.readStr()
benchmark = self.readStr()
projection = self.readStr()
legsStr = None
if version >= 2:
legsStr = self.readStr()
self.eWrapper().scannerData(tickerId, rank, contract, distance, benchmark, projection, legsStr)
ctr += 1
self.eWrapper().scannerDataEnd(tickerId)
elif msgId == self.CONTRACT_DATA:
version = self.readInt()
reqId = -1
if version >= 3:
reqId = self.readInt()
contract = ContractDetails()
contract.m_summary.m_symbol = self.readStr()
contract.m_summary.m_secType = self.readStr()
contract.m_summary.m_expiry = self.readStr()
contract.m_summary.m_strike = self.readDouble()
contract.m_summary.m_right = self.readStr()
contract.m_summary.m_exchange = self.readStr()
contract.m_summary.m_currency = self.readStr()
contract.m_summary.m_localSymbol = self.readStr()
contract.m_marketName = self.readStr()
contract.m_tradingClass = self.readStr()
contract.m_summary.m_conId = self.readInt()
contract.m_minTick = self.readDouble()
contract.m_summary.m_multiplier = self.readStr()
contract.m_orderTypes = self.readStr()
contract.m_validExchanges = self.readStr()
if version >= 2:
contract.m_priceMagnifier = self.readInt()
self.eWrapper().contractDetails(reqId, contract)
elif msgId == self.BOND_CONTRACT_DATA:
version = self.readInt()
reqId = -1
if version >= 3:
reqId = self.readInt()
contract = ContractDetails()
contract.m_summary.m_symbol = self.readStr()
contract.m_summary.m_secType = self.readStr()
contract.m_cusip = self.readStr()
contract.m_coupon = self.readDouble()
contract.m_maturity = self.readStr()
contract.m_issueDate = self.readStr()
contract.m_ratings = self.readStr()
contract.m_bondType = self.readStr()
contract.m_couponType = self.readStr()
contract.m_convertible = self.readBoolFromInt()
contract.m_callable = self.readBoolFromInt()
contract.m_putable = self.readBoolFromInt()
contract.m_descAppend = self.readStr()
contract.m_summary.m_exchange = self.readStr()
contract.m_summary.m_currency = self.readStr()
contract.m_marketName = self.readStr()
contract.m_tradingClass = self.readStr()
contract.m_summary.m_conId = self.readInt()
contract.m_minTick = self.readDouble()
contract.m_orderTypes = self.readStr()
contract.m_validExchanges = self.readStr()
if version >= 2:
contract.m_nextOptionDate = self.readStr()
contract.m_nextOptionType = self.readStr()
contract.m_nextOptionPartial = self.readBoolFromInt()
contract.m_notes = self.readStr()
self.eWrapper().bondContractDetails(reqId, contract)
elif msgId == self.EXECUTION_DATA:
version = self.readInt()
orderId = self.readInt()
contract = Contract()
if version >= 5:
contract.m_conId = self.readInt()
contract.m_symbol = self.readStr()
contract.m_secType = self.readStr()
contract.m_expiry = self.readStr()
contract.m_strike = self.readDouble()
contract.m_right = self.readStr()
contract.m_exchange = self.readStr()
contract.m_currency = self.readStr()
contract.m_localSymbol = self.readStr()
exec_ = Execution()
exec_.m_orderId = orderId
exec_.m_execId = self.readStr()
exec_.m_time = self.readStr()
exec_.m_acctNumber = self.readStr()
exec_.m_exchange = self.readStr()
exec_.m_side = self.readStr()
exec_.m_shares = self.readInt()
exec_.m_price = self.readDouble()
if version >= 2:
exec_.m_permId = self.readInt()
if version >= 3:
exec_.m_clientId = self.readInt()
if version >= 4:
exec_.m_liquidation = self.readInt()
if version >= 6:
exec_.m_cumQty = self.readInt()
exec_.m_avgPrice = self.readDouble()
self.eWrapper().execDetails(orderId, contract, exec_)
elif msgId == self.MARKET_DEPTH:
version = self.readInt()
id = self.readInt()
position = self.readInt()
operation = self.readInt()
side = self.readInt()
price = self.readDouble()
size = self.readInt()
self.eWrapper().updateMktDepth(id, position, operation, side, price, size)
elif msgId == self.MARKET_DEPTH_L2:
version = self.readInt()
id = self.readInt()
position = self.readInt()
marketMaker = self.readStr()
operation = self.readInt()
side = self.readInt()
price = self.readDouble()
size = self.readInt()
self.eWrapper().updateMktDepthL2(id, position, marketMaker, operation, side, price, size)
elif msgId == self.NEWS_BULLETINS:
version = self.readInt()
newsMsgId = self.readInt()
newsMsgType = self.readInt()
newsMessage = self.readStr()
originatingExch = self.readStr()
self.eWrapper().updateNewsBulletin(newsMsgId, newsMsgType, newsMessage, originatingExch)
elif msgId == self.MANAGED_ACCTS:
version = self.readInt()
accountsList = self.readStr()
self.eWrapper().managedAccounts(accountsList)
elif msgId == self.RECEIVE_FA:
version = self.readInt()
faDataType = self.readInt()
xml = self.readStr()
self.eWrapper().receiveFA(faDataType, xml)
elif msgId == self.HISTORICAL_DATA:
version = self.readInt()
reqId = self.readInt()
startDateStr = ""
endDateStr = ""
completedIndicator = "finished"
if version >= 2:
startDateStr = self.readStr()
endDateStr = self.readStr()
completedIndicator += "-" + startDateStr + "-" + endDateStr
itemCount = self.readInt()
## for-while
ctr = 0
while ctr < itemCount:
date = self.readStr()
open = self.readDouble()
high = self.readDouble()
low = self.readDouble()
close = self.readDouble()
volume = self.readInt()
WAP = self.readDouble()
hasGaps = self.readStr()
barCount = -1
if version >= 3:
barCount = self.readInt()
self.eWrapper().historicalData(
reqId, date, open, high, low, close, volume, barCount, WAP, Boolean.valueOf(hasGaps).booleanValue()
)
ctr += 1
self.eWrapper().historicalData(reqId, completedIndicator, -1, -1, -1, -1, -1, -1, -1, False)
elif msgId == self.SCANNER_PARAMETERS:
version = self.readInt()
xml = self.readStr()
self.eWrapper().scannerParameters(xml)
elif msgId == self.CURRENT_TIME:
self.readInt()
time = self.readLong()
self.eWrapper().currentTime(time)
elif msgId == self.REAL_TIME_BARS:
self.readInt()
reqId = self.readInt()
time = self.readLong()
open = self.readDouble()
high = self.readDouble()
low = self.readDouble()
close = self.readDouble()
volume = self.readLong()
wap = self.readDouble()
count = self.readInt()
self.eWrapper().realtimeBar(reqId, time, open, high, low, close, volume, wap, count)
elif msgId == self.FUNDAMENTAL_DATA:
self.readInt()
reqId = self.readInt()
data = self.readStr()
self.eWrapper().fundamentalData(reqId, data)
elif msgId == self.CONTRACT_DATA_END:
self.readInt()
reqId = self.readInt()
self.eWrapper().contractDetailsEnd(reqId)
else:
self.m_parent.error(
EClientErrors.NO_VALID_ID, EClientErrors.UNKNOWN_ID.code(), EClientErrors.UNKNOWN_ID.msg()
)
return False
return True
def __init__(self, dtype_or_func=None, default=None, missing_values=None,
locked=False):
# Convert unicode (for Py3)
if isinstance(missing_values, unicode):
missing_values = asbytes(missing_values)
elif isinstance(missing_values, (list, tuple)):
missing_values = asbytes_nested(missing_values)
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
dtype = np.dtype('bool')
else:
# Is the input a np.dtype ?
try:
self.func = None
dtype = np.dtype(dtype_or_func)
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func(asbytes('0'))
except ValueError:
default = None
dtype = self._getdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(dtype.type, deftype):
_status = i
if default is None:
self.default = default_def
else:
self.default = default
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to
# something more robust.
if self.func == self._mapper[1][1]:
if issubclass(dtype.type, np.uint64):
self.func = np.uint64
elif issubclass(dtype.type, np.int64):
self.func = np.int64
else:
self.func = lambda x : int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([asbytes('')])
else:
if isinstance(missing_values, bytes):
missing_values = missing_values.split(asbytes(","))
self.missing_values = set(list(missing_values) + [asbytes('')])
#
self._callingfunction = self._strict_call
self.type = self._dtypeortype(dtype)
self._checked = False
self._initial_default = default
#!/usr/bin/env python
# coding=utf-8
# Created by Ferris on 2016/11/16
# 内建函数1
import __builtin__
__builtin__.float()
# help(__builtin__.XXX)
# 返回一个数字的绝对值
def fun(x):
if x < 0:
return -x
return x
# 等于abs()
# max() 参数时一个可迭代的对象
# min()
# len()取序列长度 列表 元组 字典 字符串
# divmod(x,y) x/y 返回一个元组两个值一个商一个余数
# pow(x,y[, z]) 两个参数的话就是 x^y 三个参数就是(x^y)%z
# round(number[, ndigits]) 四舍五入 后边可选参数是保留几位小数 默认为0 先变浮点侯保留
def plotResults(self):
#### calculate stats on collected data and draw some plots ####
import matplotlib.mlab as mlab
from matplotlib.pyplot import axis, title, xlabel, hist, grid, show, ylabel, plot
import pylab
results= self.results
durations=results[:,0]
flips=results[1:,2]
dmin=durations.min()
dmax=durations.max()
dmean=durations.mean()
dstd=durations.std()
fmean=flips.mean()
fstd=flips.std()
pylab.figure(figsize=[30,10])
pylab.subplot(1,3,1)
# the histogram of the delay data
n, bins, patches = hist(durations, 50, normed=True, facecolor='blue', alpha=0.75)
# add a 'best fit' line
y = mlab.normpdf( bins, dmean, dstd)
plot(bins, y, 'r--', linewidth=1)
xlabel('ioHub getEvents Delay')
ylabel('Percentage')
title(
r'$\mathrm{{Histogram\ of\ Delay:}}\ \min={0:.3f},\ \max={1:.3f},\ \mu={2:.3f},\ \sigma={3:.4f}$'.format(
dmin, dmax, dmean, dstd))
axis([0, dmax+1.0, 0, 25.0])
grid(True)
# graphs of the retrace data ( taken from retrace example in psychopy demos folder)
intervalsMS = flips
m=fmean
sd=fstd
distString= "Mean={0:.1f}ms, s.d.={1:.1f}, 99%CI={2:.1f}-{3:.1f}".format(m, sd, m - 3 * sd, m + 3 * sd)
nTotal=len(intervalsMS)
nDropped=sum(intervalsMS>(1.5*m))
droppedString = "Dropped/Frames = {0:d}/{1:d} = {2:.3f}%".format(nDropped, nTotal, int(nDropped) / float(nTotal))
pylab.subplot(1,3,2)
#plot the frameintervals
pylab.plot(intervalsMS, '-')
pylab.ylabel('t (ms)')
pylab.xlabel('frame N')
pylab.title(droppedString)
pylab.subplot(1,3,3)
pylab.hist(intervalsMS, 50, normed=0, histtype='stepfilled')
pylab.xlabel('t (ms)')
pylab.ylabel('n frames')
pylab.title(distString)
show()
def float(value):
return __builtin__.float(value)
def pos_float(value):
value = __builtin__.float(value)
if value <= 0:
raise ValueError
return value
def contains(self, entry):
return (
(entry.as_seconds >= self.start.as_seconds)
and (entry.as_seconds <= self.end.as_seconds)
and (float(entry.speed) < pause_speed_limit)
)
