Uploaded generateTransformers

Transformers/generateTransformers.py

+from getFullList import getFullList
+from Transformer import OneToOneNumberTransformer
+def read_matrix(n):
+    answer = []
+    with open(str(n)+ "_matrix.csv") as ofile:
+        for line in ofile:
+            answer.append([(int(num) if num != '' else None) for num in line.split(",") ])
+    return answer
+
+def identify_generators(matrix):
+    n = len(matrix) - 1
+    positions = len(matrix[0]) -1
+    
+    occurrences_to_positions = {}
+    
+    for num in range(2, int(((n+1)/2))):
+        for pos in range(1, positions-1):
+            occurrences = matrix[num+1][pos+1]
+            if occurrences in occurrences_to_positions:
+                occurrences_to_positions[occurrences].append((num, pos))
+            else:
+                occurrences_to_positions[occurrences] = [(num,pos)]
+    
+    
+    
+    for occurrences in occurrences_to_positions:
+        if type(occurrences_to_positions[occurrences]) == list:
+            pairs = allPairsInList(occurrences_to_positions[occurrences])
+            for pair in pairs:
+                if len(make_generator(matrix, getFullList(n), pair[0][0], pair[0][1], pair[1][0], pair[1][1])) > 0:
+                    print(pair, "works")
+            
+
+def make_generator(matrix, ns1d0s, r1, c1, r2, c2):
+    source_num = matrix[r1 + 1][0]
+    source_pos = matrix[0][c1+ 1]
+    
+    dest_num = matrix[r2 + 1][0]
+    dest_pos = matrix[0][c2+1]
+    
+    
+    source_matching_sequences = [a for a in ns1d0s if a[source_pos] == source_num]
+    dest_matching_sequences = [a for a in ns1d0s if a[dest_pos] == dest_num]
+    
+    
+    source_all_nums = []
+    for source_sequence in source_matching_sequences:
+        source_all_nums.extend(source_sequence)
+        
+    dest_all_nums = []
+    for dest_sequence in dest_matching_sequences:
+        dest_all_nums.extend(dest_sequence)
+        
+    source_frequencies = []
+    dest_frequencies = []
+    for num in range(len(matrix)):
+        source_frequencies.append(source_all_nums.count(num))
+        dest_frequencies.append(dest_all_nums.count(num))
+        
+    if set(source_frequencies) != set(dest_frequencies):
+        return []
+    
+    
+    
+    mapping_dict = {}
+    
+    for i in range(len(matrix)):
+        if i == 0:
+            mapping_dict[0] = 0 
+            continue
+        elif i == 1:
+            mapping_dict[1] = 1
+            continue
+        elif i == r1:
+            mapping_dict[r1] = r2
+            continue
+        
+        matches = []
+        for j in range(len(matrix)):
+            if source_frequencies[i] == dest_frequencies[j]:
+                matches.append(j)
+        
+        if len(matches) == 1:
+            mapping_dict[i] = matches[0]
+        elif len(matches) == 0:
+            return []
+        else:
+            if source_frequencies[i] == 0:
+                mapping_dict[i] = matches[0]
+            else:
+                mapping_dict[i] = matches
+    
+    all_possible_mappings = make_possible_mappings(mapping_dict)
+    all_possible_generators = [OneToOneNumberTransformer(mapping) for mapping in all_possible_mappings]
+
+    good_fits = []
+    for generator in all_possible_generators:
+        if generator.check(source_matching_sequences, dest_matching_sequences):
+            good_fits.append(generator)
+
+    return good_fits
+    
+            
+
+def make_possible_mappings(mapping_dict):
+    possible_dicts = [{}]
+    for key in mapping_dict:
+        if type(mapping_dict[key]) == int:
+            for possible_dict in possible_dicts:
+                possible_dict[key] = mapping_dict[key]
+        else:
+            new_possibilities = []
+            for value in mapping_dict[key]:
+                for possible in possible_dicts:
+                    copied_possible = possible.copy()
+                    copied_possible[key] = value
+                    new_possibilities.append(copied_possible)
+            possible_dicts = new_possibilities
+            
+    return possible_dicts
+
+
+# This function generates all the pairs of objects in a given list of numbers, 
+# specifically it generates combinations rather than permutations (i.e. if a, b
+# is in the list of pairs, then b, a will not be).
+
+# input: a list of objects (list of objects of type i)
+# output: all pairs of those objects (list of lists of objects of type i)
+def allPairsInList(objectList):
+    combinations = allPermutationsOfLength(objectList,2)
+    for [a,b] in combinations:
+        if [b,a] in combinations:
+            combinations.remove([b,a])
+            
+    return combinations
+        
+# This function generates all permutations of a certain length from a list of 
+# objects. Since they are permutations, sequences containing the same objects
+# in a different order will occur (e.g. if 1,2,3 is a permutation, 3,2,1 will 
+# be as well).
+    
+# input: a list of objects (list of objects of type i), a length (int)
+# output: all permutations of the given length  of those objects 
+# (list of lists of objects of type i)
+def allPermutationsOfLength(objectList, length):
+    if length == 0:
+        return [[]]
+    else:
+        combos = []
+        for number in objectList:
+            subList = objectList.copy()
+            subList.remove(number)
+            subCombos = allPermutationsOfLength(subList, length-1)
+            for combo in subCombos:
+                combo.append(number)
+                combos.append(combo)
+        return combos
+