def main(): #challenge 9 print 'Challenge 9 Results: ' print Operations.padString('YELLOW SUBMARINE', 20, '\x04') #challenge 10 data = FileConvert.FileConvert("10.txt") data.b64ToBinary() data.integrate() iv = Operations.padString('', 16, '\x00') AESCipher = AESImplementation.AESstuff('YELLOW SUBMARINE') print AESCipher.CBCEncrypt(iv, data.getContent()) #challenge 11 data11 = FileConvert.FileConvert("12.txt") data11.integrate() RandCipher = AESImplementation.AESstuff(Operations.randombytes(16)) RandCipher.randKeyAndProtocol() if RandCipher.detectifECB() == 1: print "ECB Detected" else: print "CBC, Or something" #challenge 12 data12 = FileConvert.FileConvert("12.txt") data12.b64ToBinary()
def getListVersions(self, values, package): # get all node versions versionsNode = list(NodeManager.nodeVersions.values()) versionsNode.sort() versionsNode.reverse() # get the node version based in date values['node_on_date'] = NodeManager.getVersionOnDate( self.release.client_timestamp) # get only versions to execute posCurrentVersion = versionsNode.index(values['node_on_date']) versions = versionsNode[ posCurrentVersion:] # get only versions to execute # try get the version in package.json engines->node # if this versions doesn't exists in versions list, insert try: versionEngines = NodeManager.getVersionOnPackage(package) if not versions.__contains__(versionEngines): versions.insert(0, versionEngines) except (KeyError, AttributeError, TypeError): pass # do nothing # try with the lattest if not versions.__contains__('10.12.0'): versions.insert(0, '10.12.0') op.printTableInfo('NodeJS versions to run in {0}: {1}'.format( self.client_name, str(versions))) return versions
def AStar(initBoard, priority): startTime = time.time() output = {} visited = [] openList = [Node(initBoard, 0, None, priority)] count = 0 while (openList): if openList == []: return None # check if finish currentNode = openList[0] visited.append(currentNode.board) # print(currentNode.board) if (ops.isGoal(currentNode.board)): endTime = time.time() output["reachable"] = True output["iterations"] = count output["duration"] = endTime - startTime output["priority"] = priority output["nb_moves"] = openList[0].step return output, openList openList.pop(0) count += 1 nextMoves = ops.moves(currentNode.board) for nextMove in nextMoves: if nextMove not in visited: openList.append( Node(nextMove, currentNode.step + 1, currentNode, priority)) openList.sort(key=lambda x: x.value)
def cron(request, db): blob_data = [blob.name for blob in bucket.list_blobs()] data = Operations.findall(db, collection, {'type': 'file'}) dbfiles = [d['file_id'] for d in data] delete_files = list(set(blob_data) - set(dbfiles)) dbdata = [] blob_delete = [] for d in data: if (d['file_id'].lower().endswith('.txt')): dbdata.append(d['_id']) blob_delete.append(d['file_id']) delete_files = delete_files + blob_delete db_delete_status = True blob_delete_status = True try: for blob in bucket.list_blobs(): if blob.name in delete_files: blob.delete() except: blob_delete_status = False try: db_delete_status = Operations.deleteMany(db, collection, {'_id': { '$in': dbdata }}) except: db_delete_status = False return json.dumps( { 'dbstatus': db_delete_status, 'blob_status': blob_delete_status }, default=str), 200, headers
def main(): global session session = tf.Session() print("Creating network..") NC.create_network(FP.json_path) NC.define_cost() PM.initialize_performance_measures() Operations.train()
def __init__(self, *patterns): self.data = [] item = [Base.asStream(p) for p in patterns] size = op.LCM(*[len(i) for i in item]) for n in range(size): for i in item: self.data.append(op.modi(i, n)) self.make()
def main(): if os.path.exists(DPATH): #R ootHash Login OPT.login(COLOR, FONT, SPATH) else: # When RootHash execute first time in a computer, this will run Root.first_time()
def __init__(self, inputBoard, step, parent, priority): self.board = inputBoard self.step = step if priority == "Hamming": self.value = ops.DistHamming(inputBoard) + self.step else: self.value = ops.DistManhattan(inputBoard) + self.step self.parent = parent self.priority = priority
def __init__(self, string, n, no_measurment_qubits=1, left_justified=False): """ :param string: This should be a string of 1's and 0's where 1 is the |1> and 0 is |0> :param n: The number of qubits in the system :param no_measurment_qubits: The number of qubits that will be measured :return: Returns the Description of class variables state: This is the density matrix of the system classical_states: This is a dictionary of computational basis states that should have has its keys labels of computational basis states and values the corresponding probabilities projectors: This is a dictionary with keys being labels for the computational basis states and the values being the corresponding projectors for that particular computational basis state. no_measurement_qubits: The number of qubits you intend to measure classical_states_history: Has a key values all possible measurement syndromes and keeps a record of their probabilities """ oper_dict = {'0': g.b1(), '1': g.b4(), '2': g.id()} self.state = op.superkron(oper_dict, val=1, string=string) self.n = n self.no_measurement_qubits = no_measurment_qubits self.measurement_string = op.createlabel(self.no_measurement_qubits, 2) for i in range(len(self.measurement_string)): if left_justified: self.measurement_string[i] = self.measurement_string[i].ljust( self.n, '2') else: self.measurement_string[i] = self.measurement_string[i].rjust( self.n, '2') self.projectors = { i.replace('2', ''): op.superkron(oper_dict, val=1, string=i) for i in self.measurement_string } self.classical_states = { i.replace('2', ''): 0 for i in self.measurement_string } self.classical_states_history = { i.replace('2', ''): [] for i in self.measurement_string } self.hamiltonian = None self.dt = None self.U = None self.xlabel = '' self.ylabel = '' self.T = None self.kraus_operators = []
def __init__(self, pat1, pat2, rule=lambda a, b: True): length = op.LCM(len(pat1), len(pat2)) self.data = [] i = 0 while i < min(length, 32): a, b = op.modi(pat1,i), op.modi(pat2,i) if rule(a, b): self.data.append((a,b)) i += 1 self.make()
def raw_harvest (year, game_num, away_acronym, home_acronym, away_roster, home_roster): """ Extract play-by-play information from a html file on the local machine (in the form of raw, unspeficied events). Returns list of unspecified event objects """ tree = Operations.germinate_report_seed(year,game_num,'PL','02') events = [] # empty list for holding unspecified events for item in tree.xpath('//table/tr[@class="evenColor"]'): event_raw = item.xpath('./td/text()') num = int(event_raw[0]) per_num = int(event_raw[1]) strength = unicode(event_raw[2]) time = unicode(event_raw[3]) event_type = unicode(event_raw[5]) description = unicode(event_raw[6]) try: # Zone not always indicated in event description # A bit redudant, done also before pruning events description_raw = description.split() zone_index = description_raw.index('Zone,') - 1 zone = description_raw[zone_index] except ValueError: try: # Certain events have zone at end of description zone_index = description_raw.index('Zone') - 1 zone = description_raw[zone_index] except ValueError: zone = None assert zone == 'Neu.' or zone == 'Off.' or zone == 'Def.' \ or zone == None, "ERROR: Event zone(%s) invalid"%(zone) # Goals have an additional row in the description cell for assists if event_type == 'GOAL' and event_raw[7].find('Assist') != -1: description = unicode(" ".join(event_raw[6:8])) players_on_ice = item.xpath('./td/table') home_on_ice = [] away_on_ice = [] if len (players_on_ice) == 2: # Perhaps make this more robust? away_on_ice = Operations.chop_on_ice_branch ( players_on_ice[0], away_roster) home_on_ice = Operations.chop_on_ice_branch ( players_on_ice[1], home_roster) event = Event(num, per_num, strength, time, event_type, zone, description, away_acronym, home_acronym, away_on_ice, home_on_ice) events.append (event) return events
def analyseJUD(text, expression, count, flag, OP, c): """ Analyse une opération de jointure entrée au clavier. Le paramètre OP spécifie le type de l'Opération à créer: 1) OP = "J" => Join 2) OP = "U" => Union ") OP = "D" => Diff Syntaxe attendue : -exemple1 : Join(Rel(name);Rel(name)) -exemple2 : Join(*expr1*;*expre2*) -exemple3 : Union(*expr1*;*expre2*) -exemple4 : Diff(*expr1*;*expre2*) Note : expr1 et expr2 sont des expressions SPJRUD entrée au clavier en respectant la syntaxe. """ flag.append(False) param1 = None param2 = None if(OP == "J"): currentExpression = o.Join(param1,param2, c) elif (OP == "U"): currentExpression = o.Union(param1,param2, c) elif (OP == "D"): currentExpression = o.Diff(param1,param2, c) #On analyse le param1 count += 1 if(text[count:count+3] == "Rel"): currentExpression.param1=(e.Relation(analyseRel(text, count), c)) while(text[count] != ";"): count += 1 else: tempExpr = None tempf = [] #On effectue une seconde récursion pour déterminer le premier paramètre l = analyseLen(text, count) tempExpr = analyseInput(text, tempExpr, count, tempf, c) currentExpression.param1 = tempExpr #On calcule l'indice de début du param2 count += l #On analyse le param2 count += 1 if(text[count:count+3] == "Rel"): flag[-1] = True currentExpression.param2=(e.Relation(analyseRel(text, count), c)) else: flag[-1] = False if (expression != None): #Ce n'est pas la première opération de l'expression : On ajoute l'opération à l'expression existante expression.addExpr(currentExpression) return expression, flag, count else: #C'est la première opération de l'expression expression = currentExpression return expression, flag, count
async def ThirdFunction(time): print('Thread 3 started...') await asyncio.sleep(time) O = Obj.CreateVector(4, 3) P = Obj.CreateVector(4, 3) MS = Obj.CreateMatrix(4, 3) MT = Obj.CreateMatrix(4, 3) Result = Opr.SubtractVectors( Opr.MultiplyMatrixVector(Opr.SortMatrix(Opr.MultiplyMatrix(MS, MT)), O), P) print('\nFunction 3 result:\n' + str(Result))
async def SecondFunction(time): print('Thread 2 started...') await asyncio.sleep(time) MG = Obj.CreateMatrix(4, 2) MH = Obj.CreateMatrix(4, 2) MK = Obj.CreateMatrix(4, 2) ML = Obj.CreateMatrix(4, 2) Result = Opr.MultiplyMatrix(Opr.MultiplyMatrix(MG, MH), Opr.SumMatrix(MK, ML)) prettyList = pprint.pformat(Result) print('\nFunction 2 result:\n' + prettyList)
async def FirstFunction(time): print('Thread 1 started...') await asyncio.sleep(time) A = Obj.CreateVector(4, 1) B = Obj.CreateVector(4, 1) C = Obj.CreateVector(4, 1) MA = Obj.CreateMatrix(4, 1) ME = Obj.CreateMatrix(4, 1) #sleep Result = Opr.MultiplyVectors(B, C) + Opr.MultiplyVectors( A, B) + Opr.MultiplyVectors( Opr.MultiplyMatrixVector(Opr.MultiplyMatrix(MA, ME), B), C) print('\nFunction 1 result:\n' + str(Result))
def hsite(self): """ :return: Returns the on site hamiltonian """ labels = self.getlabels() operators = {'0': g.id(), '1': np.dot(g.b3(), g.b2())} ham = np.zeros((pow(2, self.n), pow(2, self.n))) for l in range(0, len(labels)): hamstring = op.generatetensorstring(self.n, l + 1) ham += op.superkron(operators, val=1, string=hamstring) return ham
def AdminPanel(usrName, filename): print("Welcome to the software: " + usrName) operationAns = input("What action would you like to perform on the csv file: \n\n1.Add an account \n2.Delete an account \n3.Edit an account\n") if operationAns == '1': ops.Add(filename) elif operationAns == '2': ops.Delete(filename) elif operationAns == '3': ops.Edit(filename) else: print("Error: incorrect input, please enter with 1, 2 or 3 \n") AdminPanel(usrName, filename)
def prune_block(event, description_raw, game_personnel): block_anchor = Operations.substring_index(description_raw, 'BLOCKED')[0] delim_index = Operations.substring_index(description_raw, ',')[0] + 1 assert block_anchor != -1 and delim_index != 0, "ERROR - Anchor not found" assert 'Zone' in description_raw, "ERROR - 'Zone' not found" shot_type = description_raw[-3].strip(',') blocking_team = description_raw[block_anchor + 2] blocking_num = description_raw[block_anchor + 3].strip('#') blocking_name = ( " ".join(description_raw[block_anchor + 4: delim_index])).strip (',') if blocking_team == event.home_acronym: shooting_on_ice = event.away_on_ice shooting_roster = game_personnel.away_roster blocking_on_ice = event.home_on_ice blocking_roster = game_personnel.home_roster elif blocking_team == event.away_acronym: shooting_on_ice = event.home_on_ice shooting_roster = game_personnel.home_roster blocking_on_ice = event.away_on_ice blocking_roster = game_personnel.away_roster else: assert False, 'ERROR: shooting_team(%s) doesnt match home (%s) or away\ (%s) team'%(shooting_team, event.away_acronym, event.home_acronym) if block_anchor >= 3: shooting_name = " ".join(description_raw[2:block_anchor]) shooting_team = description_raw[0] shooting_num = description_raw[1].strip('#') shooting_player = clone_rosterplayer( shooting_num, shooting_name, shooting_roster) else: # NHL f****d up; loaded a blank shooter if blocking_team == event.away_acronym: shooting_team = event.home_acronym elif blocking_team == event.home_acronym: shooting_team = event.home_acronym shooting_player = Roster.return_null_player() blocking_player = clone_rosterplayer( blocking_num, blocking_name, blocking_roster) return Block( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, shot_type, shooting_player, blocking_player, shooting_team, blocking_team)
def Resolve_Signal(Sig_Index, kernel): #(Make sure you put driving count = 0 after resolving values) final_val = M.VALUE_Z for i in range(0,kernel.Signal[Sig_Index]['Driving_Count']): final_val = OP.Resolve_Value(final_val, kernel.Driver[kernel.Signal[Sig_Index]['Driver_Head'] + i]) if(final_val != kernel.Signal[Sig_Index]['Eff_Val']): kernel.Signal[Sig_Index]['Eff_Val'] = final_val OP.Trigger_Sensitive_Processes(Sig_Index,kernel) kernel.Signal[Sig_Index]['Driving_Count'] = 0
def echo_message(message): bot.send_chat_action(message.chat.id, 'typing') text = op.strip_accents(message.text) if op.validar_mensaje(text): bot.send_message( message.chat.id, "Debes seguir esta estructura:\n\nNombres ApellidoMaterno ApellidoPaterno Materia", parse_mode="MARKDOWN") with open('Images/giphy.gif', 'rb') as gif: bot.send_sticker(message.chat.id, gif) else: # La materia son las ultimas dos palabras materia = ' '.join(text.split(' ')[-2:]) archivo = op.regresa_archivo(materia) if archivo == None: bot.send_message( message.chat.id, f"La materia: ___{materia}___ no existe, prueba cambiando el numero a romano o viceversa", parse_mode="MARKDOWN") with open('Images/fallout.webp', 'rb') as gif: bot.send_sticker(message.chat.id, gif) else: nombre = text.split(' ')[:-2] alumno = op.bitacora_alumno(archivo, nombre) if alumno == None: bot.send_message( message.chat.id, f"El nombre: ___{' '.join(nombre)}___ no esta en mi base de datos", parse_mode="MARKDOWN") with open('Images/mario.webp', 'rb') as gif: bot.send_sticker(message.chat.id, gif) else: try: bot.send_message(message.chat.id, f"```{alumno.get_table()}```", parse_mode="MARKDOWN") except telebot.apihelper.ApiTelegramException as ex: if ex.error_code == 400: with open('temp.html', 'w', encoding="UTF-8") as f: f.write(f"{alumno.nombre}\n\n{alumno.get_html()}") with open('temp.html', 'rb') as f: bot.send_document(message.chat.id, f) bot.send_message( message.chat.id, f"___{alumno.nombre} - {materia.upper()}___ [👨🏼🎓]\n\nTienes {alumno.promedio} [📝]\n\nDado tu puntaje eres el numero {alumno.ranking} [🌟]", parse_mode="MARKDOWN") with open('log.txt', 'a', encoding="UTF-8") as f: f.write( f"{message.from_user.username} | {alumno.nombre} | {materia} | {datetime.datetime.now()}\n" )
def noaction_operators(self): operators = {'0': g.id(), '1': g.b1()} perceptnum = len(self.perceptlabels()) actuatorlist = self.actuatorlabels() list_op = {} actlist = range(0, len(actuatorlist)) for a_1, a_2 in zip(actlist, actuatorlist): opstring = op.generatetensorstring(self.n, perceptnum + a_1 + 1) list_op['n' + a_2] = op.superkron(operators, val=1, string=opstring) return list_op
def generate(p): if is_atom(p): return values[p] elif len(p) == 2: if p[0] == "!": return op.negate(generate(p[1])) elif len(p) == 3: if p[1] == "&": return op.conjuction(generate(p[0]), generate(p[2])) if p[1] == "|": return op.disjunction(generate(p[0]), generate(p[2])) if p[1] == ">": return op.implies(generate(p[0]), generate(p[2])) if p[1] == "=": return op.equivalence(generate(p[0]), generate(p[2]))
def prune_give_take(event, description_raw, game_personnel): givetake_team = description_raw[0] givetake_num = description_raw[3].strip('#') delim_anchor = Operations.substring_index(description_raw, ',')[0] + 1 assert delim_anchor != 0, "ERROR - Anchor not found" givetake_name = (" ".join(description_raw[4:delim_anchor])).strip(',') if givetake_team == event.away_acronym: givetake_on_ice = event.away_on_ice givetake_roster = game_personnel.away_roster elif givetake_team == event.home_acronym: givetake_on_ice = event.home_on_ice givetake_roster = game_personnel.home_roster else: assert False, "ERROR: Which team(%s) gave/took away??"%(givetake_team) givetake_player = clone_rosterplayer( givetake_num, givetake_name, givetake_roster) if event.event_type == 'GIVE': return Give( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, givetake_player, givetake_team) elif event.event_type == 'TAKE': return Take( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, givetake_player, givetake_team)
def pauli_group(n, full=False, normalize=True): """ :param n: number of qubits :param full: If true returns the full pauli group for n qubits including group elements that differ by center of the group :param normalize: If true returns pauli group elements so that group are normalized :return: Returns a dictionary of unitary representation of the single qubit pauli group """ if normalize: pauli_matrix = { 'I': id() / sqrt(2), 'X': x() / sqrt(2), 'Y': y() / sqrt(2), 'Z': z() / sqrt(2) } else: pauli_matrix = {'I': id(), 'X': x(), 'Y': y(), 'Z': z()} center = {'i': 1j, '-i': -1j, '1': 1, '-1': -1} pauli_labels = [''.join(i) for i in product('IXYZ', repeat=n)] qubit_group = {} pauli_dict = {} if full is False: for pl in pauli_labels: pauli_dict[pl] = op.superkron(pauli_matrix, val=1, string=pl) else: for i in center: for p in pauli_dict: qubit_group[str(i) + str(p)] = dot(center[i], pauli_dict[p]) return pauli_dict
def create_filter(self, filter_set, repoman): filter = None name = filter_set.pop(0) if filter_set.pop(0) == "And": filter = Filter.Filter(name, Filter.And) else: filter = Filter.Filter(name, Filter.Or) # Get rid of 'begin items' and 'end items' strings filter_set.pop(0) filter_set.pop() while len(filter_set) > 0: filter_type = filter_set.pop(0) if filter_type == "BEGIN ITEM": key = filter_set.pop(0) op = Operations.opForName(filter_set.pop(0)) value = eval(filter_set.pop(0)) filter.add_item(FilterItem(key, op, value)) elif filter_type == "BEGIN GROUP": group = filter_set.pop(0) isMember = eval(filter_set.pop(0)) filter.add_item(FilterGroup(group, isMember, repoman)) else: target = self.get(filter_set.pop(0)) value = eval(filter_set.pop(0)) filter.add_item(FilterFilter(target, value)) # Get rid of 'end item', 'end group' or 'end filterfilter' strings filter_set.pop(0) return filter
def fullHamDist(List, Blocksize): subLists = [] for i in range(0, len(List), Blocksize): subLists.append(List[i:i + Blocksize]) Average = 0 num = 0 for i in range(0, len(subLists)): for j in range(1, len(subLists)): Average += op.binhamdist(subLists[i], subLists[j]) num += 1 Average /= float(num) return Average # file = open("FIND_ECB","r") # hexStr = "" # BinaryList = [] # for line in file: # hexStr = line # binStr = binascii.a2b_hex(hexStr.strip("\n")) # BinaryList.append(binStr) # file.close() # # Distances = [] # Index = 1 # for list in BinaryList: # avgDist = fullHamDist(list,16) # Distances.append((avgDist,Index)) # Index += 1 # # Minimum, Index = op.indexOfMinimum(Distances) # print Distances[Index-1] # print Index
def kraus_ad(n, t, t1): """ Produces the kraus matrices for the amplitude damping channel :param n: number of qubit :param t: time step for evolution :param t1: relaxation time :return: returns a 3 dimensinal array of amplitude damping kraus matrices """ A = np.zeros((pow(2, n), pow(2, n), pow(2, n)), dtype=complex) # 3 dimensional array to store kraus matrices gamma = 1 - np.exp(-t / t1) adOperators = { "0": np.array([[1, 0], [0, np.sqrt(1 - gamma)]]), "1": np.array([[0, np.sqrt(gamma)], [0, 0]]) } labels = op.createlabel(n, 2) for i in range(len(labels)): temp = 1 for digit in labels[i]: temp = np.kron(temp, adOperators[digit]) A[i] = temp return A
def kraus_pta(n, t, t1, t2): """ Produces the kraus matrices for the pta channel :param n: number of qubit :param t: time step for evolution :param t1: relaxation time :param t2: dephasing time :return: returns a 3 dimensinal array of pta kraus matrices """ gamma = 1 - np.exp(-t / t1) t_phi = Decimal(1 / t2) - Decimal(1 / (2 * t1)) # lambda1 = np.exp(-t/t1)*(1-np.exp(-2*(t/t_phi))) px = py = gamma / 4.0 pz = 1.0 / 2.0 - py - np.exp(-t / (2 * t1)) * np.exp(-(t / t_phi)) / 2 pi = 1 - (px + py + pz) print('px: ', py, 'pz: ', pz, 'pi: ', pi) A = np.zeros((pow(4, n), pow(2, n), pow(2, n)), dtype=complex) # 3 dimensional array to store kraus matrices ptaOperators = { '0': np.sqrt(pi) * g.id(), '1': np.sqrt(px) * g.x(), '2': np.sqrt(py) * g.y(), '3': np.sqrt(pz) * g.z() } # get labels labels = op.createlabel(n, 4) for i in range(len(labels)): temp = 1 for digit in labels[i]: temp = np.kron(temp, ptaOperators[digit]) A[i] = temp return A
def pta_ad(n, t, t1): """ Produces the kraus matrices for the pta channel :param n: number of qubit :param t: time step for evolution :param t1: relaxation time :return: returns a 3 dimensinal array of pta kraus matrices """ gamma = 1 - np.exp(-t / t1) px = py = gamma / 4.0 pz = 1.0 / 2.0 - py - np.sqrt(1 - gamma) / 2 pi = 1 - (px + py + pz) A = np.zeros((pow(4, n), pow(2, n), pow(2, n)), dtype=complex) # 3 dimensional array to store kraus matrices ptaOperators = { '0': np.sqrt(pi) * g.id(), '1': np.sqrt(px) * g.x(), '2': np.sqrt(py) * g.y(), '3': np.sqrt(pz) * g.z() } # get labels labels = op.createlabel(n, 4) for i in range(len(labels)): temp = 1 for digit in labels[i]: temp = np.kron(temp, ptaOperators[digit]) A[i] = temp return A
def __init__(self, s, dur=0.5): self.data = [] chars = PSeq().fromString(s) for i, char in chars.items(): dur = op.modi(dur, i) if char == " ": self.data[-1] += dur else: if len(char) > 1: div = float(len(char)) this_dur = PRhythm(str(char), dur / div).list() self.data += this_dur else: self.data.append(dur)
def Execute_Time_Events(kernel): for ele in kernel.Event_List[0][1:]: if( ele[0] < 0): # Delayed Signal OP.Insert_Driving_Value(ele[1],ele[2],kernel) # ele[1] = Sig_Index , ele[2] = Value else: Execute_Process(ele, kernel) # process and kernel sent kernel.Event_List.pop(0) # Removes already happed time events for i in range(1,kernel.Signal_Update_Event[0]+1): Resolve_Signal(kernel.Signal_Update_Event[i], kernel) # Signal_index and kernel sent kernel.Signal_Update_Event[0] = 0 # Resets the Signal Update Head while(bool(kernel.Process_Trigger_Event[0])): # if Some process trigering is registered, then entered in while for i in range(1,kernel.Process_Trigger_Event[0]+1): Execute_Process(kernel.Signal_Triggered_Process[kernel.Process_Trigger_Event[i]], kernel) kernel.Signal_Triggered_Process[kernel.Process_Trigger_Event[i]]['Triggered_Bit'] = 0 # Resets. Now it can again be registered for Trigering kernel.Process_Trigger_Event[0] = 0 # Resets the Process Trigger Head for i in range(1,kernel.Signal_Update_Event[0]+1): Resolve_Signal(kernel.Signal_Update_Event[i], kernel) # Signal_index and kernel sent kernel.Signal_Update_Event[0] = 0 # Resets the Signal Update Head
def __init__(self, *pats): l, p = [], [] for pat in pats: p.append(Base.asStream(pat)) l.append(len(p[-1])) length = op.LCM(*l) self.data = zip(*[p[i].stretch(length) for i in range(len(p))])
class TestOperationsMethods(unittest.TestCase): def setUp(self): self.operations = Operations() def test_operations(self): self.assertEqual("Running app 'app1' in namespace 'dev' nice", self.operations.runningInfo("app1", "dev"))
def Execute_Process(process, kernel): suspend = 0 # if 1, then process should be suspended if (process['Current_Instruction_Index'] >= process['Instruction_End_Index']): #Exceded own region process['Current_Instruction_Index'] = process[ 'Instruction_Start_Index'] # resets while (not (bool(suspend))): if (process['Current_Instruction_Index'] >= process['Instruction_End_Index']): process['Current_Instruction_Index'] = process[ 'Instruction_Start_Index'] suspend = 1 if (len(process) == 3): # Time Sensitive Process OP.Schedule_Time_Event( process, 0, kernel) # Schedules process event in the next timestrap else: suspend = Execute_Instruction( process, kernel ) # Executes the Instruction pointed by process['Current_Instruction_Index']
def delete(request, db): try: document_id = request.args.get('docid') status = Operations.deleteOne(db, collection, document_id) return json.dumps({'status': status}, default=str), 200, headers except: return "Invalid JSON"
def fullHamDist(List, Blocksize): subLists = [] for i in range(0,len(List),Blocksize): subLists.append(List[i:i + Blocksize]) Average = 0 num = 0 for i in range(0,len(subLists)): for j in range(1,len(subLists)): Average += op.binhamdist(subLists[i], subLists[j]) num += 1 Average /= float(num) return Average # file = open("FIND_ECB","r") # hexStr = "" # BinaryList = [] # for line in file: # hexStr = line # binStr = binascii.a2b_hex(hexStr.strip("\n")) # BinaryList.append(binStr) # file.close() # # Distances = [] # Index = 1 # for list in BinaryList: # avgDist = fullHamDist(list,16) # Distances.append((avgDist,Index)) # Index += 1 # # Minimum, Index = op.indexOfMinimum(Distances) # print Distances[Index-1] # print Index
def playbyplay_extractor (year, game_num): """ Extract play-by-play information from a html file on the local machine (in the form of events) """ tree = Operations.germinate_report_seed(year,game_num,'PL','02') events = [] # empty list for holding unspecified events for item in tree.xpath('//table/tr[@class="evenColor"]'): #for x in range (116, 120): # item = tree.xpath('//table/tr[@class="evenColor"]') [x] event_raw = item.xpath('./td/text()') num = unicode(event_raw[0]) per_num = unicode(event_raw[1]) strength = unicode(event_raw[2]) time = unicode(event_raw[3]) event_type = unicode(event_raw[5]) description = unicode(event_raw[6]) # Goals have an additional row in the description cell for assists if event_type == 'GOAL' and event_raw[7].find('Assist') != -1: description = unicode(" ".join(event_raw[6:8])) players_on_ice = item.xpath('./td/table') home_on_ice = [] away_on_ice = [] if len (players_on_ice) == 2: away_players_raw = players_on_ice[0].xpath ('.//font') for away_player in away_players_raw: position_name = away_player.xpath ('./@title') number = away_player.xpath ('./text()') [0] position, name = position_name[0].split(' - ') away_on_ice.append ([position, name, number]) home_players_raw = players_on_ice[1].xpath ('.//font') for home_player in home_players_raw: position_name = home_player.xpath ('./@title') number = home_player.xpath ('./text()') [0] position, name = position_name[0].split(' - ') home_on_ice.append ([position, name, number]) event = Objects.Event( num, per_num, strength, time, event_type, description,\ away_on_ice, home_on_ice ) events.append (event) return events
def __init__(self, *patterns): self.data = [] item = [asStream(p) for p in patterns] size = op.LCM(*[len(i) for i in item]) for n in range(size): for i in item: self.data.append(op.modi(i,n)) self.make()
def __init__(self, data, n=1): n = P(n) lrg = max(len(data), len(n)) self.data = [] for i in range(lrg): for j in range(op.modi(n,i)): self.data.append(op.modi(data,i)) ## for i, item in enumerate(data): ## for j in range(op.modi(n,i)): ## self.data.append( item ) self.make()
def description(self): value = None if type(self.value) == int: value = "%d" % self.value elif type(self.value) == float: value = "%.2f" % self.value else: value = "%s" % self.value return self.key + " " + Operations.nameForOp(self.op) + " " + value
def __init__(self, data, n=1): self.data = [] for i, item in enumerate(data): for j in range(op.modi(n,i)): self.data.append( item ) self.make()
def save(self, f): f.write('BEGIN ITEM') f.write(os.linesep) f.write(self.key) f.write(os.linesep) f.write(Operations.nameForOp(self.op)) f.write(os.linesep) f.write(repr(self.value)) f.write(os.linesep) f.write('END ITEM') f.write(os.linesep)
def prune_stop(event, description_raw, event_index, event_list, game_personnel): stopping_player = Roster.return_null_player() stopping_team = None zone = None tv_timeout = 0 timeout_caller = None description_raw = re.split('\W+', event.description) description_parsed = " ".join(description_raw) # Parse out 'TV TIMEOUT if not only item if 'TV' in description_raw: tv_timeout = 1 if len(description_raw) != 2: index = description_raw.index("TV") description_raw.pop (index) description_raw.pop (index) description_parsed = " ".join(description_raw) if 'HOME' in description_raw: timeout_caller = game_personnel.home_coach.full_name() elif 'VISITOR' in description_raw: timeout_caller = game_personnel.away_coach.full_name() if "GOALIE" in description_raw or 'FROZEN' in description_raw: stopping_team, stopping_on_ice = Operations.team_responsible( event_index, event_list) for player in stopping_on_ice: if player.pos == 'Goalie': stopping_player = player elif "ICING" in description_raw: stopping_team, stopping_on_ice = Operations.team_responsible( event_index, event_list) return Stop( event.num, event.period_num, event.strength, event.time, event.event_type, zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, description_parsed, stopping_player, stopping_team, tv_timeout, timeout_caller)
def test_all(): year = '20142015' report_type = 'PL' game_type = '02' for x in range (750,1150): game_num = Operations.pad_game_num(x) game_info = GameHeader.harvest(year, game_num, report_type, game_type) game_personnel = Roster.harvest(year, game_num) game_summary = GameSummary.harvest(year, game_num, game_info, game_personnel) yield check_refs, game_personnel, game_summary
def prune_hit(event, description_raw, game_personnel): hit_anchor = description_raw.index('HIT') delim_anchors = Operations.substring_index(description_raw, ',') assert hit_anchor != -1, "ERROR - Anchor not found" if delim_anchors == []: # No zone entered in nhl report hit_name = (" ".join( description_raw[hit_anchor + 3:])).strip (',') else: name_anchor = delim_anchors[0] + 1 hit_name = (" ".join( description_raw[hit_anchor + 3: name_anchor])).strip (',') hit_team = description_raw[hit_anchor + 1] hit_num = description_raw[hit_anchor + 2].strip('#') if hit_team == event.home_acronym: hitting_on_ice = event.away_on_ice hitting_roster = game_personnel.away_roster hit_on_ice = event.home_on_ice hit_roster = game_personnel.home_roster elif hit_team == event.away_acronym: hitting_on_ice = event.home_on_ice hitting_roster = game_personnel.home_roster hit_on_ice = event.away_on_ice hit_roster = game_personnel.away_roster else: assert False, 'ERROR: hit_team(%s) doesnt match home (%s) or away\ (%s) team'%(hit_team, event.away_acronym, event.home_acronym) if hit_anchor >= 3: hitting_team = description_raw[0] hitting_num = description_raw[1].strip('#') hitting_name = " ".join(description_raw[2:hit_anchor]) hitting_player = clone_rosterplayer( hitting_num, hitting_name, hitting_roster) else:# NHL f****d up; loaded a blank hitter if hit_team == event.away_acronym: hitting_team = event.home_acronym elif hit_team == event.home_acronym: hitting_team = event.home_acronym hitting_player = Roster.return_null_player() hit_player = clone_rosterplayer(hit_num, hit_name, hit_roster) return Hit( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, hitting_player, hit_player, hitting_team, hit_team)
def prune_miss(event, description_raw, game_personnel): delim_anchors = Operations.substring_index(description_raw, ',') delim_anchor = delim_anchors[0] + 1 assert delim_anchor != 0, "ERROR - Anchor not found" if len(delim_anchors) < 4: # Part of info is missing-usually shot/miss type shot_type = None miss_type = None else: shot_type = description_raw[-8].strip(',') miss_type = (" ".join(description_raw[delim_anchor + 1:-4])).strip(',') distance = description_raw[-2] shooting_team = description_raw[0] shooting_num = description_raw[1].strip('#') shooting_name = (" ".join(description_raw[2:delim_anchor])).strip(',') shooting_player = (shooting_num, shooting_name) if shooting_team == event.away_acronym: shooting_on_ice = event.away_on_ice shooting_roster = game_personnel.away_roster blocking_on_ice = event.home_on_ice blocking_team = event.home_acronym blocking_roster = game_personnel.home_roster elif shooting_team == event.home_acronym: shooting_on_ice = event.home_on_ice shooting_roster = game_personnel.home_roster blocking_on_ice = event.away_on_ice blocking_team = event.away_acronym blocking_roster = game_personnel.away_roster else: assert False, 'ERROR: shooting_team doesnt match home or away team' for player in blocking_on_ice: blocking_player = Roster.return_null_player() if player.pos == 'G': blocking_player = player shooting_player = clone_rosterplayer( shooting_num, shooting_name, shooting_roster) return Miss( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, shot_type, miss_type, distance, shooting_player, blocking_player, shooting_team, blocking_team)
def __init__( self, name, SA, rt_cnts, sht_cnts, rt_wght, gfact, load_time, elut_ends, raw_cpms, elut_cpms): """Constructor of Run objects @type self: Run @type name: str Name of run, used for identification purposes @type SA: float The specific activity of the loading solution used for the CATE run/replicate; radioactivity(counts per min)/volume (mL). @type rt_cnts: float Radioactivity of the roots of the plant used (cpm). @type sht_cnts: float Radioactivity of the shoots of the plant used (cpm). @type rt_wght: float Weight of the roots of the plant used (grams). @type gfact: float Instrument-specific correction factor. Used to account of idiosyncrasies of the detecting equipment. @type load_time: float Amount of time plant used was placed in loading solution for (minutes). @type elut_ends: list[float] Time points that eluates were removed from plants (vs added to plants) @type raw_cpms: list[float] Eluate radioactivities as measured by detecting equipment. @type elut_cpms: list[float] raw_cpms with blank values ('') replaced with 0s @rtype: None """ self.name = name # Text identifier extracted from col header in excel self.SA = SA self.rt_cnts = rt_cnts self.sht_cnts = sht_cnts self.rt_wght = rt_wght self.gfact = gfact self.load_time = load_time self.elut_ends = elut_ends self.raw_cpms = raw_cpms self.elut_cpms = elut_cpms # = raw_cpms with blanks('') replaced w/0 self.elut_starts = [0.0] + elut_ends[:-1] self.elut_cpms_gfact, self.elut_cpms_gRFW, \ self.elut_cpms_log, self.elut_ends_parsed = \ Operations.basic_run_calcs( rt_wght, gfact, self.elut_starts, elut_ends, elut_cpms) # x and y data for graphing ('numpy-fied') self.x = numpy.array(self.elut_ends_parsed) self.y = numpy.array(self.elut_cpms_log)
def findKeySize(hexStr): dec = int(hexStr,16) binaryStr = bin(dec) Distances = [] for keySize in range(2,40): firstPart = binaryStr[0:keySize * 8] secondPart = binaryStr[keySize * 8: keySize * 8 * 2] Distances.append(((op.binhamdist(firstPart, secondPart) / 1.0 / keySize),keySize)) min = 2 val = Distances[0][0] for num, key in Distances: if num < val: val = num min = key # print numpy.array(Distances) # exit() return min
def findKeySize(self, workingData=None, keymin=2, keymax=40): if workingData is None: workingData = self.data minHamming = 99999 bestKey = 0 for key in range(keymin, keymax): hammingSum = float(0) compares = 0 for endblock in range(1, 4): for startBlock in range(0, endblock - 1): hammingSum += Operations.binaryHamming(workingData[startBlock * key:(startBlock + 1) * key], workingData[endblock * key:(endblock + 1) * key]) compares += 1 hammingSum = hammingSum / key / compares if hammingSum < minHamming: minHamming = hammingSum bestKey = key return bestKey
def __init__(self, s, dur=0.5): self.chars = [] self.data = [] if type(s) is str: s = P().fromString(s) dur = s.dur(dur) self.data = [] for i, char in s.items(): # Recursively get rhythms val = op.modi(dur,i) if isinstance(char, Base.PGroup): dur_group = self.__class__(char, val) self.chars += list(dur_group.chars) self.data += list(dur_group.data) else: self.chars.append(char) self.data.append(val)
def harvest(year, game_num): """ Extract roster information from a html file on the local machine and create database entries """ game_info = GameHeader.harvest(year, game_num, "RO", "02") tree = Operations.germinate_report_seed(year, game_num, "RO", "02") tables = tree.xpath("//table//table//table//table") away_roster = chop_ind_roster_branch(tables, "away", game_info, year) home_roster = chop_ind_roster_branch(tables, "home", game_info, year) away_coach, home_coach = chop_coach_branch(tables) away_coach.team = game_info.away_team home_coach.team = game_info.home_team referees, linesmen = chop_officials_branch(tables) return GamePersonnel(away_roster, home_roster, away_coach, home_coach, referees, linesmen)
def prune_roster_parts(tree, scratch, team, years, roster_objects): """ Given xml tree of a part of a roster (either scratched or nonscratched list as tree), construct and add R_Player objects to roster_objects list """ iter_roster = iter(tree) next(iter_roster) for item in iter_roster: captaincy = None num = item.xpath("./td/text()")[0] position = item.xpath("./td/text()")[1] temp_starting = item.xpath("./td/@class")[0] starting = 0 if "bold" in temp_starting: starting = 1 temp_name_raw = item.xpath("./td/text()")[2] temp_name_raw_split = temp_name_raw.split() first_name = temp_name_raw_split[0] if "(A)" in temp_name_raw_split: captaincy = "A" temp_name_raw_split.pop(-1) elif "(C)" in temp_name_raw_split: captaincy = "C" temp_name_raw_split.pop(-1) last_name = " ".join(temp_name_raw_split[1:]) playerid = Operations.get_playerid(first_name, last_name, team, years, position) roster_objects.append( R_Player(team, num, position, first_name, last_name, captaincy, starting, scratch, playerid) )
def prune_shot(event, description_raw, game_personnel): distance = description_raw[-2] shot_type = description_raw[-5].strip(',') shooting_team = description_raw[0] shooting_num = description_raw[3].strip('#') delim_anchor = Operations.substring_index(description_raw, ',')[0] + 1 assert delim_anchor != 0, "ERROR - Anchor not found" shooting_name = (" ".join(description_raw[4:delim_anchor])).strip(',') if shooting_team == event.away_acronym: shooting_on_ice = event.away_on_ice shooting_roster = game_personnel.away_roster blocking_on_ice = event.home_on_ice blocking_team = event.home_acronym elif shooting_team == event.home_acronym: shooting_on_ice = event.home_on_ice shooting_roster = game_personnel.home_roster blocking_on_ice = event.away_on_ice blocking_team = event.away_acronym for player in blocking_on_ice: if player.pos == 'G': blocking_player = player shooting_player = clone_rosterplayer( shooting_num, shooting_name, shooting_roster) return Shot( event.num, event.period_num, event.strength, event.time, event.event_type, event.zone, event.description, event.away_acronym, event.home_acronym, event.away_on_ice, event.home_on_ice, shot_type, distance, shooting_player, blocking_player, shooting_team, blocking_team)
def harvest(year, game_num): game_info = GameHeader.harvest (year, game_num, 'RO', '02') away_full_name = Operations.team_acronym_to_uppercase( game_info.away_team) home_full_name = Operations.team_acronym_to_uppercase( game_info.home_team) tree = Operations.germinate_report_seed (year, game_num, "ES", '02') tables = tree.xpath('//table[@class="tablewidth" and @align="center"]/tr/td/table[@width="100%"]') rows = tables[3].xpath('./tr') roster = [] team_acronym = game_info.away_team for item in rows: if item.xpath('./td/text()')[0] == home_full_name: away_roster = roster roster = [] team_acronym = game_info.home_team elif item.get('class') == 'evenColor' or\ item.get('class') == 'oddColor': fields = item.xpath('./td/text()') for index, field in enumerate(fields): if field == u'\xa0': field = '0' if index == 0: number = field elif index == 1: position = field elif index == 2: name_raw = field.split(', ') first_name = name_raw[1] last_name = name_raw[0] elif index == 3: goals = field elif index == 4: assists = field elif index == 5: points = field elif index == 6: plus_minus = field elif index == 7: num_penalties = field elif index == 8: pim = field elif index == 9: total_minutes = field elif index == 10: num_shifts = field elif index == 11: avg_shift_length = field elif index == 12: powerplay_minutes = field elif index == 13: shorthanded_minutes = field elif index == 14: evenstrength_minutes = field elif index == 15: shots = field elif index == 16: attempts_blocked = field elif index == 17: missed_shots = field elif index == 18: hits = field elif index == 19: give_aways = field elif index == 20: take_aways = field elif index == 21: blocked_shots = field elif index == 22: faceoff_wins = field elif index == 23: faceoff_losses = field elif index == 24: faceoff_percentage = field playerid = Operations.get_playerid(first_name, last_name, team_acronym, year, position) roster.append (ES_Player(team_acronym, number, position, first_name, last_name, goals, assists, points, plus_minus, num_penalties, pim, total_minutes, num_shifts, avg_shift_length, powerplay_minutes, shorthanded_minutes, evenstrength_minutes, shots, attempts_blocked, missed_shots, hits, give_aways, take_aways, blocked_shots, faceoff_wins, faceoff_losses, faceoff_percentage, playerid)) home_roster = roster return away_roster, home_roster
def harvest(year, game_num): """ Extract roster information from a html file on the local machine and create database entries """ game_info = GameHeader.harvest(year, game_num, "RO", "02") tree = Operations.germinate_report_seed(year, game_num, "RO", "02") tables = tree.xpath("//table//table//table//table") away_roster = chop_ind_roster_branch(tables, "away", game_info, year) home_roster = chop_ind_roster_branch(tables, "home", game_info, year) away_coach, home_coach = chop_coach_branch(tables) away_coach.team = game_info.away_team home_coach.team = game_info.home_team referees, linesmen = chop_officials_branch(tables) return GamePersonnel(away_roster, home_roster, away_coach, home_coach, referees, linesmen) if __name__ == "__main__": for x in range(1, 100): game_num = Operations.pad_game_num(x) print harvest("20142015", game_num)
def run(): kOffset_a = 24 kOffset_b = 8 clk = 0 arr = [] isNextTrainA = True offset = kOffset_a for clk in range(0, 8192 * 4): if int(clk % (8192)) == 0: if isNextTrainA: offset = kOffset_a isNextTrainA = False else: offset = kOffset_b isNextTrainA = True # The Bluetooth clock is a 28-bit counter with a clock cycle of 312.5µs. # Bluetooth communication at the Baseband level is organised into time slots. # Each slot has a length of two clock cycles, i.e. 625µs. clk_bits = op.dec2bin(clk, 32) # change clock to 32 bits # --------------------------- # Find X # 0 index is right most one # 4-0 would actually mean -> indices 27, 28, 29 , 30, 31 # Similarly take clock's 16-12 # +1 because python does not include b if a:b clk_16_12 = op.bin2dec(clk_bits[31 - 16 : 31 - 12 + 1]) clk_4_2_0 = op.bin2dec(clk_bits[31 - 4 : 31 - 2 + 1] + clk_bits[31 - 0]) ################################################# sub_clk = 0 """if clk_16_12 > clk_4_2_0: sub_clk = clk_16_12 - clk_4_2_0 else: sub_clk = clk_4_2_0 - clk_16_12 """ # clk_4_2_0 is always a pattern like 0101 2323 ... 12131213, 14151415. (32 tics) # clk_16_12 is 0 for 4096 tics and 1 for next 4096 then 2 so on # subtraction doesn't make sense sub_clk = clk_4_2_0 - clk_16_12 temp_clk = sub_clk % 16 # in decimal Xi = op.dec2bin((clk_16_12 + offset + temp_clk) % 32, 32) X = Xi[31 - 4 : 31 - 0 + 1] # print(">>> " + X) # print("X: "+str(temp_clk)) # --------------------------- # 0000 1001 1110 1000 # address = [ 4-LSBs-of-DCI(0x00), GIAC LAP (0x9E8B33)] address = op.hex2bin("09E8B33") # this return 32 bits ########################### ## we can flip the address address = address[4:] # Get 28 bits # print("Address:" + address) A = address[27 - 27 : 27 - 23 + 1] B = address[27 - 22 : 27 - 19 + 1] C = "".join((address[27 - 8], address[27 - 6], address[27 - 4], address[27 - 2], address[27 - 0])) D = address[27 - 18 : 27 - 10 + 1] E = "".join( ( address[27 - 13], address[27 - 11], address[27 - 9], address[27 - 7], address[27 - 5], address[27 - 3], address[27 - 1], ) ) F = "0" # print('clock [1]: ' + clk_bits[31-1]) Y1 = clk_bits[31 - 1] * 5 # in binary # Y1 = clk_bits[31-2] if clk_bits[31 - 1] == "0": Y2 = "000000" else: Y2 = "100000" # Y2 will either be 100000 or 000000 # Y2 = op.dec2bin(32 * op.bin2dec(clk_bits[31-1]), 32) # in binary # Y1 = '0' Y2 = "0" add_1 = "{0:05b}".format((op.bin2dec(A) + op.bin2dec(X)) % 32) xor_1 = "{0:05b}".format(op.bin2dec(add_1) ^ op.bin2dec(B)) xor_2 = "{0:05b}".format(op.bin2dec(C) ^ op.bin2dec(Y1)) perm_1 = op.perm5(xor_1, xor_2, D) add_2 = op.bin_add(E, F, perm_1, Y2) freq = op.bin2dec(add_2) % 79 arr.append(freq) return arr
def singleByteXor(self, cipher, workingData=None): if workingData is None: workingData = self.data return Operations.xorAgainst(workingData, cipher)
def repeatingXORKeyKnown(self, key): decrypted = Operations.xor(self.data, key) return decrypted
def analyze(self): """Implement analysis based on settings from attributes. Parameters are defined based on the phase limits that have been provided The 'engine' of the analysis if you will. @type self: Analysis @rtype: None """ # Implement objective analysis. Note that objective analysis just uses a # set algorithm to set phase limits. After this if block the process # is the same of both objective and subjective analyses. A subjective # just allows the user to directly set the phase limits. if self.kind == 'obj': self.obj_x_start = self.run.x[-self.obj_num_pts:] self.obj_y_start = self.run.y[-self.obj_num_pts:] self.xs_p3, self.r2s, self.ms, self.bs = Operations.get_obj_phase3( obj_num_pts=self.obj_num_pts, elut_ends_parsed=self.run.elut_ends_parsed, elut_cpms_log=self.run.elut_cpms_log) self.xs_p2, self.xs_p1, self.p12_r2_max = Operations.get_obj_phase12( xs_p3=self.xs_p3, elut_ends_parsed=self.run.elut_ends_parsed, elut_cpms_log=self.run.elut_cpms_log, elut_ends=self.run.elut_ends) # From here analysis is same for both objective and subjective analyses if self.xs_p3 != ('', ''): self.phase3 = Operations.extract_phase( xs=self.xs_p3, x_series=self.run.elut_ends_parsed, y_series=self.run.elut_cpms_log, elut_ends=self.run.elut_ends, SA=self.run.SA, load_time=self.run.load_time) Operations.advanced_run_calcs(analysis=self) if self.xs_p2 != ('', '') and self.phase3.xs != ('', ''): # Set series' to be curve-stripped end_p12_index = Operations.x_to_index( x_value=self.xs_p2[1], boundary_type='end', x_series=self.run.elut_ends_parsed, larger_x=self.run.elut_ends) self.x_p12 = self.run.x[: end_p12_index+1] self.y_p12 = self.run.y[: end_p12_index+1] # Curve strip phase 1 + 2 data of phase 3 # From here on data series potentially have 'holes' from # omitting negative log operations during curvestripping self.x_p12_curvestrip_p3, self.y_p12_curvestrip_p3 = \ Operations.curvestrip( x_series=self.x_p12, y_series=self.y_p12, slope=self.phase3.slope, intercept=self.phase3.intercept) self.phase2 = Operations.extract_phase( xs=self.xs_p2, x_series=self.x_p12_curvestrip_p3, y_series=self.y_p12_curvestrip_p3, elut_ends=self.run.elut_ends, SA=self.run.SA, load_time=self.run.load_time) if self.xs_p1 != ('', '') and self.phase2.xs != ('', ''): start_p1_index = Operations.x_to_index( x_value=self.xs_p1[0], boundary_type='start', x_series=self.run.elut_ends_parsed, larger_x=self.run.elut_ends) end_p1_index = Operations.x_to_index( x_value=self.xs_p1[1], boundary_type='end', x_series=self.run.elut_ends, larger_x=self.run.elut_ends) self.x_p1 = self.run.x[start_p1_index : end_p1_index+1] self.y_p1 = self.run.y[start_p1_index : end_p1_index+1] # Getting phase 1 data that has been already stripped of # phase 3 data self.x_p1_curvestrip_p3 =\ self.x_p12_curvestrip_p3[start_p1_index: end_p1_index+1] self.y_p1_curvestrip_p3 =\ self.y_p12_curvestrip_p3[start_p1_index: end_p1_index+1] # Curve-strip phase 2 data from phase 1 self.x_p1_curvestrip_p23, self.y_p1_curvestrip_p23 = \ Operations.curvestrip( x_series=self.x_p1_curvestrip_p3, y_series=self.y_p1_curvestrip_p3, slope=self.phase2.slope, intercept=self.phase2.intercept) self.phase1 = Operations.extract_phase( xs=self.xs_p1, x_series=self.x_p1_curvestrip_p23, y_series=self.y_p1_curvestrip_p23, elut_ends=self.run.elut_ends, SA=self.run.SA, load_time=self.run.load_time)