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 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()