def get_dynamic_performance_profile(instances, config, selector):
classes = config['solution_quality_classes']
bounds = config['solution_quality_class_bounds']
count = config['solution_quality_class_count']
groups = utils.get_groups(instances, 'qualities')
estimated_groups = utils.get_groups(instances, 'estimated_qualities')
length = utils.get_max_list_length(groups)
steps = range(length)
trimmed_groups = utils.get_trimmed_lists(groups, length)
trimmed_estimated_groups = utils.get_trimmed_lists(estimated_groups, length)
profile = get_initial_dynamic_performance_profile(classes, count, steps)
for i, _ in enumerate(trimmed_groups):
qualities = trimmed_groups[i]
estimated_qualities = trimmed_estimated_groups[i]
for step in steps:
if step + 1 < length:
origin_quality, target_quality = selector(qualities, estimated_qualities, step)
origin_class = utils.digitize(origin_quality, bounds)
target_class = utils.digitize(target_quality, bounds)
profile[origin_class][step][target_class] += 1
return get_normalized_performance_profile(profile, classes, steps)
def instant_vcp(port, address, cmd=0x63):
"""Возвращает список с текущими показаниями напряжения (В),
тока (А), потребляемой мощности (кВт/ч)"""
data = send_command(port, address, cmd)
voltage = digitize(data[1:3]) / 10.
current = digitize(data[3:5]) / 100.
power = digitize(data[5:8]) / 1000.
return [voltage, current, power]
def instant_vcp(port, address, cmd=0x63):
"""Возвращает список с текущими показаниями напряжения (В),
тока (А), потребляемой мощности (кВт/ч)"""
data = send_command(port, address, cmd)
voltage = digitize(data[1:3]) / 10.
current = digitize(data[3:5]) / 100.
power = digitize(data[5:8]) / 1000.
return [voltage, current, power]
def solution():
MAX = 100
maxsum = 0
for a in range(1, MAX):
for b in range(1, MAX):
maxsum = max(maxsum, sum(digitize(a ** b)))
return maxsum
def test(leading, trailing, possibles):
if tuple([leading]+[trailing] + possibles) in checked:
return 0
checked.add(tuple([leading]+[trailing] + possibles))
if ((leading + trailing + sum(possibles)) % 3) != 0:
return 0
# print [leading] + sorted(possibles) + [trailing]
for perm in permutations(possibles):
candidate = [1] + list(perm) + [trailing]
c = numberize(candidate)
base = sorted(candidate)
found = 0
for factor in [6,5,4,3,2]:
z = c*factor
# print c, z, base, sorted(digitize(z))
if sorted(digitize(z)) != base:
if found > 2:
print 'almost', c, factor
break
else:
found += 1
else:
print '**!!!', c
return c
return 0
def get_mevc(estimated_quality, step, profile_1, profile_3, config):
origin_class = utils.digitize(estimated_quality,
config['solution_quality_class_bounds'])
current_expected_value = 0
next_expected_value = 0
for target_class in config['solution_quality_classes']:
target_quality = utils.get_bin_value(
target_class, config['solution_quality_class_count'])
intrinsic_value = get_intrinsic_values(
target_quality, config['intrinsic_value_multiplier'])
current_time_cost = get_time_costs(step,
config['time_cost_multiplier'])
current_comprehensive_value = get_comprehensive_values(
intrinsic_value, current_time_cost)
current_expected_value += profile_3[origin_class][step][
target_class] * current_comprehensive_value
next_time_cost = get_time_costs(step + 1,
config['time_cost_multiplier'])
next_comprehensive_value = get_comprehensive_values(
intrinsic_value, next_time_cost)
next_expected_value += profile_1[origin_class][step][
target_class] * next_comprehensive_value
return next_expected_value - current_expected_value
def get_probabilistic_performance_profile(instances, config):
groups = utils.get_groups(instances, 'qualities')
length = utils.get_max_list_length(groups)
steps = range(length)
trimmed_groups = utils.get_trimmed_lists(groups, length)
profile = get_initial_probabilistic_performance_profile(config['solution_quality_class_count'], steps)
for step in steps:
for qualities in trimmed_groups:
target_quality = qualities[step]
target_class = utils.digitize(target_quality, config['solution_quality_class_bounds'])
profile[step][target_class] += 1
normalizer = sum(profile[step])
for target_class in config['solution_quality_classes']:
profile[step][target_class] /= normalizer
return profile
def get_optimal_action(quality, step, values, profile_2, profile_3, config):
origin_class = utils.digitize(quality,
config['solution_quality_class_bounds'])
stop_value = 0
continue_value = 0
for target_class in config['solution_quality_classes']:
target_quality = utils.get_bin_value(
target_class, config['solution_quality_class_count'])
intrinsic_value = get_intrinsic_values(
target_quality, config['intrinsic_value_multiplier'])
time_cost = get_time_costs(step, config['time_cost_multiplier'])
comprehensive_value = get_comprehensive_values(intrinsic_value,
time_cost)
stop_value += profile_3[origin_class][step][
target_class] * comprehensive_value
continue_value += profile_2[origin_class][step][target_class] * values[
target_class][step + 1]
return STOP_SYMBOL if stop_value >= continue_value else CONTINUE_SYMBOL
def solution(MAX):
normal = set()
lychrel = set()
for original in range(0,MAX):
current = set()
A = original
found = False
for j in range(51):
B = reverse(A)
C = A + B
current |= set([A])
if A in lychrel:
break
if is_palindrome(digitize(C)) or A in normal:
# optimization: all of the numbers in the current set are now normal
normal |= current
found = True
break
A = C
if not found:
lychrel |= current
return len([x for x in lychrel if x < MAX])
def get_normalized_state(self, raw_state):
raw_quality, raw_time = raw_state
bounds = np.linspace(0.15, 1, self.QUALITY_CLASS_COUNT)
return utils.digitize(raw_quality, bounds), raw_time
def candidates():
for p in gen_primes():
digits = digitize(p)
if len(digits) > len(set(digits)):
yield digits
def display_readings(port, address, cmd=0x27):
"""Возвращает список показаний потреблённой энергии в кВт/ч по 3 тарифам
с момента последнего сброса"""
data = send_command(port, address, cmd)
return [digitize(data[idx:idx+4]) / 100.0 for idx in range(1, 13, 4)]
def reverse(N):
return numberize([x for x in reversed(digitize(N))])
def plot(filename,
recording=0,
channels=None,
spikes=False,
t0=0,
t1=inf,
digitize=False,
output=None):
raw_data = McsPy.McsData.RawData(filename)
rec = raw_data.recordings[recording]
stream = rec.analog_streams[0]
segments = rec.segment_streams[0].segment_entity
timestamps = rec.timestamp_streams[0].timestamp_entity
if not channels:
channels = stream.channel_infos.keys()
n_channels = len(channels)
n_cols = int(np.ceil(np.sqrt(n_channels)))
n_rows = int(np.ceil(n_channels / n_cols))
fig, axes = plt.subplots(n_rows, n_cols, sharex=True, sharey=True)
axes = np.atleast_1d(axes)
axes = axes.flatten()
fig.suptitle(filename)
for i, ch in enumerate(channels):
label = stream.channel_infos[ch].label
label = "CH{}: {}".format(ch, label)
print(label, end='')
tick = stream.channel_infos[ch].sampling_tick
tick = ureg.convert(tick.magnitude, tick.units, "second")
idx_start = 0
idx_end = stream.channel_data.shape[1]
if t1 != inf:
idx_end = int(t1 / tick)
if t0 > 0:
idx_start = int(t0 / tick)
t, unit = stream.get_channel_sample_timestamps(ch, idx_start, idx_end)
t = ureg.convert(t, unit, "second")
data, unit = stream.get_channel_in_range(ch, idx_start, idx_end)
data = ureg.convert(data, unit, "microvolt")
ax = axes[i]
ax.set_title(label)
if i % n_cols == 0:
ax.set_ylabel("uV")
if i >= (n_cols * (n_rows - 1)):
ax.set_xlabel("Time")
ax.set_xlim(t[0], t[-1])
ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
ax.plot(t, data, color='#E24A33')
ymin, ymax = ax.get_ylim()
ylim = max(abs(ymin), abs(ymax))
yheight = 2 * ylim
ybot = -ylim
if spikes:
# Segments
if ch in segments:
signal, unit = segments[ch].get_segment_in_range(0, False)
signal = signal * ureg.convert(1, unit, "microvolt")
ts, unit = segments[ch].get_segment_sample_timestamps(0, False)
ts = ureg.convert(ts, unit, "second")
ts = np.ma.masked_outside(ts, t0, t1)
signal = np.ma.array(signal, mask=ts.mask)
cols = np.flatnonzero(np.ma.count(ts, axis=0))
n_segments = len(cols)
for j in cols:
ax.plot(ts[:, j], signal[:, j], color='#8EBA42')
print(", {} segments".format(n_segments), end='')
# Timestamps
if ch in timestamps:
ts, unit = timestamps[ch].get_timestamps()
ts = ureg.convert(ts, "microsecond", "second")
ts = np.ma.masked_outside(ts, t0, t1)
ts = ts.compressed()
ymax = ybot + yheight / 20
ax.vlines(ts, ybot, ymax, color='#8EBA42')
ybot += 1.1 * yheight / 20
print(", {} timestamps".format(len(ts)), end='')
if digitize:
# +/- 5std
mean = np.mean(data)
std = np.std(data)
th_lo = mean - 5 * std
th_hi = mean + 5 * std
print(", mean={}, std={}, th_hi={}, th_lo={}".format(
mean, std, th_hi, th_lo),
end='')
ax.axhline(th_hi, color='#E24A33')
ax.axhline(th_lo, color='#348ABD')
bits = utils.digitize(data, th_lo, th_hi)
idx = utils.split_where(bits)
for i, j in idx:
ax.plot(t[i:j], data[i:j], color='#988ED5')
print(", detected {} high bits".format(idx.shape[0]), end='')
height = yheight / 20
ax.plot(t, ybot + height * bits, color='#988ED5')
# ax.set_ylim(ymin=ymin)
ax.set_ylim(-ylim, ylim)
print("")
for i in range(n_channels, axes.shape[0]):
axes[i].set_visible(False)
if output:
plt.savefig(output)
else:
plt.show()