def gauss_legendre(N, lo=0, up=1, composite=1): """ Generate the quadrature nodes and weights in Gauss-Legendre quadrature """ N,lo,up = [np.array(_).flatten() for _ in [N,lo,up]] dim = max(lo.size, up.size, N.size) N,lo,up = [np.ones(dim)*_ for _ in [N,lo,up]] N = np.array(N, dtype=int) if isinstance(composite, int): composite = [np.linspace(0,1,composite+1)]*dim else: composite = np.array(composite) if not composite.shape: composite = composite.flatten() if len(composite.shape)==1: composite = np.array([composite]).T composite = ((composite.T-lo)/(up-lo)).T q = [_gauss_legendre(N[i], composite[i]) for i in xrange(dim)] x = np.array([_[0] for _ in q]) w = np.array([_[1] for _ in q]) x = combine(x) w = combine(w) x = (up-lo)*x + lo w = np.prod(w*(up-lo), 1) return x.T, w
def leja(order, dist): """ After paper by Narayan and Jakeman """ if len(dist) > 1: if isinstance(order, int): xw = [leja(order, d) for d in dist] else: xw = [leja(order[i], dist[i]) for i in xrange(len(dist))] x = [_[0][0] for _ in xw] w = [_[1] for _ in xw] x = combine(x).T w = combine(w) w = np.prod(w, -1) return x, w lo, up = dist.range() X = [lo, dist.mom(1), up] for o in xrange(order): X_ = np.array(X[1:-1]) obj = lambda x:-np.sqrt(dist.pdf(x))*np.prod(np.abs(X_-x)) opts, vals = zip(*[fminbound(obj, X[i], X[i+1], full_output=1)[:2] for i in xrange(len(X)-1)]) index = np.argmin(vals) X.insert(index+1, opts[index]) X = np.asfarray(X).flatten()[1:-1] W = weightgen(X, dist) X = X.reshape(1, X.size) return np.array(X), np.array(W)
def gauss_legendre(N, lo=0, up=1, composite=1): """ Generate the quadrature nodes and weights in Gauss-Legendre quadrature """ N, lo, up = [np.array(_).flatten() for _ in [N, lo, up]] dim = max(lo.size, up.size, N.size) N, lo, up = [np.ones(dim) * _ for _ in [N, lo, up]] N = np.array(N, dtype=int) if isinstance(composite, int): composite = [np.linspace(0, 1, composite + 1)] * dim else: composite = np.array(composite) if not composite.shape: composite = composite.flatten() if len(composite.shape) == 1: composite = np.array([composite]).T composite = ((composite.T - lo) / (up - lo)).T q = [_gauss_legendre(N[i], composite[i]) for i in xrange(dim)] x = np.array([_[0] for _ in q]) w = np.array([_[1] for _ in q]) x = combine(x) w = combine(w) x = (up - lo) * x + lo w = np.prod(w * (up - lo), 1) return x.T, w
def tensprod_rule(N, part=None): N = N * np.ones(dim, int) q = [np.array(funcs[i](N[i])) \ for i in xrange(dim)] x = [_[0] for _ in q] x = combine(x, part=part).T w = [_[1] for _ in q] w = np.prod(combine(w, part=part), -1) return x, w
def tensprod_rule(N, part=None): N = N*np.ones(dim, int) q = [np.array(funcs[i](N[i])) \ for i in xrange(dim)] x = [_[0] for _ in q] x = combine(x, part=part).T w = [_[1] for _ in q] w = np.prod(combine(w, part=part), -1) return x, w
def getMenu(self) -> menu.Menu: return menu.Menu(utils.combine( { "Exit": lambda arg: self.__exit(arg), "Map": lambda arg: self.__map(arg) }, self.__options), title=self.__name, titleColor=self.__color, description=self.__description)
def clenshaw_curtis(N, lo=0, up=1, growth=False, composite=1, part=None): """ Generate the quadrature nodes and weights in Clenshaw-Curtis quadrature """ N, lo, up = [np.array(_).flatten() for _ in [N, lo, up]] dim = max(lo.size, up.size, N.size) N, lo, up = [np.ones(dim) * _ for _ in [N, lo, up]] N = np.array(N, dtype=int) if isinstance(composite, int): composite = [np.linspace(0, 1, composite + 1)] * dim else: composite = np.array(composite) if not composite.shape: composite = composite.flatten() if len(composite.shape) == 1: composite = np.array([composite]) composite = ((composite.T - lo) / (up - lo)).T if growth: q = [_clenshaw_curtis(2**N[i]-1*(N[i]==0), composite[i]) \ for i in xrange(dim)] else: q = [_clenshaw_curtis(N[i], composite[i]) for i in xrange(dim)] x = [_[0] for _ in q] w = [_[1] for _ in q] x = combine(x, part=part).T w = combine(w, part=part) x = ((up - lo) * x.T + lo).T w = np.prod(w * (up - lo), -1) assert len(x) == dim assert len(w) == len(x.T) return x, w
def clenshaw_curtis(N, lo=0, up=1, growth=False, composite=1, part=None): """ Generate the quadrature nodes and weights in Clenshaw-Curtis quadrature """ N,lo,up = [np.array(_).flatten() for _ in [N,lo,up]] dim = max(lo.size, up.size, N.size) N,lo,up = [np.ones(dim)*_ for _ in [N,lo,up]] N = np.array(N, dtype=int) if isinstance(composite, int): composite = [np.linspace(0,1,composite+1)]*dim else: composite = np.array(composite) if not composite.shape: composite = composite.flatten() if len(composite.shape)==1: composite = np.array([composite]) composite = ((composite.T-lo)/(up-lo)).T if growth: q = [_clenshaw_curtis(2**N[i]-1*(N[i]==0), composite[i]) \ for i in xrange(dim)] else: q = [_clenshaw_curtis(N[i], composite[i]) for i in xrange(dim)] x = [_[0] for _ in q] w = [_[1] for _ in q] x = combine(x, part=part).T w = combine(w, part=part) x = ((up-lo)*x.T + lo).T w = np.prod(w*(up-lo), -1) assert len(x)==dim assert len(w)==len(x.T) return x, w
def gk(order, dist, rule=24): assert isinstance(rule, int) if len(dist) > 1: if isinstance(order, int): xw = [gk(order, d, rule) for d in dist] else: xw = [gk(order[i], dist[i], rule) for i in xrange(len(dist))] x = [_[0][0] for _ in xw] x = combine(x).T w = [_[1] for _ in xw] w = np.prod(combine(w), -1) return x, w foo = eval("gk" + str(rule)) x, w = foo(order) x = dist.inv(ndtr(x)) x = x.reshape(1, x.size) return x, w
def do_TJ(self, seq): if self.textstate.font is None: if STRICT: raise PDFInterpreterError('No font specified!') return #print "[-" + str(seq) + "-]" self.device.resetCharbboxes() self.device.render_string(self.textstate, seq) # ta metoda obliczy nam bounding boxy znakow i calego tekstu seq #fontik = self.textstate.font #print type(fontik) #exit() #textik = TagInterpreter.toUni(self.textstate.font, seq) self.__bbox = combine(self.__bbox, self.__bboxof(self.device)) # pobieramy bounding box calego tekstu self.__resetbbox(self.device) #print "TJ", self.bbox #print "[" + str(seq) + "]" if self.__mc: #lena = 0 #lenb = 0 for el in seq: assert(not isinstance(el, unicode)) # dodajemy tekst do aktualnie przetwarzanej zawartosci oznaczonej z MCIDem if isinstance(el, str): #print "[" + el + "]" for bdc in self.__bdcs: bdc.els.append(el) #lena += len(el) for bdc in self.__bdcs: # pobieramy bouding boxy znakow for c in self.device.getCharbboxes(): bdc.charbboxes.append(c) #lenb += 1 #bdc.control.append(fontik) #bdc.control.append(seq) #for c in textik: # #bdc.charbboxes.append(c) # bdc.control.append(c) # #lenb += 1 #lena = len(textik) #if lena > 1000: # print lena, lenb, len(seq), seq, self.device.getCharbboxes() #assert(lena == lenb) return
def calculate_distance_mode(pairs, df, ref, mode, measure, ref2=[]): """ From a set of pairs, calculate the distance of the offset of the pair in relation to the global offset. Parameters: ----------- pairs: list list containing tuples of IDs of norms [(id1,id2),(id3,id4)...] df: pandas.dataframe dataframe containing ids and embeddings of sentences ref: np.array vector containing the reference to measure the distance mode: string how vectors are combined (offset, concat or mean) measure: string measure to calculate the distance (euc or cos) ref2: np.array calculate the distance to a second reference Return: ------- list containing the distance and ids in the form [(dist, id1, id2), (dist, id2, id3),...] """ vdist = [] pb = progressbar.ProgressBar(len(pairs)) for i, pair in enumerate(pairs): id1, id2 = pair combined = utils.combine(pair, df, mode=mode) dist = utils.calculate_distance(combined, ref, measure=measure) if len(ref2) > 0: dist2 = utils.calculate_distance(combined, ref2, measure=measure) vdist.append((dist, dist2, id1, id2)) else: vdist.append((dist, id1, id2)) pb.update() #if i == 1000: break return vdist
def merge_strings_handler(line): lexer = VBLexer() tokens = lexer.tokenize(line) expr = exprFactory.get('string.concatenate') m = expr.search(tokens) # Sanity check (should be checked in the merge_strings_matcher) if m is not None: start,end = m.span s1 = tokens[start] # This is the 1st string s2 = tokens[end - 1] # This is the 2nd string return combine(' ', *[ lexer.untokenize(tokens[:start]), '"{0}{1}"'.format(s1.data, s2.data), lexer.untokenize(tokens[end:]) ]) # Something went wrong.. just return the line return line
mismatch_cost = DEFAULT_MISMATCH_COST else: print("* Defining own costs *") ins_cost = get_input_float('Please type the insertion penalty/cost') del_cost = get_input_float('Please type the deletion penalty/cost') match_cost = get_input_float('Please type the matching penalty/cost') mismatch_cost = get_input_float( 'Please type the mismatching penalty/cost') #%% Algorithm Timing start_time = timer() V, paths = needleman_wunsch(S1, S2, ins_cost, del_cost, match_cost, mismatch_cost) st1, st2, score = reconstruct(S1, S2, V, paths) combined = combine(V, paths, PATH_CHARACTERS) end_time = timer() duration_sec = end_time - start_time #%% Results print("** Results **") print( f"\tFor: Insertion Cost={ins_cost}, Deletion Cost={del_cost}, Match Cost={match_cost}, Mismatch Cost={mismatch_cost}" ) print(f"Calculation took {duration_sec:.4f} seconds") print(f"V=\n{V}") print(f"Paths=\n{paths}") print(f"Combined=\n{combined}")
# Delta labels dAll = [ "dCurrentFood", "dFoodUsed", "dFoodSold", "dFoodBought", "dFoodGathered", "dCurrentWood", "dWoodUsed", "dWoodSold", "dWoodBought", "dWoodGathered", "dCurrentMetal", "dMetalUsed", "dMetalSold", "dMetalBought", "dMetalGathered", "dCurrentStone", "dStoneUsed", "dStoneSold", "dStoneBought", "dStoneGathered", "dInfantryGained", "dInfantryLost", "dInfantryKilled", "dCavalryGained", "dCavalryLost", "dCavalryKilled", "dSupportGained", "dSupportLost", "dSupportKilled", "dSiegeGained", "dSiegeLost", "dSiegeKilled", "dStructuresGained", "dStructuresLost", "dStructuresDestroyed", "MilitaryMovementsOccurred", "SupportMovementsOccurred", "dDistanceEnemyBase" ] print "Gathering and initializing data..." utils.combine() X = utils.getData() X[All] = machine_learning.norm(X[All]) print "Done." print "Hierarchial clustering..." hierarchy = machine_learning.recursiveCluster(X[dAll], size=500) Y = machine_learning.flatten(hierarchy, min=40) X = X[Y >= 0] # Eliminating outliers Y = Y[Y >= 0] y_values = np.unique(Y) for i in range(0, len(y_values)): Y[Y == y_values[i]] = i print "Done." print "Visualizing..."
class DummyConverter(PDFLayoutAnalyzer): def __init__(self, rsrcmgr, pageno=1, laparams=None): PDFLayoutAnalyzer.__init__(self, rsrcmgr, pageno=pageno, laparams=laparams) self.__bbox = None # bounding box przetwarzanego napisu self.__itembbox = None # bounding box aktualnie przetwarzanego znaku self.__charbboxes = [] # bounding boxy znakow przetwarzanego napisu return def getBbox(self): return self.__bbox def getCharbboxes(self): return self.__charbboxes # resetuje bounding boxy znakow przed przetworzeniem nastepnego napisu def resetCharbboxes(self): self.__charbboxes = [] def setBbox(self, bbox): self.__bbox = bbox # zaslepka def write(self, text): return # zaslepka def receive_layout(self, ltpage): return # metoda ktora w pdfminerze zajmuje sie czym innym, ale my wykorzystujemy # ja do obliczania bounding boxow napisu seq i jego znakow def render_string(self, textstate, seq): matrix = mult_matrix(textstate.matrix, self.ctm) font = textstate.font fontsize = textstate.fontsize scaling = textstate.scaling * .01 charspace = textstate.charspace * scaling wordspace = textstate.wordspace * scaling rise = textstate.rise if font.is_multibyte(): wordspace = 0 dxscale = .001 * fontsize * scaling if font.is_vertical(): textstate.linematrix = self.render_string_vertical( seq, matrix, textstate.linematrix, font, fontsize, scaling, charspace, wordspace, rise, dxscale) else: textstate.linematrix = self.render_string_horizontal( seq, matrix, textstate.linematrix, font, fontsize, scaling, charspace, wordspace, rise, dxscale) return # metoda ktora w pdfminerze zajmuje sie czym innym, ale my wykorzystujemy # ja do obliczania bounding boxow napisu seq i jego znakow def render_string_horizontal(self, seq, matrix, (x,y), font, fontsize, scaling, charspace, wordspace, rise, dxscale): needcharspace = False #print len(self.__charbboxes) #print "render: " + str(seq) for obj in seq: #print "<" + obj + ">" if isinstance(obj, int) or isinstance(obj, float): x -= obj*dxscale needcharspace = True else: for cid in font.decode(obj): if needcharspace: x += charspace x += self.render_char(translate_matrix(matrix, (x,y)), font, fontsize, scaling, rise, cid) self.__bbox = combine(self.__bbox, self.__itembbox) # dodajemy bounding box # przetworzonego znaku do sumy bounding boxow juz przetworzonych znakow if cid == 32 and wordspace: x += wordspace needcharspace = True #print len(self.__charbboxes) return (x, y)
def golub_welsch(order, dist, acc=100, **kws): """ Golub-Welsch algorithm for creating quadrature nodes and weights Parameters ---------- order : int Quadrature order dist : Dist Distribution nodes and weights are found for with `dim=len(dist)` acc : int Accuracy used in discretized Stieltjes procedure. Will be increased by one for each itteration. Returns ------- x : numpy.array Optimal collocation nodes with `x.shape=(dim, order+1)` w : numpy.array Optimal collocation weights with `w.shape=(order+1,)` Examples -------- >>> Z = cp.Normal() >>> x, w = cp.golub_welsch(3, Z) >>> print x [[-2.33441422 -0.74196378 0.74196378 2.33441422]] >>> print w [ 0.04587585 0.45412415 0.45412415 0.04587585] Multivariate >>> Z = cp.J(cp.Uniform(), cp.Uniform()) >>> x, w = cp. golub_welsch(1, Z) >>> print x [[ 0.21132487 0.21132487 0.78867513 0.78867513] [ 0.21132487 0.78867513 0.21132487 0.78867513]] >>> print w [ 0.25 0.25 0.25 0.25] """ o = np.array(order)*np.ones(len(dist), dtype=int)+1 P, g, a, b = stieltjes(dist, np.max(o), acc=acc, retall=True, **kws) X, W = [], [] dim = len(dist) for d in xrange(dim): if o[d]: A = np.empty((2, o[d])) A[0] = a[d, :o[d]] A[1, :-1] = np.sqrt(b[d, 1:o[d]]) vals, vecs = eig_banded(A, lower=True) x, w = vals.real, vecs[0, :]**2 indices = np.argsort(x) x, w = x[indices], w[indices] else: x, w = np.array([a[d, 0]]), np.array([1.]) X.append(x) W.append(w) if dim==1: x = np.array(X).reshape(1,o[0]) w = np.array(W).reshape(o[0]) else: x = combine(X).T w = np.prod(combine(W), -1) assert len(x)==dim assert len(w)==len(x.T) return x, w
import cr, utils from urlparse import urlparse url = 'http://www.beeradvocate.com' base_urls = [urlparse(url).netloc] spider = cr.Spider(url, base_urls, 'beer.db', 0.1, '/beer') spider.nstep(100000) utils.combine('beer.db')
def util_msg_handler(agent): """ The util_msg_handler routine in the util_msg_propogation part; this method is run for non-leaf nodes; it waits till all the children of this agent have sent their util_msg, combines them, and then calculates and sends the util_msg to its parent; if this node is the root node, it waits till all the children have sent their util_msg, combines these messages, chooses the assignment for itself with the optimal utility, and then sends this assignment and optimal utility value to all its children and pseudo- children; assumes that the listening thread is active; given the 'agent' which runs this function. """ # Wait till util_msg from all the children have arrived while True: all_children_msgs_arrived = True for child in agent.c: if ('util_msg_'+str(child)) not in agent.msgs: all_children_msgs_arrived = False break if all_children_msgs_arrived == True: break util_msgs = [] for child in sorted(agent.c): util_msgs.append(agent.msgs['util_msg_'+str(child)]) for child in sorted(agent.c): util_msgs.append(agent.msgs['pre_util_msg_'+str(child)]) # Combine the util_msgs received from all children combined_msg, combined_ant = utils.combine(*util_msgs) info = agent.agents_info if agent.is_root: assert combined_ant == (agent.id, ) # Choose the optimal utility utilities = list(combined_msg) max_util = max(utilities) xi_star = agent.domain[utilities.index(max_util)] agent.value = xi_star agent.max_util = max_util # Send the index of assigned value D = {} ind = agent.domain.index(xi_star) D[agent.id] = ind for node in agent.c: agent.udp_send('value_msg_'+str(agent.id), D, node) else: util_cube, _ = get_util_cube(agent) # Combine the 2 cubes combined_cube, cube_ant = utils.combine( util_cube, combined_msg, tuple([agent.id] + [agent.p] + agent.pp), combined_ant ) # Removing own dimension by taking maximum L_ant = list(cube_ant) ownid_index = L_ant.index(agent.id) msg_to_send = np.maximum.reduce(combined_cube, axis=ownid_index) # Ant to send in pre_util_msg ant_to_send = cube_ant[:ownid_index] + cube_ant[ownid_index+1:] # Creating the table to store cc = combined_cube table_shape = list(cc.shape[:]) del table_shape[ownid_index] table_shape = tuple(table_shape) table = np.zeros(table_shape, dtype=object) cc_rolled = np.rollaxis(cc, ownid_index) for i, abc in enumerate(cc_rolled): for index, _ in np.ndenumerate(abc): if abc[index] == msg_to_send[index]: table[index] = agent.domain[i] agent.table = table agent.table_ant = ant_to_send # Send the assignment-nodeid-tuple agent.udp_send('pre_util_msg_'+str(agent.id), ant_to_send, agent.p) agent.udp_send('util_msg_'+str(agent.id), msg_to_send, agent.p)
def golub_welsch(order, dist, acc=100, **kws): """ Golub-Welsch algorithm for creating quadrature nodes and weights Parameters ---------- order : int Quadrature order dist : Dist Distribution nodes and weights are found for with `dim=len(dist)` acc : int Accuracy used in discretized Stieltjes procedure. Will be increased by one for each itteration. Returns ------- x : numpy.array Optimal collocation nodes with `x.shape=(dim, order+1)` w : numpy.array Optimal collocation weights with `w.shape=(order+1,)` Examples -------- >>> Z = cp.Normal() >>> x, w = cp.golub_welsch(3, Z) >>> print x [[-2.33441422 -0.74196378 0.74196378 2.33441422]] >>> print w [ 0.04587585 0.45412415 0.45412415 0.04587585] Multivariate >>> Z = cp.J(cp.Uniform(), cp.Uniform()) >>> x, w = cp. golub_welsch(1, Z) >>> print x [[ 0.21132487 0.21132487 0.78867513 0.78867513] [ 0.21132487 0.78867513 0.21132487 0.78867513]] >>> print w [ 0.25 0.25 0.25 0.25] """ o = np.array(order) * np.ones(len(dist), dtype=int) + 1 P, g, a, b = stieltjes(dist, np.max(o), acc=acc, retall=True, **kws) X, W = [], [] dim = len(dist) for d in xrange(dim): if o[d]: A = np.empty((2, o[d])) A[0] = a[d, :o[d]] A[1, :-1] = np.sqrt(b[d, 1:o[d]]) vals, vecs = eig_banded(A, lower=True) x, w = vals.real, vecs[0, :]**2 indices = np.argsort(x) x, w = x[indices], w[indices] # p = P[-1][d] # dp = po.differential(p, po.basis(1,1,dim)[d]) # # x = x - p(x)/dp(x) # x = x - p(x)/dp(x) # x = x - p(x)/dp(x) # # z = np.arange(dim) # arg = np.array([k*(z == d) for k in range(2*o[d]-3)]) # b_ = dist.mom(arg.T) # # X_, r = np.meshgrid(x, np.arange(2*o[d]-3)) # X_ = X_**r # w = np.linalg.lstsq(X_, b_)[0].flatten() # print "w", w.shape # print np.linalg.lstsq(X_, b_)[0] else: x, w = np.array([a[d, 0]]), np.array([1.]) X.append(x) W.append(w) if dim == 1: x = np.array(X).reshape(1, o[0]) w = np.array(W).reshape(o[0]) else: x = combine(X).T w = np.prod(combine(W), -1) assert len(x) == dim assert len(w) == len(x.T) return x, w
from utils import combine import sys import os.path from utils import read_solution_line from shutil import copyfile if len(sys.argv) != 2: print("Usage: combine_solutions.py [file1]") else: file = sys.argv[1] combine("COMBINED SOLUTIONS", file) copyfile("COMBINED SOLUTIONS", "CURRENT BEST SOLUTIONS") print("Copied new solutions to CURRENT BEST SOLUTIONS.") print("Done.") # Writing to solutions.out print("Writing to solutions.out") write_file = open("solutions.out", "w") read_file = open("COMBINED SOLUTIONS", "r") data = read_file.readlines() for line in data: info = read_solution_line(line) solution = info[3] if solution.isspace(): write_file.write("None\n") else: solution = solution[1:] write_file.write(solution + "\n") print("Done.")
found = i # linia po i-1 odstepie, ktory jest ostatnim (i-ta kolumna) break if before == None: # (**) nie jestesmy w stanie ustalic, czy linia jest # przed czy po odstepie i musimy dzielic miedzy kolumny # poszczegolne znaki break if before: # linia przed i-tym odstepem (i-ta kolumna) found = i break if found != None: # ok, znalezlismy kolumne do ktorej nalezy linia, # dodajemy ja do kolumny assert (l.getPageId() != None) textgroups[i].add(l) #print "TUTAJ:", l.getBbox(), textgroups[i].getBbox() textgroups[i].setBbox( combine(textgroups[i].getBbox(), l.getBbox())) continue # jezeli jestesmy tutaj to wystapila sytuacja (**) powyzej for _ in range(self.__divNum + 1): line = PDFMinerNode( "textline") # tworzymy linie dla kazdej kolumny, # bedziemy do nich przydzielac znaki line.setPageId(pageid) newLines.append(line) for text in l.getChildren(): # dla kazdego znaku: if text.getBbox() == None: #[0.0, 0.0, 0.0, 0.0]: continue i = 0 # indeks kolumny for div in columnDivs: if self.__before(text, div, l, prev, next): # jezeli znak jest
b = DEFAULT_B match_cost = DEFAULT_MATCH_COST mismatch_cost = DEFAULT_MISMATCH_COST else: print("* Defining own costs *") a = get_input_float('Please type the value for a in f(k) = a + (b * k)') b = get_input_float('Please type the value for b in f(k) = a + (b * k)') match_cost = get_input_float('Please type the matching penalty/cost') mismatch_cost = get_input_float('Please type the mismatching penalty/cost') #%% Algorithm Timing start_time = timer() F, E, G, F_paths, E_paths, G_paths = gotoh(S1, S2, match_cost, mismatch_cost, a, b) st1, st2, score = reconstruct(S1, S2, F, E, G, F_paths, E_paths, G_paths) combined_F = combine(F, F_paths, PATH_F_CHARACTERS) combined_G = combine(G, G_paths, PATH_G_CHARACTERS) combined_E = combine(E, E_paths, PATH_E_CHARACTERS) end_time = timer() duration_sec = end_time - start_time #%% Results print("** Results **") print(f"Calculation took {duration_sec:.4f} seconds") print(f"Combined_F=\n{combined_F}") print(f"Combined_G=\n{combined_G}") print(f"Combined_E=\n{combined_E}") print(f"Original Inputs:")