def get_tecs_for_Meredith2002_fig11(): exp_res = [] exp_res.append( TEC([Vector([1, 3])], [], [ Vector([0, -2]), Vector([0, 0]), Vector([1, -2]), Vector([1, -1]), Vector([1, 0]), Vector([2, -1]) ])) exp_res.append( TEC([Vector([2, 1]), Vector([2, 2])], [], [Vector([0, 0]), Vector([0, 1])])) exp_res.append( TEC([Vector([1, 1]), Vector([2, 1])], [], [Vector([0, 0]), Vector([0, 2]), Vector([1, 1])])) exp_res.append( TEC([Vector([1, 1]), Vector([1, 3]), Vector([2, 2])], [], [Vector([0, 0]), Vector([1, 0])])) return exp_res
def get_conj(tec, sorted_dataset): """ Computes the conjugate of a TEC as defined in equations 7-9 of [Meredith2013]. """ p_0 = tec.get_pattern()[0] conj_tec_pattern_ind = [tec.get_pattern_indices()[0]] p_prime = [p_0] for translator in tec.get_translators(): if not translator.is_zero(): p_prime_vec = p_0 + translator p_prime.append(p_prime_vec) # Find the index for the point in the pattern of the conjugate TEC. if p_prime_vec < p_0: for i in range(tec.get_pattern_indices()[0], -1, -1): if sorted_dataset[i] == p_prime_vec: conj_tec_pattern_ind.append(i) break else: for i in range(tec.get_pattern_indices()[0], len(sorted_dataset)): if sorted_dataset[i] == p_prime_vec: conj_tec_pattern_ind.append(i) break v_prime = [Vector.zero_vector(p_0.dimensionality())] for point in tec.get_pattern(): p = point - p_0 if not p.is_zero(): v_prime.append(point - p_0) conj_tec = TEC(p_prime, conj_tec_pattern_ind, v_prime) return conj_tec
def compute_encoding(tecs, d): """ Implements algorithm in Figure 7 of [Meredith2013]. """ best_tecs = [] cover = [] for i in range(0, len(tecs)): tec = tecs[i] s = tec.coverage() s_diff_cover = deepcopy(s) for p in cover: if p in s_diff_cover: s_diff_cover.remove(p) if len(s_diff_cover) > len(tec.get_pattern()) + len(tec.get_translators()) - 1: best_tecs.append(tec) cover += s dataset_covered = True for p in d: if p not in cover: dataset_covered = False break if dataset_covered: break residual = set(d) - set(cover) if residual: best_tecs.append(TEC(list(residual), [], [])) return best_tecs
def test_bounding_box(self): dataset = Dataset('unittest_data/heuristics_test.csv') dataset = Dataset.sort_ascending(dataset) tec = TEC( [Vector([1, 3]), Vector([3, 5]), Vector([4, 1]), Vector([5, 3])], [0, 3, 4, 6], [Vector([0, 0])]) self.assertEqual(heuristics.bounding_box_compactness(tec, dataset), 4 / 9)
def get_tec_for_mtp(pattern_indices, w, p): """ Find the TEC for the given MTP. This function is not described in [Meredith2013] but is said to use the logic of SIATEC, so this function uses the logic of finding translators for the pattern used in SIATEC. """ translators = find_translators(pattern_indices, w, len(p)) pattern = [] for index in pattern_indices: pattern.append(p[index]) tec = TEC(pattern, pattern_indices, translators) return tec
def siatechf(d, min_cr): """ SIATECH that only returns TECs that have compression ratio of at least min_cr. """ d = Dataset.sort_ascending(d) # Map of difference vector, index list pairs. mtp_map = {} # Compute the difference vectors between points and add both # the starting and ending index as pair to the lists corresponding to the # difference vector. for i in range(len(d)): for j in range(i + 1, len(d)): diff = d[j] - d[i] if diff in mtp_map: mtp_map[diff].append((i, j)) else: mtp_map[diff] = [(i, j)] tecs = [] handled_patterns = set() for diff_vec in mtp_map: pattern = [] pattern_indices = [] mtp = mtp_map[diff_vec] for index_pair in mtp: pattern_indices.append(index_pair[0]) pattern.append(d[index_pair[0]]) vectorized_pattern = Pattern(vec(pattern)) if vectorized_pattern not in handled_patterns: if cr_upper_bound(pattern, mtp_map, d) >= min_cr: translators = [] if len(pattern) == 1: for point in d: translators.append(point - pattern[0]) else: translators = find_translators_h(pattern, vectorized_pattern, mtp_map, d) tec = TEC(pattern, pattern_indices, translators) if heuristics.compression_ratio(tec) >= min_cr: tecs.append(tec) handled_patterns.add(vectorized_pattern) return tecs
def siatech(d): d = Dataset.sort_ascending(d) # Map of difference vector, index list pairs. mtp_map = {} # Compute the difference vectors between points and add both # the starting and ending index as pair to the lists corresponding to the # difference vector. for i in range(len(d)): for j in range(i + 1, len(d)): diff = d[j] - d[i] if diff in mtp_map: mtp_map[diff].append((i, j)) else: mtp_map[diff] = [(i, j)] tecs = [] handled_patterns = set() for diff_vec in mtp_map: pattern = [] pattern_indices = [] mtp = mtp_map[diff_vec] for index_pair in mtp: pattern_indices.append(index_pair[0]) pattern.append(d[index_pair[0]]) vectorized_pattern = Pattern(vec(pattern)) if vectorized_pattern not in handled_patterns: translators = [] if len(pattern) == 1: for point in d: translators.append(point - pattern[0]) else: translators = find_translators_h(pattern, vectorized_pattern, mtp_map, d) tecs.append(TEC(pattern, pattern_indices, translators)) handled_patterns.add(vectorized_pattern) return tecs
def siatech_compress(d): """ Implements SIATECCompress as defined in [Meredith2016] but uses SIATECH. """ tecs = siatech(d) sort_tecs_by_quality(tecs, d) covered_points = set() best_tecs = [] for tec in tecs: new_points = tec.coverage() - covered_points if len(new_points) > len(tec.get_pattern()) + len(tec.get_translators()): best_tecs.append(tec) covered_points = covered_points | tec.coverage() if len(covered_points) == len(d): break residual = set(d) - set(covered_points) if residual: best_tecs.append(TEC(list(residual), [], [])) return best_tecs
def compute_tecs(y, v, w, d): """ Implements algorithm of fig. 23 in [Meredith2002]. """ i = 0 tecs = [] while i < len(y): j = y[i][0] pattern_indices = [] while j < len(v) and v[j][0] == v[y[i][0]][0]: pattern_indices.append(v[j][1]) j += 1 pattern = collect_pattern(pattern_indices, d) translators = find_translators(pattern_indices, w, len(d)) tecs.append(TEC(pattern, pattern_indices, translators)) i += 1 while i < len(y) and y[i][1] == y[i - 1][1]: i += 1 return tecs
def test_pattern_volume(self): tec = TEC([Vector([2, -1, 0]), Vector([-1, 2, -1]), Vector([0, 1, 2])], [0, 1, 2], [Vector([0, 0, 0])]) self.assertEqual(heuristics.pattern_volume(tec), 27)
def test_pattern_width(self): tec = TEC([Vector([1, 3, 4]), Vector([1, 1, 5]), Vector([5, 1, 2])], [0, 1, 2], [Vector([0, 0, 0])]) self.assertEqual(heuristics.pattern_width(tec), 4)
#!/usr/bin/env python # -*- coding: utf-8 -*- from tec import TEC import pickle import copy std = pickle.load(open("test/TEC_temporary_STANDARD.dat","r")) output_current_array = [] motives = [] for data in std: tec = TEC(data) output_current_array.append([1e4*data["output_current_density"],tec.calc_forward_current_density()]) #input_params = copy.deepcopy(std[0]) #input_params["Collector"]["voltage"] = 0.5 #tec = TEC_Langmuir(input_params) #print tec["motive_data"].keys()