def polyroots(q, p, pol): """ Finds all of the roots of polynomial @pol, with the constant of highest degree @q and the constant of x**0 @p. Returns a set of all the roots. >>> polyroots(1, 2, 'x**3 - 2*x**2 - x + 2') set([1, 2, -1]) TODO: Add ability to find @q and @p from @pol AUTHORS: v0.5.1+ --> pydsigner v1.1.0+ --> pydsigner """ # First a set of fractions is generated from the factors of @q and @p; # These fractions are every possible (x/y equaling -x/-y and # -x/y equaling x/-y) combination of these factors (the factors of @p being # in the denominator) that makes the polynomial equal 0 S = set(x for x in set( flatten((frac(pv, qv), frac(-pv, qv)) for qv in factors(abs(q)) for pv in factors(abs(p)))) if eval(pol.replace('x', 'frac("%s")' % x)) == 0) # Make new set where whole numbers are changed to int()s and any lossless # conversions to float()s are made nset = set() for n in S: if n.denominator == 1: nset.add(n.numerator) elif frac(float(n)) == n: nset.add(float(n)) else: nset.add(n) return nset
def solve_test_case(): line = sys.stdin.readline().rstrip().split(' ') n_points = int(line[0]) dice_sets = [DiceSet(*d_str.split('d')) for d_str in line[1].split('+')] dices = [ds.n_sides for ds in dice_sets for _ in range(ds.n_dices)] dices = sorted(dices) probs = None for idx, n_sides in enumerate(dices): # If first dice if idx == 0: # Probability of obtaining i points is 1 / n_sides probs = {p: frac(1, n_sides) for p in range(1, n_sides + 1)} continue # Remaining dices new_probs = defaultdict(lambda: frac(0, 1)) for points in range(1, n_sides + 1): for old_points, old_prob in probs.items(): new_probs[old_points + points] += old_prob * frac(1, n_sides) probs = new_probs # Calculate probability of getting more than n points goal_prob = frac(0, 1) for points, prob in probs.items(): if points >= n_points: goal_prob += prob return \ '0/1' if goal_prob.numerator == 0 else \ '1/1' if goal_prob.denominator == 1 else \ str(goal_prob)
def standardForm(matrix): i = 0 terminatingRows, nonTerminatingRows = [], [] for idx, row in enumerate(matrix): if all([val == 0 for val in row]): terminatingRows.append(idx) else: nonTerminatingRows.append(idx) standardRows = terminatingRows + nonTerminatingRows standardMatrix = [[0 for _ in range(len(matrix[0]))] for _ in range(len(matrix))] for i in range(len(terminatingRows)): standardMatrix[i][i] = 1 for i in range(len(terminatingRows), len(standardMatrix)): for j in range(len(matrix[0])): standardMatrix[i][j] = matrix[standardRows[i]][standardRows[j]] R, Q = [], [] for i in range(len(terminatingRows), len(standardMatrix)): deno = sum(standardMatrix[i]) rRow, qRow = [], [] for j in range(len(standardMatrix[0])): if j < len(terminatingRows): rRow.append(frac(standardMatrix[i][j], deno)) else: qRow.append(frac(standardMatrix[i][j], deno)) R.append(rRow) Q.append(qRow) return R, Q
def visit_node(node): assert self._repetition_vector[node] is not None # look at all edges for channel in graph.sdf.channel: if channel.srcActor == node: # outgoing connections production_rate = rates[channel.srcActor][channel.srcPort] consumption_rate = rates[channel.dstActor][channel.dstPort] factor = frac(production_rate, consumption_rate) src_rate = self._repetition_vector[channel.srcActor] dst_rate = src_rate * factor if self._repetition_vector[channel.dstActor] is None: self._repetition_vector[channel.dstActor] = dst_rate # recursive traversal visit_node(channel.dstActor) elif self._repetition_vector[channel.dstActor] != dst_rate: raise RuntimeError("SDF graph is not consistent!") elif channel.dstActor == node: # incoming connections production_rate = rates[channel.srcActor][channel.srcPort] consumption_rate = rates[channel.dstActor][channel.dstPort] factor = frac(production_rate, consumption_rate) dst_rate = self._repetition_vector[channel.dstActor] src_rate = dst_rate / factor if self._repetition_vector[channel.srcActor] is None: self._repetition_vector[channel.srcActor] = src_rate # recursive traversal visit_node(channel.srcActor) elif self._repetition_vector[channel.srcActor] != src_rate: raise RuntimeError("SDF graph is not consistent!")
def PerChordSymbolAndPosition(PCTX, SIGTRE): Y = [] for ChordsInEveryPart in ChordListGetter(PartsContainsChord(PCTX)): X = [] for DictItemWhichKeyIsPartName in ChordsInEveryPart: ListOfChordWithEveryPartContent = [] for i in ChordsInEveryPart[DictItemWhichKeyIsPartName]: ListOfChordWithEveryPartContent.append( (i[0], 1 / int(i[1].rstrip('*>').lstrip('<')), i[2])) SpaceBeforeChord = 0 WholePartLength = 0 for i in range(len(ListOfChordWithEveryPartContent)): WholePartLength += ListOfChordWithEveryPartContent[i][1] * \ ListOfChordWithEveryPartContent[i][2] * \ frac(str(SIGTRE[1]) + '/' + str(SIGTRE[0])) if i == 0: X.append((0.0, [ m.groupdict() for m in re.finditer( PerChordPattern, ListOfChordWithEveryPartContent[i] [0]) ][0])) else: SpaceBeforeChord += frac(ListOfChordWithEveryPartContent[i - 1][1]) * \ frac(ListOfChordWithEveryPartContent[i - 1][2]) * \ frac(str(SIGTRE[1]) + '/' + str(SIGTRE[0])) X.append((SpaceBeforeChord, [ m.groupdict() for m in re.finditer( PerChordPattern, ListOfChordWithEveryPartContent[i] [0]) ][0])) Y.append(({DictItemWhichKeyIsPartName: X}, WholePartLength)) return Y
def niceprint(matrix, ij=[None, None]): sp = ' ' * 50 print(f'{bcolors.X}{sp}{bcolors.ENDC}\n') ki = 0 for irow, row in enumerate(matrix): pp = [] for icol, rr in enumerate(row): if abs(rr) > 1.e-8: r = frac(rr) if r.numerator > 1.e3 or r.denominator > 1.e3: r = f'{rr:7.3f}' else: r = str(frac(rr)) if (ij[0] == irow) and (ij[1] == icol): r = f'{bcolors.OKGREEN}{r}{bcolors.ENDC}' else: r = '0' pp.append(r) p = pp[:-1] p.append(f'{bcolors.WARNING}:{bcolors.ENDC}') p.append(f'{bcolors.TST}{pp[-1]}{bcolors.ENDC}') msg = "\t".join(p) print(msg) print("\u001b[0m") # reset return 0
def test_points_on_different_curves(self): C1 = EllipticCurve(3,4) C2 = EllipticCurve(5,4) self.assertFalse(C1 == C2) P1 = Point(C1,frac(0), frac(2)) P2 = Point(C2,frac(0), frac(2)) with self.assertRaises(Exception): #I don't think it makes sense to compare points on different curves #but correct me if I'm wrong. P1 == P2 with self.assertRaises(Exception): P1 < P2 with self.assertRaises(Exception): P1 > P2 with self.assertRaises(Exception): P1 <= P2 with self.assertRaises(Exception): P1 >= P2 with self.assertRaises(Exception): P1 + P2 with self.assertRaises(Exception): P1 - P2
def fractran(n, prog, giveup=100): states = [] states.append(n) count = 0 while True: count+=1 if count>giveup: return(states) if prog == []: return(states) i = 0 while True: try: dif = abs(n*(frac(prog[i][0],prog[i][1])) - int(n*(frac(prog[i][0],prog[i][1])))) if (dif<=0.000001) |(round(dif,4)==1): states.append(int(n*(frac(prog[i][0],prog[i][1])))) n = int(n*(frac(prog[i][0],prog[i][1]))) break n = int(n) else: n = int(n) i+=1 if i>len(prog): return(states) except: return(states) return(states)
def csanky(input_matrix): A = input_matrix n,m = A.shape if n!=m: raise ValueError(n,'by',m,'matrix input. Input must be square.') # get traces M = Id(n) trace = dict() i = 1 while i <= n: M = M*A trace[i] = tr(M) i += 1 # and the core of the algorithm... b = matrix([[frac((-1)**(i+1)*trace[i],i) for i in range(1,n+1)]],dtype=object).transpose() T = matrix([[0 for i in range(n)] for j in range(n)],dtype=object) i = 0 while i<n: j = 0 while j<i: c = (-1)**(i-j+1) T[i,j] = frac(c*frac(1,i+1)*trace[i-j]) j += 1 i += 1 T = Id(n)-T T = rec_lt_block_invert(T) return T*b # note: returns s1 through sn; s0 is 1 and is not in the result
def rec_lt_block_invert(input_matrix): # recursive inverse for lower triangular M = input_matrix # also assumes that there are no 0s on diagonal, which n,m = M.shape # works in this context (diagonal will be 1's) # make sure it's square... if n!=m: raise ValueError('Inverse of non-square matrix.') # base case... if n==1: return matrix([[frac(1,frac(M[0,0]))]]) # make sure it's lower triangular... for i in range(n): for j in range(i+1,n): if M[i,j]!=0: raise ValueError('Inversion method is for lower triangular matrices only.') # split into blocks for recursion l = int(n/2) # size of smaller block A = M[:l,:l] # upper left B = M[l:,l:] # lower right E = M[l:,:l] # lower left O = M[:l,l:] # upper right, should be all zeros A = rec_lt_block_invert(A) # invert A B = rec_lt_block_invert(B) # invert B E = -B*E*A # "invert" E R = concatenate((concatenate((A,E),axis=0),concatenate((O,B),axis=0)),axis=1) return matrix(R)
def solution(pegs): lst = [] for i in range(len(pegs) - 1): lst.append(pegs[i + 1] - pegs[i]) last_gear = 0 for i, ele in enumerate(lst): if i % 2 == 0: last_gear += ele else: last_gear -= ele if len(pegs) % 2 == 0: last_gear = frac(last_gear, 3) first_gear = frac(last_gear) * 2 if first_gear <= 0 or last_gear <= 0: return [-1, -1] ss = [first_gear] cur_gear = first_gear for element in lst: check = element - cur_gear if check <= 1: return [-1, -1] ss.append(check) cur_gear = check for i in range(len(ss) - 1): klo = ss[i] + ss[i + 1] if klo != lst[i]: return [-1, -1] return [first_gear.numerator, first_gear.denominator]
def polyroots(q, p, pol): """ Finds all of the roots of polynomial @pol, with the constant of highest degree @q and the constant of x**0 @p. Returns a set of all the roots. >>> polyroots(1, 2, 'x**3 - 2*x**2 - x + 2') set([1, 2, -1]) TODO: Add ability to find @q and @p from @pol AUTHORS: v0.5.1+ --> pydsigner v1.1.0+ --> pydsigner """ # First a set of fractions is generated from the factors of @q and @p; # These fractions are every possible (x/y equaling -x/-y and # -x/y equaling x/-y) combination of these factors (the factors of @p being # in the denominator) that makes the polynomial equal 0 S = set(x for x in set(flatten((frac(pv, qv), frac(-pv, qv)) for qv in factors(abs(q)) for pv in factors(abs(p)))) if eval(pol.replace('x', 'frac("%s")' % x)) == 0) # Make new set where whole numbers are changed to int()s and any lossless # conversions to float()s are made nset = set() for n in S: if n.denominator == 1: nset.add(n.numerator) elif frac(float(n)) == n: nset.add(float(n)) else: nset.add(n) return nset
def main(): print("یه اینتر اضافه آخرش بزنید") print("insirt A") satr = [frac(x) for x in input().split()] matrix = np.array(satr) loghat = [] satr = [frac(x) for x in input().split()] while len(satr) != 0: matrix = np.vstack((matrix, satr)) satr = [frac(x) for x in input().split()] matrix_reduce, p, p_r, p_c = echelon(matrix) print("ماتریس کاهش یافته ی سطری") print(matrix_reduce.astype(str)) free_c = [c for c in range(matrix.shape[1]) if c not in p_c] null = [] for col in free_c: v = np.zeros((matrix.shape[1], 1)) v[col] = 1 for piv in p: v[piv[1], 0] = -1 * matrix_reduce[piv[0], col] null.append(v) print("پایه های فضای پوچ") for b in null: print(b) print("#####") print("مختصات بقیه ی بردار ها بر اساس بردار پایه") for free in free_c: zarib = np.zeros((len(p_r), 1)) for row in p_r: zarib[row] = matrix_reduce[row, free] print(zarib) print("====")
def solver_results(x, s, m, c, w, order=False, verbose=True): """ solves the optimization equation :param s: speeds :param m: gekko model :param c: completion times :param verbose: boolean to print or not :param order: optional order to print or not :return: task_process_time, ending times, intervals, speeds, objective value """ #m.Obj(O) # Objective try: m.options.IMODE = 3 # Steady state optimization m.solve(disp=verbose) # Solve except: # print("Did not work") # if order!=False: # print("Order is ", order) return [], [-1] * len(s), [-1] * len(s), [-1, -1] * len(s), [ -1 ] * len(s), 10000000 task_process_time = [ frac(w[i] / frac(s[i].value[0])) for i in range(len(s)) ] ending_time = [frac(c[i].value[0]) for i in range(len(c))] intervals = [[end - process_time, end] for (process_time, end) in zip(task_process_time, ending_time) ] speeds = [frac(s[i].value[0]) for i in range(len(s))] task_process_time = [ float(process_time.__round__(5)) for process_time in task_process_time ] ending_time = [float(end_time.__round__(5)) for end_time in ending_time] intervals = [[ float(interval[0].__round__(5)), float(interval[1].__round__(5)) ] for interval in intervals] speeds = [float(speed.__round__(5)) for speed in speeds] if verbose: print('Results') for i in range(len(s)): print( str(i) + " Speed: " + str(s[i].value) + " Ending Time: " + str(c[i].value) + " Interval: " + str(intervals[i]) + " Task process time: " + str(task_process_time[i])) print('Objective: ' + str(m.options.objfcnval)) if x != None: order = create_order(x, c) else: order = None return order, task_process_time, ending_time, intervals, speeds, float( frac(m.options.objfcnval).__round__(5))
def answer(m): denominators = get_denominators(m) absorbing_states = [] non_absorbing_states = [] for state in range(len(denominators)): if denominators[state] == 0: absorbing_states.append(state) else: non_absorbing_states.append(state) # handle 1x1 nad 2x2 matricies if len(denominators) <= 2: return [1, 1] # handle absorbing state 0 if 0 in absorbing_states: return [1 if s == 0 else 0 for s in range(len(m))] + [1] # setup standard for matricies q_matrix = [[frac(m[n][q], denominators[n]) for q in non_absorbing_states] for n in non_absorbing_states] i_matrix = get_identity_matrix(q_matrix) r_matrix = [[frac(m[n][a], denominators[n]) for a in absorbing_states] for n in non_absorbing_states] # calculate iq_matrix = subtract_matricies(i_matrix, q_matrix) f_matrix = invert_matrix(subtract_matricies(i_matrix, q_matrix)) result_matrix = multiply_matricies(f_matrix, r_matrix) # get probabilities from s0 return get_int_array_for_fractions(result_matrix[0])
def __compute_left_to_sale(self) -> frac: left_to_sale = frac("1") for item in self.processing.order_by(Processing.id): if left_to_sale < frac(str(item.done)): return frac("0.0") left_to_sale -= frac(str(item.done)) return left_to_sale
def f(k): global cache n = frac(1, k) nx = [str(1), str(k)] alist = [] if k == 1: return 1 while True: if nx[0] == "1" and len(nx) != 1: alist += [nx[1]] if len(nx) == 1 or int(nx[1]) == 1: for i in alist: cache[i] = int(nx[0]) return int(nx[0]) else: x = nx[0] y = nx[1] x = int(x) + 1 y = int(y) - 1 n = frac(x, y) nx = str(n).split("/") if nx[0] == "1" and len(nx) != 1 and cache.get(nx[1]): global count count += 1 for i in alist: cache[i] = cache.get(nx[1]) return cache.get(nx[1])
def __compute_wall_area_to_sale(self) -> frac: wall_area_to_sale = self.__compute_gross_wall_area() for hole in self.holes: if not hole.below_3m2: wall_area_to_sale -= frac(str(hole.total_area)) - frac( str(hole.amount)) return wall_area_to_sale
def polyroots(q, p, pol): ''' Finds all of the roots of polynomial @pol, with the constant of highest degree @q and the constant of x**0 @p. Returns a set of all the roots. >>> polyroots(1, 2, 'x**3 - 2*x**2 - x + 2') set([1, 2, -1]) TODO: Add ability to find @q and @p from @pol AUTHORS: v0.5.1+ --> pydsigner ''' s = set((x for x in set(iter_utils.flatten((((frac(up, uq) for uq, up in [ (-qv, -pv), (-qv, pv), (qv, -pv), (qv, pv)]) for qv in factors(abs(q))) for pv in factors(abs(p))))) if eval(pol.replace('x', 'frac("%s")' % x)) == 0)) nset = set() for n in s: if n.denominator == 1: nset.add(n.numerator) elif frac(float(n)) == n: nset.add(float(n)) else: nset.add(n) return nset
def victory_chance(current_board, tqdm_nesting=0): if count_ones(current_board.state) == 15: return frac(1, 1) hash = current_board.hash() with ENV.begin() as txn: stored = txn.get(hash + b"_chance") if stored is not None: return frac(*struct.unpack(">2Q", stored)) total_chance = frac(0, 1) weights = zip(*get_weights(current_board.remaining_pieces)) best_positions = {} if tqdm_nesting > 0: weights = pbar(weights, leave=False, total=len(PIECES), desc=f"Weights {tqdm_nesting-1}") for weight, last_legal in weights: if weight == 0: continue boards = [(current_board.place(last_legal, x, y), x, y) for x in range(current_board.w) for y in range(current_board.h)] boards = [i for i in boards if i[0] is not None] if tqdm_nesting > 0: boards = pbar(boards, desc=f"Victory {tqdm_nesting-1}", leave=False) chances = [(victory_chance(board, tqdm_nesting - 1), x, y) for board, x, y in boards] chances.sort(reverse=True) total_chance += 0 if len(chances) == 0 else chances[0][0] * weight chances = [{ "numerator": chance._numerator, "denominator": chance.denominator, "x": x, "y": y } for chance, x, y in chances] best_positions[last_legal] = chances chance_packed = struct.pack(">2Q", total_chance._numerator, total_chance.denominator) moves_dumped = json.dumps(best_positions).encode() with ENV.begin(write=True) as txn: txn.put(hash + b"_chance", chance_packed) txn.put(hash + b"_moves", moves_dumped) return total_chance
def A(prof): if prof == 0: return frac(2) else: a = frac(2 + (1 / 2)) for i in range(prof - 1): a = frac(2 + 1 / a) return frac(a)
def convert_to_1(row, value): try: value = frac(value) inverse_of_value = value**-1 for index, i in enumerate(row): row[index] = frac(i) * inverse_of_value except ZeroDivisionError: print("This system of equations cant be solved") exit()
def getConstant(x,y): n = np.shape(y)[0] pyramid = np.zeros([n,n]) pyramid = pyramid.astype('object') pyramid[::,0] = y for j in range(1,n): for i in range(n-j): pyramid[i][j] = frac((frac(pyramid[i+1][j-1]) - frac(pyramid[i][j-1])),(frac(x[i+j]) - frac(x[i]))) return pyramid[0]
def probabilify_matrix(m): for row in m: denominator = sum(row) if not denominator == 0: for i in range(len(row)): row[i] = frac(row[i], denominator) else: for i in range(len(row)): row[i] = frac(0)
def validate_done_attr_while_editing(wall: db.Model, processing: db.Model, data: Dict) -> Dict: done = data.get("done") if done: left_to_sale = frac(str(wall.left_to_sale)) left_to_sale += frac(str(processing.done)) if float(left_to_sale) < float(done): data["done"] = float(left_to_sale) return data
def addArray(arr,new_value): try: if '/' in new_value: new_value = frac(new_value) else: new_value = int(new_value) except: new_value = frac(new_value).limit_denominator() return np.append(arr, new_value)
def test_equals(self): self.assertTrue(zero == Ideal(C)) self.assertTrue(P == Point(C, frac(3), frac(5))) self.assertTrue(Q == Point(C, frac(-2), frac(0))) self.assertFalse(zero == P) self.assertFalse(zero == Q) self.assertFalse(P == zero) self.assertFalse(P == Q) self.assertFalse(Q == zero) self.assertFalse(Q == P)
def reduce(v1, v2): v1 = [frac(v) for v in v1] v2 = [frac(v) for v in v2] while True: if norm(v2) < norm(v1): v1, v2 = v2, v1 m = round(dot(v1, v2) / norm(v1), 0) if m == 0: return ([float(v) for v in v1], [float(v) for v in v2]) v2 = [u2 - m * u1 for u2, u1 in zip(v2, v1)]
def __init__(self, s): """ :param s: string notation of the units. there should be whitespace around quantities and '/' dividing quantities """ if isinstance(s, OSUnits): self.power = cp.deepcopy(s.power) else: self.power = np.array( [frac(0), frac(0), frac(0), frac(0), frac(0)]) if isinstance(s, bytes): s = s.decode("utf-8") if 'a.u.' != s: sl = s.split() nominator = True while sl: ss = sl.pop(0) if ss == '/': nominator = False continue for p, n in enumerate(OSUnits.name): if n == ss[0:len(n)]: res = OSUnits.xtrnum.findall(ss) # extract numbers if res: self.power[p] = frac( res[0]) if nominator else -frac(res[0]) else: self.power[p] = frac( 1, 1) if nominator else frac(-1, 1) break elif ss in ['1', '2', '\pi', '2\pi']: break else: raise ValueError('Unknown unit: ' + re.findall(r'\w+', ss)[0])
def get_I(m): I = [] for i in range(len(m)): temp = [] for j in range(len(m)): if j == i: temp.append(frac(1)) else: temp.append(frac(0)) I.append(temp) return I
def identity_matrix(transit_len): I = [] for r in range(transit_len): I.append([]) for c in range(transit_len): if r == c: I[r].append(frac(1, 1)) else: I[r].append(frac(0, 1)) return I
def cast_to_probability_matrix(m): """Takes the input matrix and casts each row to a probabilistic representation with fractions where the total of each row is calculated and each entry in the row represents it's fraction of the total""" m_new = [] for i in range(len(m)): row_sum = reduce((lambda x, y: x + y), m[i]) if row_sum > 0: m_new.append(map((lambda x: frac(x, row_sum)), m[i])) else: m_new.append(map((lambda x: frac(x, 1)), m[i])) return matrix(m_new)
def displayResult(): ## Get Constant Vector start_time = time.time() constant_vector = getConstant(x,y) print('The Constant Vector = ',constant_vector) # Get value Y from X based on Polynomial Equation formula = getFormula(constant_vector) print('') print(f"Excecution Time: {time.time()-start_time} seconds ") test1 = ''.join(formula).replace('(','*(').replace('x','a').replace('c*','c') print(' ') # expression to be evaluated expr = test1 while True: # variable used in expression selection = input("Enter '1' for value of X, '2' for location of x, 'f' for skip: ") print(selection) if selection == '1': a = input("Enter the value of x:") try: if '/' in a: a=frac(a) else: a = int(a) except: a = frac(a).limit_denominator() elif selection == '2': loc = float(input("Enter the location of x:")) a = findnewX(loc) try: if '/' in a: a=frac(a) else: a = int(a) except: a = frac(a).limit_denominator() elif selection == 'f': break; # evaluating expression Y = eval(expr) print('Y =', Y) ans = input("Do you want to test with other value of x or other location of x? y/n : ") if ans =='y': continue else: break
def eulerphi(d): '''return euler's phi for the input''' factors=factor(d) primes=(f for f in factors if isprime(f)) #generator expression invprimes=map(lambda x: frac(x-1,x),primes) phi=d*reduce(lambda x,y: x*y,invprimes) #formula from http://en.wikipedia.org/wiki/Euler%27s_totient_function return phi
def b(self, i): if i == 1: return 1; numer = factorial( i-1 ) * factorial(i) denom = factorial(2*i-1) if (i-1)&1 == 1: numer = -numer return frac(numer, denom)
def checkio(*data): xw1 = frac(data[0][0]) yw1 = frac(data[0][1]) xw2 = frac(data[1][0]) yw2 = frac(data[1][1]) xa = frac(data[2][0]) ya = frac(data[2][1]) xb = frac(data[3][0]) yb = frac(data[3][1]) if data[2] == data[3]: return -1 #Ax+By+C=0 dxw, dyw = xw2 - xw1, yw2 - yw1 awall, bwall, cwall = dyw, -dxw, dxw * yw1 - dyw * xw1 dxba, dyba = xb - xa, yb - ya abull, bbull, cbull = dyba, -dxba, dxba * ya - dyba * xa try: if bwall: x = (bbull * cwall / bwall - cbull) / (abull - bbull * awall / bwall) y = -1 * (awall * x + cwall) / bwall else: x = -1 * cwall / awall y = -1 * (abull * x + cbull) / bbull except ZeroDivisionError: #parallel #check if bullet line and wall line is same if bwall and bbull: cwall = cwall / bwall cbull = cbull / bbull else: cwall = cwall / awall cbull = cbull / abull if cwall == cbull: if min(xw1, xw2) <= xa <= max(xw1, xw2) and min(yw1, yw2) <= ya <= max(yw1, yw2): return True x, y = xw1, yw1 #shoot in end of wall else: return -1, None #parallell #check if x,y in wall mx, my = (xw1 + xw2) / 2, (yw1 + yw2) / 2 dist = ((mx - x) ** 2 + (my - y) ** 2) ** 0.5 wdist = ((mx - xw1) ** 2 + (my - yw1) ** 2) ** 0.5 if min(xw1, xw2) <= x <= max(xw1, xw2) and min(yw1, yw2) <= y <= max(yw1, yw2): #check direction if min(x, xa) <= xb <= max(x, xa) and min(y, ya) <= yb <= max(y, ya): pass elif min(xa, xb) <= x <= max(xb, xa) and min(yb, ya) <= y <= max(yb, ya): pass else: return -1, None if dist > wdist: return -1, [float(x), float(y)] else: return 100 - round((dist / wdist) * 100), [float(x), float(y)]
def solve(n): ''' Solves PE problem 152. Finds all representations of 1/2 as the sum of distinct inverse squares with denominator at most n. For n = 45, the representations are: {2,3,4,6,7,9,10,20,28,35,36,45} and {2,3,4,6,7,9,12,15,28,30,35,36,45}, {2,3,4,5,7,12,15,20,28,35} ''' excluded_primes = [] cand_psets = [] #HACK (sorry about this) sets = [5,7,13] for s in sets: cand_psets.append([]) for st in find_feasible(n,s): if 13 not in st and 11 not in st: cand_psets[-1].append(set([s*el for el in st])) fdict1 = {} for set_comb in product(*cand_psets): finit = frac(0,1) for el in set_comb[0].union(set_comb[1].union(set_comb[2])): finit += frac(1,el*el) if finit in fdict1: fdict1[finit] += 1 else: fdict1[finit] = 1 total = 0 rems = list(HarshadGen([2,3],n,exact=False))[2:] rems.remove(3) rems.remove(64) rems.remove(32) rems.remove(27) rems.remove(2*27) sf=frac(1,4)-frac(1,9) fracs = [sf] for el in rems: cfrac = frac(1,el*el) tf = [] for f in fracs: t2 = f-cfrac if t2 in fdict1: total += fdict1[t2] tf.append(t2) fracs.extend(tf) return total
def b(self, i): """Calculate the b matrix""" if i == 1: return 1; numer = factorial( i-1 ) * factorial(i) denom = factorial(2*i-1) if (i-1)&1 == 1: numer = -numer return frac(numer, denom)
def sq2(n): "Estimate square root of two by continued fractions" # Format: [1;(2)] base = 1 repeater = 2 def helper(n): if n==0: return repeater return repeater + frac(1, helper(n-1)) return base + frac(1, helper(n-1))
def a(self, i, j): """Calculate the A[i][j]. Args: i: row number. j: column number. """ numer = i * factorial(j+i-1) denom = j * factorial(2*i-1) * factorial(j-i) return frac(numer, denom)
def f1(k): if k == 1: return 1 if cache.get(k): return cache.get(k) n = frac(1, int(k)) nx = [str(1), str(k)] alist = [] while True: if len(nx) == 1 or nx[1] == 1: return int(nx[0]) else: x = nx[0] y = nx[1] x = int(x) + 1 y = int(y) - 1 n = frac(x, y) nx = str(n).split("/") if nx[0] == "1": return f1(nx[1])
def b(self, i): """Calculate the b[i]. Args: i: row number. """ if i == 1: return 1; numer = factorial( i-1 ) * factorial(i) denom = factorial(2*i-1) if (i-1)&1 == 1: #just even or odd numer = -numer return frac(numer, denom)
def intersection(self, other): # l1*a + (1-l1) *b = l2 * oa + (1-l2) * ob try: A = np.array([self.a - self.b, other.b - other.a]).T b = other.b - self.b d = int(A[0, 0] * A[1, 1] - A[1, 0] * A[0, 1]) if not d: return None l1 = int(b[0] * A[1, 1] - b[1] * A[0, 1]) l2 = int(b[1] * A[0, 0] - b[0] * A[1, 0]) l1 = frac(l1, d) l2 = frac(l2, d) if l1 <= 0 or l1 >= 1 or l2 <= 0 or l2 >= 1: return None return (int(self.a[0] - self.b[0]) * l1 + self.b[0], int(self.a[1] - self.b[1]) * l1 + self.b[1]) except: return None
def matrix_b(self,i): """Calculate the b(i) of matrix b """ #For numerator numer = (-1)**(i-1) for i1 in range(2*i-3, 1, -2): numer = numer * i1**2 #For denominator denom = 1 i2 = (2*i-1)**2 for i3 in range(2*i-3, -1, -2): denom = denom * (i2- i3**2) b = frac(numer, denom) return b
def solve_eq(d): x, y = 0, 0 seq_size = 2 reduced_sequence = continued_fraction(d) while x**2 - d * y ** 2 != 1: generalized_sequence = generate_development(reduced_sequence) sequence = [generalized_sequence.send(None) for _ in range(seq_size)] current = 0 for i in range(len(sequence) - 1, 0, -1): current = frac(1, sequence[i] + current) current += sequence[0] x = current.numerator y = current.denominator seq_size += 1 return x, y
def fenci(s): l = len(s) p = [1 for i in range(l + 1)] t = [None for i in range(l)] for i in range(l - 1, -1, -1): p[i], t[i] = max((frac(prob(s[i:i + k]), total) * p[i + k], k) for k in range(1, l - i + 1)) p[i] = simplify(p[i]) print 'sum:', p[0] i = 0 while i < l: yield s[i:i + t[i]] i = i + t[i]
def matrix_a(self, i, j): """Calculate the a(i,j) of matrix A """ #For numerator numer = 1 j1 = (2*j-1)**2 for i1 in range(2*i-3, -1, -2): numer = numer * (j1 - i1**2) #For denominator denom = 1 i2 = (2*i-1)**2 for i3 in range(2*i-3, -1, -2): denom = denom * (i2- i3**2) #print( frac(numer, denom) ) return frac(numer, denom)
def divPoly(N,D): N, D = map(frac,trim(N)), map(frac,trim(D)) degN, degD = len(N)-1, len(D)-1 if(degN>=degD): q=[0]*(degN-degD+1) while(degN>=degD and N!=[0]): d=list(D) [d.insert(0,frac(0,1)) for i in range(degN-degD)] q[degN-degD]=N[degN]/d[len(d)-1] d=map(lambda x: x*q[degN-degD],d) N=subPoly(N,d) degN=len(N)-1 r=N else: q=[0] r=N return [trim(q),trim(r)]
def slow_rep_positive(rep): a,b,c = int(rep[0]), int(rep[1]), int(rep[2]) if a == 0: if b == 0: return c >= 0 else: return r_less(0, frac(c, b)) d = b*b - 4*a*c # print "disc ",d #then the polynomial is always positive or negative for r real, with sign given by the leading coefficient if d < 0: return a >= 0 # D = frac(d, 4*a*a) # C = frac(-b, 2*a) r1, r2 = None, None # m1 = (D + 3*C*C - 2*C) #m1 = frac(d+3*b*b+4*a*b, 4*a*a) #m2 = (3*D*C - D + C**3 - C*C - 1) #m2 = frac(-3*d*b-2*a*d-b**3-2*a*b*b-8*a**3, 8*a**3) m2 = -3*d*b-2*a*d-b**3-2*a*b*b-8*a**3 m1 = d+3*b*b+4*a*b mag_comp = d*m1*m1 >= m2*m2 if m1 >= 0: if m2 >= 0: r1 = True r2 = not mag_comp else: r1 = mag_comp r2 = False else: if m2 < 0: r1 = False r2 = mag_comp else: r1 = not mag_comp r2 = True if a > 0: return (r1 and r2) or (not r1 and not r2) else: return (r1 and not r2) or (r2 and not r1)
def e(n): "Estimate e by continued fractions" # Format: [2; 1,2,1, 1,4,1, 1,6,1, ..., 1,2k,1 ...] base = 2 def repeater(): k=1 while True: yield 1 yield 2*k k+=1 yield 1 R = repeater() def helper(n, depth=1): if n==0: return R.next() return R.next() + frac(1, helper(n-1, depth+1)) if n==0: return base return base + frac(1, helper(n-1))
def test_ds(): ref = [[1.0], [1.0]] h = frac(1,2) ds = cg.CG(h, 0, h) assert_cg(ref, ds)
def test_sd(): ref = [[1.0, 1.0]] h = frac(1, 2) sd = cg.CG(0, h, h) assert_cg(ref, sd)
__author__ = '보운' # 20113259 컴퓨터공학부 3학년 김보운 # 알고리즘 과제 - Henry from fractions import Fraction as frac with open('input.txt', 'r') as f: testCase = int(f.readline()) for x in range(testCase): data = f.readline().split(' ') henry = frac(int(data[0]), int(data[1])) while henry.numerator > 1: henry -= frac(1, int(((henry.denominator - 1) / henry.numerator + 1))) print(henry.denominator)
def test_score_rest(): rest = score.Rest(frac(1, 4)) assert isinstance(rest, score.Rest)
def test_score_note(): note = score.Note("c##", frac(1, 4)) assert isinstance(note, score.Note)
def expandSqrt2(n): ls = [frac(3,2)] for i in range(1, n): ls.append(1+frac(1,1+ls[i-1])) return ls
def test_dds(): isq2 = sqrt(0.5) ref = [[0.0, -isq2], [isq2, 0.0]] h = frac(1, 2) dds = cg.CG(h, h, 0) assert_cg(ref, dds)
def test_ddt(): isq2 = sqrt(0.5) ref = [[1.0, isq2], [isq2, 1.0]] h = frac(1,2) ddt = cg.CG(h, h, 1) assert_cg(ref, ddt)