def power_interval(a, n): the_power = ft.arb(1) if type(a) != type(ft.arb(1)): return float(a)**n elif n != 0: if a.lower() >= 0: the_power = ft.arb(0.5 * (a.lower())**n + 0.5 * (a.upper())**n, 0.5 * (a.upper())**n - 0.5 * (a.lower())**n) elif a.upper() <= 0: if n % 2 == 0: the_power = ft.arb(0.5 * (a.lower())**n + 0.5 * (a.upper())**n, 0.5 * (a.lower())**n - 0.5 * (a.upper())**n) else: the_power = ft.arb(0.5 * (a.lower())**n + 0.5 * (a.upper())**n, 0.5 * (a.upper())**n - 0.5 * (a.lower())**n) else: a1 = ft.arb(0.5 * a.lower(), -0.5 * a.lower()) a2 = ft.arb(0.5 * a.upper(), 0.5 * a.upper()) the_power2 = ft.arb(0.5 * (float(a2.upper()))**n, 0.5 * (float(a2.upper()))**n) if n % 2 == 0: the_power1 = ft.arb(0.5 * (a1.lower())**n, 0.5 * (a1.lower())**n) else: the_power1 = ft.arb(0.5 * (a1.lower())**n, -0.5 * (a1.lower())**n) the_power = the_power1.union(the_power2) #print("power") #print(the_power.lower(),the_power.upper()) return the_power
def evaluation_term(term, B): #evaluate a term at a box B... term if [str(T) for T in term[0]] == ["0"] * len(term[0]): if type(term[1]) == type( ft.arb(1)): #to avoid an error by sympy zeros the_evaluation = term[1] else: the_evaluation = ft.arb(float(term[1])) else: the_evaluation = ft.arb(1) for i in range(len(term[0])): if term[0][i] != 0: the_evaluation = intervals_multi( the_evaluation, (power_interval(B[i], term[0][i]))) #print(B[i], term[0],i) #print(the_evaluation.lower()) #ftprint([intervals_multi(the_evaluation,(power_interval(B[i],term[0][i])))]) #input() #the_evaluation=(the_evaluation)*(power_interval(B[i],term[0][i])) if type(term[1]) == type( ft.arb(1)): #to avoid an error by sympy zeros the_evaluation = the_evaluation * term[1] else: the_evaluation = intervals_multi(the_evaluation, ft.arb(float(term[1]))) return the_evaluation
def _validate_root_enclosure(poly, x): """ Given x known to be an enclosure of *at least one root of poly*, certifies that the enclosure contains a unique root, and in that case returns a new (possibly improved) enclosure for the same root. Returns None if uniqueness cannot be certified. """ if x.is_exact() or poly.degree() == 1: return x orig = ctx.prec try: acc = x.rel_accuracy_bits() ctx.prec = max(acc, 32) * 2 + 10 pure_real = x.imag == 0 # slightly inflate enclosure - needed e.g. in case of # complex interval with one very narrow real/imaginary part eps = x.rad() * (1 / 16.) if pure_real: x += arb(0, eps) else: x += acb(arb(0, eps), arb(0, eps)) # interval Newton steps xmid = x.mid() y = xmid - poly(xmid) / poly.derivative()(x) if pure_real: x = x.real y = y.real if x.contains_interior(y): return y return None finally: ctx.prec = orig
def evaluation_poly_list(poly_list, B): evaluation = ft.arb(0) for term in poly_list: value_of_term = evaluation_term(term, B) if type(value_of_term) == type(ft.arb(1)): evaluation = evaluation + value_of_term else: evaluation = evaluation + ft.arb(float(value_of_term)) return evaluation
def gauss_seidel_dim1(a, b, x): Answer = x if 0 not in (a * ft.arb(1)): try: Answer = x.intersection((b * ft.arb(1)) / a) except: Answer = 'empty' else: Answer = special_cases_gauss_seidel(a, b, x) return Answer
def B_Ball_calculator(B): # returns B_Ball norm_diff = ft.arb(0) #computing \Xi (Remark 5.2.10) for i in range(2, len(B)): norm_diff += power_interval(B[i] - B[i], 2) max_t = float(norm_diff.upper()) B_Ball = B[:2] for i in range(2, len(B)): B_Ball.append(B[i] + ft.arb(0, max_t)) B_Ball += [ft.arb(0, 1)] * (len(B) - 2) B_Ball += [ft.arb(0.5 * max_t, 0.5 * max_t)] return B_Ball
def ploterr(ax, f, xab, yab, step, yrange=None, color=None, label=None, hatch=None, alpha=1.0): print "yah" xrad = step * 0.5 a, b = xab top = 0.0 bot = 0.0 for xx in arange(a, b, 2 * xrad): xmid = xx + xrad X = arb(xmid, xrad) if abs(xmid + xrad) < 1e-10: X = -((-X).nonnegative_part()) elif abs(xmid - xrad) < 1e-10: X = X.nonnegative_part() Y = f(X) if Y.is_finite(): ymid = float(arb(Y.mid())) yrad = float(arb(Y.rad())) top = max(top, (ymid + yrad) * 1.2) bot = min(bot, (ymid - yrad) * 1.2) ax.add_patch( patches.Rectangle((xmid - xrad, ymid - yrad), 2 * xrad, 2 * yrad, color=color, alpha=alpha, hatch=hatch)) else: ax.add_patch( patches.Rectangle((xmid - xrad, -1e50), 2 * xrad, 1e50, color=color, alpha=alpha, hatch=hatch)) ax.set_xlim([a, b]) if yab is None: ax.set_ylim([bot, top]) else: ax.set_ylim(yab) if label is None: label = 'Step %s' % step patch1 = mpatches.Patch(color=color, label=label, alpha=alpha, hatch=hatch) legends.append(patch1)
def evlist(boxes): ftboxes = [[d.ftconstructor(Bi[0], Bi[1]) for Bi in B] for B in boxes] n = len(boxes[0]) m = len(boxes) m1 = [] m2 = [] for B in ftboxes: m1.append(ft.arb(0.0002 * ft.arb.sin(B[2]) * ft.arb.cos(B[2]))) m2.append(ft.arb(-2 * ft.arb.sin(B[2])**2 * ft.arb.cos(B[2]))) innrer_loops = [i for i in range(m) if 0 in m1[i] and 0 in m2[i]] x1mon = [i for i in range(m) if 0 not in m1[i]] x2mon = [i for i in range(m) if 0 in m1[i] and 0 not in m2[i]] return [x1mon, x2mon, innrer_loops]
def subdivide(B): #B is a list of ft.arb if len(B) == 1: children = [[ft.arb(B[0].mid() + (B[0].rad() / 2), B[0].rad() / 2)], [ ft.arb(B[0].mid() - (0.5 * B[0].rad()), 0.5 * B[0].rad()) ]] else: B_prime = list(B) B_prime.remove(B_prime[len(B_prime) - 1]) B_pri_sub = subdivide(B_prime) B_one_sub = subdivide([B[len(B) - 1]]) children = cartesian_product(B_pri_sub, B_one_sub) return children
def ftprint(B, k=3): answer = [] if type(B[0]) == type(ft.arb(1)): for Bi in B: if type(Bi) == type(ft.arb(0, 1)): answer.append( [round(float(Bi.lower()), k), round(float(Bi.upper()), k)]) else: answer.append([Bi, Bi]) print(answer) elif type(B[0]) == type([]): pprint(Matrix([[ [round(float(Bij.lower()),k),round(float(Bij.upper()),k) ] if \ type(Bij)==type(ft.arb(1)) else [Bij,Bij ] for Bij in Bi ] for Bi in B ] ))
def solver2(P, jac, B): t1 = time.time() S = solver(P, jac, B) S2 = [] k = 2 connected_components1 = connected_components(S) while len(connected_components1) != len(S): for component in connected_components1: if len(connected_components1[component]) == 1: S2.append(S[connected_components1[component][0]]) else: union_box = S[connected_components1[component][0]] for i in range(1, len(connected_components1[component])): union_box = box_union( union_box, S[connected_components1[component][i]]) union_box_inflated = [ x + y for x, y in zip(union_box, [ft.arb(0, 0.001)] * len(union_box)) ] S3 = solver(P, jac, union_box_inflated, k) S2 = S2 + S3 k += 1 S = S2[:] S2 = [] connected_components1 = connected_components(S) t2 = time.time() print(t2 - t1) return S
def figure3(): global legends plt.clf() ax = plt.gca() legends = [] ax.grid(True) k = 1 R = -arb(-1).exp() ploterr(ax, lambda X: acb(R, X).lambertw(k).real, [-4, 4], [-5, 1], 0.5, color="lightblue", label="$h = 0.5$", alpha=0.7) ploterr(ax, lambda X: acb(R, X).lambertw(k).real, [-4, 4], [-5, 1], 0.1, color="blue", label="$h = 0.1$", alpha=0.5) ploterr(ax, lambda X: acb(R, X).lambertw(k).real, [-4, 4], [-5, 1], 0.01, color="black", label="$h = 0.01$", alpha=1.0) plt.xlabel("$y$") plt.ylabel("$\Re(W_{%ld}(-1/e+yi))$" % k) ax.legend(handles=legends, loc="upper right") import matplotlib fig = matplotlib.pyplot.gcf() fig.set_size_inches(8, 5) fig.savefig('test2.png', bbox_inches="tight") fig.savefig('branchplot2.pdf', bbox_inches="tight")
def checking_smoothness(P, B, jac, wth=0.1): M = [coefficient_matrix_list(Pi) for Pi in P] list_of_boxes = [B] smoothness = 1 regular_boxes = [] while len(list_of_boxes) != 0 and width(list_of_boxes[0]) > wth: membership = 1 eval_P = [polyvalnd(Mi, list_of_boxes[0]) for Mi in M] for eval_Pi_at_B in eval_P: if 0 not in ft.arb(1) * (eval_Pi_at_B): membership = 0 eval_jac = matrixval(jac, list_of_boxes[0]) full_rankness = checking_full_rank(eval_jac) if membership == 0 or full_rankness == 1: regular_boxes.append(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: new_children = subdivide(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) list_of_boxes = list_of_boxes + new_children if len(list_of_boxes) != 0: smoothness = -1 print("Empty or regular boxes:", regular_boxes) print("Unknown-behavior boxes", list_of_boxes) return smoothness
def figure1(): global legends plt.clf() ax = plt.gca() legends = [] ax.grid(True) R = float(-arb(-1).exp()) k = 0 plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 3], [-3, 2], 0.5, color="lightblue", label="$W_{0}(x), \\varepsilon = 0.5$", alpha=0.6) plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 3], [-3, 2], 0.1, color="blue", label="$W_{0}(x), \\varepsilon = 0.1$", alpha=0.7) plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 3], [-3, 2], 0.01, color="black", label="$W_{0}(x), \\varepsilon = 0.01$", alpha=1.0) k = -1 plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 0], [-3, 2], 0.5, color="orange", label="$W_{-1}(x), \\varepsilon = 0.5$", alpha=0.4) plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 0], [-3, 2], 0.1, color="red", label="$W_{-1}(x), \\varepsilon = 0.1$", alpha=0.8) #plotadaptive(ax, lambda X: acb(X).lambertw(k).real, [R, 0], [-3,2], 0.01, color="black", label="$W_{-1}(x), \\varepsilon = 0.01$", alpha=1.0) ax.set_xlim([-1, 3]) ax.set_ylim([-4, 2]) ax.axhline(y=-1, color="gray") ax.axvline(x=R, color="gray") plt.xticks([-1, R, 0, 1, 2, 3], ["$-1$", "$-1/e$", "$0$", "$1$", "$2$", "$3$"]) plt.xlabel("$x$") plt.ylabel("$W_k(x)$") ax.legend(handles=legends, loc="best") import matplotlib fig = matplotlib.pyplot.gcf() fig.set_size_inches(8, 5) fig.savefig('test1aa.png', bbox_inches="tight") fig.savefig('branchplot1.pdf', bbox_inches="tight")
def checking_regularity_of_sysyem(P, B, jac, wth=0.2): list_of_boxes = [B] smoothness = 1 regular_boxes = [] empty_boxes = [] regular_volume = 0 empty_volume = 0 unknownvolume = n_volume(B) while len(list_of_boxes) != 0 and width(list_of_boxes[0]) > wth: current_box = list_of_boxes[0] membership = 1 eval_P = [evaluation_poly_list(Pi, current_box) for Pi in P] for eval_Pi_at_B in eval_P: if type(eval_Pi_at_B) != type(ft.arb(1)): eval_Pi_at_B = float(eval_Pi_at_B) if 0 not in ft.arb(1) * (eval_Pi_at_B): membership = 0 break if membership == 0: empty_boxes.append(list_of_boxes[0]) empty_volume += n_volume(list_of_boxes[0]) unknownvolume = unknownvolume - n_volume(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: eval_jac = [[ ft.arb(evaluation_poly_list(jac_ij, list_of_boxes[0])) for jac_ij in jac_i ] for jac_i in jac] if invertibility_of_a_matrix( eval_jac) == 1: # 0 not in (ft.arb_mat(eval_jac)).det(): #print(ft.arb_mat(eval_jac)) regular_boxes.append(list_of_boxes[0]) regular_volume = regular_volume + n_volume(list_of_boxes[0]) unknownvolume = unknownvolume - n_volume(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: new_children = subdivide(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) list_of_boxes = list_of_boxes + new_children if len(list_of_boxes) != 0: smoothness = -1 return smoothness
def matrixval(jac, X): #jac as i_minor and X is a list of ft.arb #coeffs_matrix_matrix=[copy(jaci) for jaci in jac] evaluation_jac_X = [copy(jaci) for jaci in jac] for i in range(len(jac)): for j in range(len(jac[0])): evaluation_jac_X[i][j] = evaluation_poly_list(jac[i][j], X) if evaluation_jac_X[i][ j] == 0: #fixing a bug in flint since Python cannot create arb from type <class 'sympy.core.numbers.Zero'> evaluation_jac_X[i][j] = ft.arb(0) return evaluation_jac_X
def interval_difference_enclosure(a, b): if a in b: Difference = 'empty' else: try: Intersection = a.intersection(b) if Intersection.upper() >= a.upper(): Difference = ft.arb( 0.5 * a.lower() + 0.5 * Intersection.lower(), 0.5 * Intersection.lower() - 0.5 * a.lower()) elif Intersection.lower() <= a.lower(): Difference = ft.arb( 0.5 * a.upper() + 0.5 * Intersection.upper(), 0.5 * a.upper() - 0.5 * Intersection.upper()) else: Difference = a except: Difference = a return Difference
def arb_trace(M): """ Computes the trace of the matrix M """ # Matrix size n, m = arb_mat.nrows(M), arb_mat.ncols(M) # Computation res = arb(0) for i in range(n): res = res + M[i,i] return res
def intersection_of_bounded_with_unbounded_interval( x, boundary, infty ): #returns the intersection of x with [boundary, infty] where infty= 1 or -1 is corresponding to + infty or -infty respectevly Intersection = x if infty == 1: if x.upper() < boundary: Intersection = 'empty' elif x.upper() >= boundary and x.lower() < boundary: Intersection = ft.arb(0.5 * x.upper() + 0.5 * boundary, 0.5 * x.upper() - 0.5 * boundary) elif x.lower() >= boundary: Intersection = x else: if x.lower() > boundary: Intersection = 'empty' elif x.lower() <= boundary and x.upper() > boundary: Intersection = ft.arb((0.5 * x.lower()) + (0.5 * boundary), (0.5 * boundary) - (0.5 * x.lower())) elif x.upper() <= boundary: Intersection = x return Intersection
def intervals_multi( B1, B2 ): #does interval multiplication for B1,B2 if they are of different sign to avoid a bug in flint if type(B1) != type(ft.arb(1)): B1 = ft.arb(float(B1)) if type(B2) != type(ft.arb(1)): B2 = ft.arb(float(B2)) end_points = [ B1.lower() * B2.lower(), B1.lower() * B2.upper(), B1.upper() * B2.lower(), B1.upper() * B2.upper() ] if 0 not in B1 and 0 not in B2: lower_point = min(end_points) upper_point = max(end_points) the_product = ft.arb(0.5 * (upper_point + lower_point), 0.5 * (upper_point - lower_point)) else: the_product = B1 * B2 return the_product
def invertibility_of_a_matrix( M ): # M is interval matrix .. invertibility_of_a_matrix(M) returns 0 if we are sure that M is singular, 1 if we are sure that M invertable and -1 if we do not know.. The smaller width M has the more sure we are Answer = 3 L = [[ Mij.mid() if type(Mij) == type(ft.arb(1)) else ft.arb(float(Mij)) for Mij in Mi ] for Mi in M] T = [] try: T = (Matrix(L)).inv() except: Answer = 0 if Answer == 3: T_list = [[float(T[j, i]) for i in range(len(M))] for j in range(len(M))] Pre_cond = matrix_multi(T_list, M) E = ft.arb_mat(T_list) * ft.arb_mat(M) zero_eigenvalue_detected = 0 Gersh = gershgorin_circles(Pre_cond) for R in Gersh: if 0 in R: zero_eigenvalue_detected = 1 break if zero_eigenvalue_detected == 0: Answer = 1 if zero_eigenvalue_detected == 1: Answer = -1 #print('the inver: ', Answer) #print([[[Mij.lower(),Mij.upper()] for Mij in Mi] for Mi in Pre_cond ]) #print('Gersh=',[[R.lower(),R.upper()] for R in Gersh ]) #if 0 not in E.det(): # Answer=1 #else: # Answer = -1 return Answer #here is a problem
def test_sage_examples_slow(self): if 0: x = fmpz_poly([0, 1]) pol = x**10 + x**9 - x**7 - x**6 - x**5 - x**4 - x**3 + x + 1 root = arb("[1.17628081825991751 +/- 3.46e-18]") alpha = alg(_minpoly=pol, _enclosure=root) lhs = alpha**630 - 1 rhs_num = (alpha**315 - 1) * (alpha**210 - 1) * ( alpha**126 - 1)**2 * (alpha**90 - 1) * (alpha**3 - 1)**3 * ( alpha**2 - 1)**5 * (alpha - 1)**3 rhs_den = (alpha**35 - 1) * (alpha**15 - 1)**2 * ( alpha**14 - 1)**2 * (alpha**5 - 1)**6 * alpha**68 rhs = rhs_num / rhs_den assert lhs == rhs
def curve_tracer( P, B, jac, wth=0.001, wth2=1 ): #returns all list of boxes that contains smooth parts of a curve and it stops if the curve is smooth list_of_boxes = [B] smoothness = 1 regular_boxes = [] smoothness = 1 while len(list_of_boxes) != 0 and width(list_of_boxes[0]) > wth: membership = 1 eval_P = [evaluation_poly_list(Pi, list_of_boxes[0]) for Pi in P ] #checking whether the box contains a point of the curve for eval_Pi_at_B in eval_P: if 0 not in ft.arb(1) * (eval_Pi_at_B): membership = 0 if membership == 0: list_of_boxes.remove(list_of_boxes[0]) #print("empty") else: eval_jac = [[ evaluation_poly_list(jac_ij, list_of_boxes[0]) for jac_ij in Jac_i ] for Jac_i in jac] full_rankness = checking_full_rank(eval_jac) if full_rankness == 1 and width(list_of_boxes[0]) < wth2: #print([ [round(float(jac_ij.lower()),5),round(float(jac_ij.upper()),5)] for jac_ij in list_of_boxes[0] ]) #input() #print("regular") #input() regular_boxes.append(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: #print('width=',width(list_of_boxes[0])) #print('the box',[ [round(float(jac_ij.lower()),5),round(float(jac_ij.upper()),5)] for jac_ij in list_of_boxes[0] ]) #pprint(Matrix([ [[round(float(jac_ij.lower()),5),round(float(jac_ij.upper()),5)] for jac_ij in jac_i] for jac_i in eval_jac ])) #input() #print("we do not know") new_children = subdivide(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) list_of_boxes = list_of_boxes + new_children if len(list_of_boxes) != 0: smoothness = -1 #print(list_of_boxes[0]) return [regular_boxes, list_of_boxes]
def polyvalnd(M, X): evaluation = ft.arb(0) if len(X) == 1: N = [] for Mi in M: #to avoid the problem: sp.Integer * arb = not correct answer if type(Mi) != ft.arb: N.append(float(Mi)) else: N.append(Mi) evaluation = np.polynomial.polynomial.polyval(X[0], N) else: Y = copy(X[0:len(X) - 1]) N = copy([polyvalnd(Mi, Y) for Mi in M]) evaluation = np.polynomial.polynomial.polyval(X[len(X) - 1], N) return evaluation
def checking_regularity_of_sysyem1(P, B, jac, wth=0.2): M = [coefficient_matrix_list(Pi) for Pi in P] list_of_boxes = [B] smoothness = 1 regular_boxes = [] regular_volume = 0 empty_volume = 0 unknownvolume = n_volume(B) it = 0 while len(list_of_boxes) != 0 and width(list_of_boxes[0]) > wth: #print(width(list_of_boxes[0])) membership = 1 eval_P = [polyvalnd(Mi, list_of_boxes[0]) for Mi in M] for eval_Pi_at_B in eval_P: if 0 not in ft.arb(1) * (eval_Pi_at_B): membership = 0 break if membership == 0: empty_volume += n_volume(list_of_boxes[0]) unknownvolume = unknownvolume - n_volume(list_of_boxes[0]) regular_boxes.append(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: eval_jac = matrixval(jac, list_of_boxes[0]) full_rankness = invertibility_of_a_matrix(eval_jac) if full_rankness == 1: regular_volume += n_volume(list_of_boxes[0]) unknownvolume = unknownvolume - n_volume(list_of_boxes[0]) regular_boxes.append(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) else: new_children = subdivide(list_of_boxes[0]) list_of_boxes.remove(list_of_boxes[0]) list_of_boxes = list_of_boxes + new_children print("regular volume=", regular_volume) print("empty volume=", empty_volume) print("unknown volume=", unknownvolume) #print('Unknown box detected') #if len(list_of_boxes)!=0: #smoothness=-1 return regular_boxes
def test_guess(self): assert alg.guess(arb(123) / 3789, 1) == alg(123) / 3789 assert alg.guess(arb(5) + acb(2).sqrt() * 1j, 2) == alg(5) + alg(2).sqrt() * alg.i() assert alg.guess(arb(5) / 64 + acb(0, 37) / 256, 2) == alg(5) / 64 + (alg(37) / 256) * alg.i() orig = ctx.prec try: ctx.dps = 200 assert alg.guess(arb(2).root(6) + arb(3).root(5), 30) == alg(2).root(6) + alg(3).root(5) finally: ctx.prec = orig assert alg.guess(arb("3.1415926535897932 +/- 1e-5"), 1, check=False) == alg(22) / 7 assert alg.guess(arb("3.1415926535897932 +/- 1e-8"), 1, check=False) == alg(355) / 113
def evaluation_exp(expr, B, X): expr_int = expr n = len(B_Ball) n = int((n + 1) / 2) for i in range(n): expr_int = expr_int.replace("x" + str(i + 1), "B_f[" + str(i) + "]") for i in range(n, len(X) - 1): expr_int = expr_int.replace("r" + str(i + 3 - n), "B_f[" + str(i) + "]") expr_int = expr_int.replace("t", "B_f[" + str(len(X) - 1) + "]") f = open("evaluation_file.py", "w") f.write("import flint as ft\n") f.write("import draft as d \n") f.write("from sympy.parsing.sympy_parser import parse_expr \n") f.write("from sympy import * \n") f.write("from numpy import * \n") f.write("import operator \n") f.write("def eval_func(): \n") for i in range(n): f.write(" x" + str(i + 1) + "=Symbol(\"" + str(X[i]) + "\" )\n") for i in range(n, len(X) - 1): f.write(" r" + str(i - n + 3) + "=Symbol(\"" + str(X[i]) + "\" )\n") f.write(" t" + "=Symbol(\"" + str(X[len(X) - 1]) + "\" )\n") f.write(" B=" + str(B) + "\n") f.write(" f=srepr( parse_expr ( \" " + str(expr) + " \") ) \n") f.write(" B_f=[ d.ftconstructor(Bi[0],Bi[1]) for Bi in B ] \n") for i in range(len(X)): f.write(" f=f.replace(\"Symbol(\'"+str(X[i])+\ "\')\", \" B_f[ "+str(i) +"] \") \n") f.write(" f=f.replace(\"Add\",\"d.sevr_add\")\n") f.write(" f=f.replace(\"Mul\",\"d.sevr_mul\")\n") f.write(" f=f.replace(\"Pow\",\"d.power_interval\")\n") f.write(" f=f.replace(\"Integer\",\"int\")\n") f.write(" f=f.replace(\"Float\",\"float\")\n") f.write(" f=f.replace(\", precision=53\", \"\")\n") #f.write("B_f=[ d.interv(d.ftconstructor(Bi[0],Bi[1])) for Bi in B ] \n" ) f.write(" return eval(f) \n") f.close() #from evaluation_file import eval_func answer = ft.arb(eval_func()) return [float(answer.lower()), float(answer.upper())]
def gershgorin_circles(M): #returns Gershgorin circles of an intrival matrix M radius = [0] * (len(M)) for i in range(len(M)): for j in range(len(M)): if i != j: radius[i] = radius[i] + abs_value(M[i][j]) T = [ ] #Now we have that radius is the list of the radiuses of The gershgorin circles i = 0 for i in range(len(radius)): m_lower = float((M[i][i]).lower()) m_upper = float((M[i][i]).upper()) r_upper = float((radius[i]).upper()) gershgorin_lower = m_upper + r_upper gershgorin_upper = m_lower - r_upper T.append( ft.arb(0.5 * (gershgorin_upper + gershgorin_lower), 0.5 * (gershgorin_upper - gershgorin_lower))) return T
def plotadaptive(ax, f, xab, yab, goal=0.1, yrange=None, color=None, label=None, hatch=None, alpha=1.0): queue = [arb(0.5 * (xab[0] + xab[1]), 0.5 * (xab[1] - xab[0]))] top = 0.0 bot = 0.0 while queue: X = queue.pop() Y = f(X) xmid = float(arb(X.mid())) xrad = float(arb(X.rad())) ymid = float(arb(Y.mid())) yrad = float(arb(Y.rad())) if yrad < goal: top = max(top, (ymid + yrad) * 1.2) bot = min(bot, (ymid - yrad) * 1.2) ax.add_patch( patches.Rectangle((xmid - xrad, ymid - yrad), 2 * xrad, 2 * yrad, color=color, alpha=alpha, hatch=hatch)) elif xrad > goal * 0.001: xa = arb(xmid - xrad * 0.5, xrad * 0.5) xb = arb(xmid + xrad * 0.5, xrad * 0.5) queue += [xa, xb] #ax.add_patch(patches.Rectangle((xmid-xrad, -1e50), 2*xrad, 1e50, color=color, alpha=alpha, hatch=hatch)) ax.set_xlim([xab[0], xab[1]]) if yab is None: ax.set_ylim([bot, top]) else: ax.set_ylim(yab) patch1 = mpatches.Patch(color=color, label=label, alpha=alpha, hatch=hatch) legends.append(patch1)
def test_fmpz_poly(): Z = flint.fmpz_poly assert Z() == Z([]) assert Z() == Z([0]) assert Z() == Z([0, flint.fmpz(0), 0]) assert Z() == Z([0, 0, 0]) assert Z() != Z([1]) assert Z([1]) == Z([1]) assert Z([1]) == Z([flint.fmpz(1)]) assert Z(Z([1, 2])) == Z([1, 2]) for ztype in [int, long, flint.fmpz]: assert Z([1, 2, 3]) + ztype(5) == Z([6, 2, 3]) assert ztype(5) + Z([1, 2, 3]) == Z([6, 2, 3]) assert Z([1, 2, 3]) - ztype(5) == Z([-4, 2, 3]) assert ztype(5) - Z([1, 2, 3]) == Z([4, -2, -3]) assert Z([1, 2, 3]) * ztype(5) == Z([5, 10, 15]) assert ztype(5) * Z([1, 2, 3]) == Z([5, 10, 15]) assert Z([11, 6, 2]) // ztype(5) == Z([2, 1]) assert ztype(5) // Z([-2]) == Z([-3]) assert ztype(5) // Z([1, 2]) == 0 assert Z([11, 6, 2]) % ztype(5) == Z([1, 1, 2]) assert ztype(5) % Z([-2]) == Z([-1]) assert ztype(5) % Z([1, 2]) == 5 assert Z([1, 2, 3])**ztype(0) == 1 assert Z([1, 2, 3])**ztype(1) == Z([1, 2, 3]) assert Z([1, 2, 3])**ztype(2) == Z([1, 4, 10, 12, 9]) assert +Z([1, 2]) == Z([1, 2]) assert -Z([1, 2]) == Z([-1, -2]) assert raises(lambda: Z([1, 2, 3])**-1, (OverflowError, ValueError)) assert raises(lambda: Z([1, 2, 3])**Z([1, 2]), TypeError) assert raises(lambda: Z([1, 2]) // Z([]), ZeroDivisionError) assert raises(lambda: Z([]) // Z([]), ZeroDivisionError) assert raises(lambda: Z([1, 2]) % Z([]), ZeroDivisionError) assert raises(lambda: divmod(Z([1, 2]), Z([])), ZeroDivisionError) assert Z([]).degree() == -1 assert Z([]).length() == 0 p = Z([1, 2]) assert p.length() == 2 assert p.degree() == 1 assert p[0] == 1 assert p[1] == 2 assert p[2] == 0 assert p[-1] == 0 assert raises(lambda: p.__setitem__(-1, 1), ValueError) p[0] = 3 assert p[0] == 3 p[4] = 7 assert p.degree() == 4 assert p[4] == 7 assert p[3] == 0 p[4] = 0 assert p.degree() == 1 assert p.coeffs() == [3, 2] assert Z([]).coeffs() == [] assert bool(Z([])) == False assert bool(Z([1])) == True ctx.pretty = False assert repr(Z([1, 2])) == "fmpz_poly([1, 2])" ctx.pretty = True assert str(Z([1, 2])) == "2*x + 1" p = Z([3, 4, 5]) assert p(2) == 31 assert p(flint.fmpq(2, 3)) == flint.fmpq(71, 9) assert p(Z([1, -1])) == Z([12, -14, 5]) assert p(flint.fmpq_poly([2, 3], 5)) == flint.fmpq_poly([27, 24, 9], 5) assert p(flint.arb("1.1")).overlaps(flint.arb("13.45")) assert p(flint.acb("1.1", "1.2")).overlaps(flint.acb("6.25", "18.00"))
def build(self, entries): from flint import ctx, arb, acb from . import formulas digits = 30 eval_digits = 40 count = 0 excluded = set([Parentheses, Brackets, Braces]) ctx.dps = eval_digits # for local manipulations # expr -> arb/acb value expressions_values = {} # expr -> entries containing expr (with repetitions!) expressions_entries = {} def insert(expr, val, eid): expressions_values[expr] = val if expr in expressions_entries: expressions_entries[expr] += (eid, ) else: expressions_entries[expr] = (eid, ) def insert_real(expr, val, eid): if val == 0: insert(expr, val, eid) if val != 0: if val < 0: insert(Neg(expr), -val, eid) else: insert(expr, val, eid) # arb or acb def insert_arb(expr, val, eid): if isinstance(val, arb): insert_real(expr, val, eid) else: a = val.real b = val.imag if a != 0: insert_real(Re(expr), a, eid) if b != 0: insert_real(Im(expr), b, eid) if a != 0 and b != 0: insert_real(Abs(expr), abs(val), eid) insert_real(Arg(expr), val.arg(), eid) def insert_expr(expr, eid): if expr == Exp: insert_real(Expr("Indirect use of e: Exp(...)"), ConstE.n(eval_digits, as_arb=True), eid) if expr.head() not in excluded: if expr in expressions_values: val = expressions_values[expr] else: try: val = expr.n(eval_digits, as_arb=True) except (ValueError, NotImplementedError): return insert_arb(expr, val, eid) # todo: second passes for subexpressions, symbolic equalities? print("Evaluating tables...") for entry in entries: eid = entry.id() for expr, val in table_values(entry): if expr.head() == NearestDecimal: expr, numdigits = expr.args() if numdigits.is_integer() and int(numdigits) >= digits: val = val.n(eval_digits, as_arb=True) # todo ... insert_arb(expr, val, eid) print("Evaluating declared constant values...") for entry in entries: # only look for constant equations variables = entry.get_arg_with_head(Variables) if variables is not None: continue formula = entry.get_arg_with_head(Formula) if formula is None: continue eid = entry.id() content = formula.args()[0] if content.head() == EqualNearestDecimal: expr, val, numdigits = content.args() if numdigits.is_integer() and int(numdigits) >= digits: print(expr, val, numdigits) val = val.n(eval_digits, as_arb=True) insert_arb(expr, val, eid) print("Evaluating expressions...") for entry in entries: eid = entry.id() for expr in entry.subexpressions(): insert_expr(expr, eid) print("Evaluating tables, 2...") for entry in entries: eid = entry.id() for expr, val in table_values(entry): if expr.head() != NearestDecimal: insert_expr(expr, eid) insert_expr(val, eid) if val in expressions_values and expr not in expressions_values: insert(expr, expressions_values[val], eid) # todo: handle complex numbers (need to keep symbolics above?) # insert symbolic equations print("Adding symbolic equalities...") for entry in entries: # only look for constant equations variables = entry.get_arg_with_head(Variables) if variables is not None: continue formula = entry.get_arg_with_head(Formula) if formula is None: continue eid = entry.id() content = formula.args()[0] if content.head() == Equal: for arg in content.args(): if arg in expressions_values: for arg2 in content.args(): if arg2 not in expressions_values: print(" ", arg2, " = ", arg) insert(arg2, expressions_values[arg], eid) break print("Building final tables...") # expr -> str(expr) ? expressions_values = dict( (str(expr), val) for (expr, val) in expressions_values.items()) expressions_entries = dict( (str(expr), val) for (expr, val) in expressions_entries.items()) # xxx: missing .is_int / .is_integer method def _arb_isint(x): return arb(x) == arb(x).floor() or arb(x) > 10**digits integer_values = set() # convert arb/acb values to decimal keys for expr in expressions_values: val = expressions_values[expr] # save integerness isint = _arb_isint(val) if val == 0: val = "0.0" + "0" * (digits - 2) else: val = val.str(digits, radius=False) expressions_values[expr] = val if isint: integer_values.add(val) # reverse the table values_expressions = {} # some rankings values_frequency = {} values_diversity = {} for expr, val in expressions_values.items(): #if val in values_frequency: # values_frequency[val] += len(expressions_entries[expr]) #else: # values_frequency[val] = len(expressions_entries[expr]) if val in values_diversity: values_diversity[val] += 1 else: values_diversity[val] = 1 if val in values_expressions: values_expressions[val].add(expr) else: values_expressions[val] = set([expr]) for val, expressions in values_expressions.items(): val_entries = set() for expr in expressions: for ent in expressions_entries[expr]: val_entries.add(ent) values_frequency[val] = len(val_entries) values_ordered = list(values_expressions.keys()) values_ordered.sort(key=lambda d: arb(d)) values_ordered_frequency = list(values_expressions.keys()) values_ordered_frequency.sort(key=lambda d: values_frequency[d], reverse=True) values_ordered_diversity = list(values_expressions.keys()) values_ordered_diversity.sort(key=lambda d: values_diversity[d], reverse=True) self.integer_values = integer_values self.values_expressions = values_expressions self.values_frequency = values_frequency self.values_diversity = values_diversity self.values_ordered = values_ordered self.values_ordered_frequency = values_ordered_frequency self.values_ordered_diversity = values_ordered_diversity self.expressions_values = expressions_values self.expressions_entries = expressions_entries