def assertIsReduced(t, m_path, x_name, eps_name): M = fuchsia.import_matrix_from_file(m_path) x = SR.var(x_name) eps = SR.var(eps_name) pranks = fuchsia.singularities(M, x).values() t.assertEqual(pranks, [0]*len(pranks)) t.assertTrue(eps not in (M/eps).simplify_rational().variables())
def test_normalize_3(t): # Test with non-zero normalized eigenvalues x = SR.var("x") e = SR.var("epsilon") M = matrix([[(1 - e) / x, 0], [0, (1 + e) / 3 / x]]) with t.assertRaises(FuchsiaError): N, T = normalize(M, x, e)
def test_factorize_1(t): x = SR.var("x") e = SR.var("epsilon") M = matrix([[1 / x, 0, 0], [0, 2 / x, 0], [0, 0, 3 / x]]) * e M = transform(M, x, matrix([[1, 1, 0], [0, 1, 0], [1 + 2 * e, 0, e]])) F, T = factorize(M, x, e) F = F.simplify_rational() for f in F.list(): t.assertEqual(limit_fixed(f, e, 0), 0)
def test_is_normalized_1(t): x = SR.var("x") e = SR.var("epsilon") t.assertFalse(is_normalized(matrix([[1 / x / 2]]), x, e)) t.assertFalse(is_normalized(matrix([[-1 / x / 2]]), x, e)) t.assertTrue(is_normalized(matrix([[1 / x / 3]]), x, e)) t.assertFalse(is_normalized(matrix([[x]]), x, e)) t.assertFalse(is_normalized(matrix([[1 / x**2]]), x, e)) t.assertTrue (is_normalized( \ matrix([[(e+SR(1)/3)/x-SR(1)/2/(x-1)]]), x, e))
def test_normalize_1(t): # Test with apparent singularities at 0 and oo, but not at 1. x = SR.var("x") M = matrix([[1 / x, 5 / (x - 1), 0, 6 / (x - 1)], [0, 2 / x, 0, 0], [0, 0, 3 / x, 7 / (x - 1)], [6 / (x - 1), 0, 0, 1 / x]]) N, T = normalize(M, x, SR.var("epsilon")) N = N.simplify_rational() t.assertEqual(N, transform(M, x, T).simplify_rational()) for point, prank in singularities(N, x).iteritems(): R = matrix_c0(N, x, point, prank) evlist = R.eigenvalues() t.assertEqual(evlist, [0] * len(evlist))
def place_list(self, mx, Mx, frac=1, mark_origin=True): """ return a tuple of 1. values that are all the integer multiple of <frac>*self.numerical_value between mx and Mx 2. the multiple of the basis unit. Give <frac> as literal real. Recall that python evaluates 1/2 to 0. If you pass 0.5, it will be converted back to 1/2 for a nice display. """ try: # If the user enters "0.5", it is converted to 1/2 frac = Rational(frac) except TypeError: pass if frac == 0: raise ValueError( "frac is zero in AxesUnit.place_list(). Maybe you ignore that python evaluates 1/2 to 0 ? (writes literal 0.5 instead) \n Or are you trying to push me in an infinite loop ?" ) l = [] k = SR.var("TheTag") for x in MultipleBetween(frac * self.numerical_value, mx, Mx, mark_origin): if self.latex_symbol == "": l.append((x, "$" + latex(x) + "$")) else: pos = (x / self.numerical_value) * k # This risks to be Sage-version dependent. text = "$" + latex(pos).replace("TheTag", self.latex_symbol) + "$" l.append((x, text)) return l
def __init__(self,dof,name,shortname=None): self.dof = int(dof) self.name = name if shortname == None : self.shortname = name.replace(' ','_').replace('.','_') else : self.shortname = shortname.replace(' ','_').replace('.','_') for i in range(1 ,1 +dof): var('q'+str(i),domain=RR) (alpha , a , d , theta) = SR.var('alpha,a,d,theta',domain=RR) default_params_dh = [ alpha , a , d , theta ] default_T_dh = matrix( \ [[ cos(theta), -sin(theta)*cos(alpha), sin(theta)*sin(alpha), a*cos(theta) ], \ [ sin(theta), cos(theta)*cos(alpha), -cos(theta)*sin(alpha), a*sin(theta) ], \ [ 0.0, sin(alpha), cos(alpha), d ] ,[ 0.0, 0.0, 0.0, 1.0] ] ) #g_a = SR.var('g_a',domain=RR) g_a = 9.81 self.grav = matrix([[0.0],[0.0],[-g_a]]) self.params_dh = default_params_dh self.T_dh = default_T_dh self.links_dh = [] self.motors = [] self.Imzi = [] self._gensymbols()
def test_normalize_4(t): # Test with non-zero normalized eigenvalues x, e = SR.var("x eps") M = matrix([[1 / x / 2, 0], [0, 0]]) with t.assertRaises(FuchsiaError): N, T = normalize(M, x, e)
def assertReductionWorks(t, filename): M = import_matrix_from_file(filename) x, eps = SR.var("x eps") t.assertIn(x, M.variables()) M_pranks = singularities(M, x).values() t.assertNotEqual(M_pranks, [0] * len(M_pranks)) #1 Fuchsify m, t1 = simplify_by_factorization(M, x) Mf, t2 = fuchsify(m, x) Tf = t1 * t2 t.assertTrue((Mf - transform(M, x, Tf)).simplify_rational().is_zero()) Mf_pranks = singularities(Mf, x).values() t.assertEqual(Mf_pranks, [0] * len(Mf_pranks)) #2 Normalize t.assertFalse(is_normalized(Mf, x, eps)) m, t1 = simplify_by_factorization(Mf, x) Mn, t2 = normalize(m, x, eps) Tn = t1 * t2 t.assertTrue((Mn - transform(Mf, x, Tn)).simplify_rational().is_zero()) t.assertTrue(is_normalized(Mn, x, eps)) #3 Factorize t.assertIn(eps, Mn.variables()) m, t1 = simplify_by_factorization(Mn, x) Mc, t2 = factorize(m, x, eps, seed=3) Tc = t1 * t2 t.assertTrue((Mc - transform(Mn, x, Tc)).simplify_rational().is_zero()) t.assertNotIn(eps, (Mc / eps).simplify_rational().variables())
def test_reduce_at_one_point_1(t): x = SR.var("x") M0 = matrix([[1 / x, 4, 0, 5], [0, 2 / x, 0, 0], [0, 0, 3 / x, 6], [0, 0, 0, 4 / x]]) u = matrix([[0, Rational((3, 5)), Rational((4, 5)), 0], [Rational((5, 13)), 0, 0, Rational((12, 13))]]) M1 = transform(M0, x, balance(u.transpose() * u, 0, 1, x)) M1 = M1.simplify_rational() u = matrix([[8, 0, 15, 0]]) / 17 M2 = transform(M1, x, balance(u.transpose() * u, 0, 2, x)) M2 = M2.simplify_rational() M2_sing = singularities(M2, x) t.assertIn(0, M2_sing) t.assertEqual(M2_sing[0], 2) M3, T23 = reduce_at_one_point(M2, x, 0, 2) M3 = M3.simplify_rational() t.assertEqual(M3, transform(M2, x, T23).simplify_rational()) M3_sing = singularities(M3, x) t.assertIn(0, M3_sing) t.assertEqual(M3_sing[0], 1) M4, T34 = reduce_at_one_point(M3, x, 0, 1) M4 = M4.simplify_rational() t.assertEqual(M4, transform(M3, x, T34).simplify_rational()) M4_sing = singularities(M4, x) t.assertIn(0, M4_sing) t.assertEqual(M4_sing[0], 0)
def test_import_export_mathematica(t): a, b = SR.var("v1 v2") M = matrix([[1, a, b], [a + b, Rational((2, 3)), a / b]]) fout = StringIO() export_matrix_mathematica(fout, M) MM = import_matrix_mathematica(StringIO(fout.getvalue())) t.assertEqual(M, MM)
def taylor_processor_factored(new_ring, Phi, scalar, alpha, I, omega): k = alpha.nrows() - 1 tau = SR.var('tau') y = [SR('y%d' % i) for i in range(k + 1)] R = PolynomialRing(QQ, len(y), y) beta = [a * Phi for a in alpha] ell = len(I) def f(i): if i == 0: return QQ(scalar) * y[0] * exp(tau * omega[0]) elif i in I: return tau / (1 - exp(tau * omega[i])) else: return 1 / (1 - y[i] * exp(tau * omega[i])) H = [ f(i).series(tau, ell + 1).truncate().collect(tau) for i in range(k + 1) ] for i in range(k + 1): H[i] = [H[i].coefficient(tau, j) for j in range(ell + 1)] r = [] # Get coefficient of tau^ell in prod(H) for w in NonnegativeCompositions(ell, k + 1): r = prod( CyclotomicRationalFunction.from_split_expression(H[i][ w[i]], y, R).monomial_substitution(new_ring, beta) for i in range(k + 1)) yield r
def padically_evaluate_regular(self, datum): T = datum.toric_datum if not T.is_regular(): raise ValueError('Can only processed regular toric data') M = Set(range(T.length())) q = SR.var('q') alpha = {} for I in Subsets(M): F = [T.initials[i] for i in I] V = SubvarietyOfTorus(F, torus_dim=T.ambient_dim) alpha[I] = V.count() def cat(u, v): return vector(list(u) + list(v)) for I in Subsets(M): cnt = sum((-1)**len(J) * alpha[I + J] for J in Subsets(M - I)) if not cnt: continue P = DirectProductOfPolyhedra(T.polyhedron, StrictlyPositiveOrthant(len(I))) it = iter(identity_matrix(ZZ, len(I)).rows()) ieqs = [] for i in M: ieqs.append( cat( vector(ZZ, (0, )), cat( vector(ZZ, T.initials[i].exponents()[0]) - vector(ZZ, T.lhs[i].exponents()[0]), next(it) if i in I else zero_vector(ZZ, len(I))))) if not ieqs: ieqs = [vector(ZZ, (T.ambient_dim + len(I) + 1) * [0])] Q = Polyhedron(ieqs=ieqs, base_ring=QQ, ambient_dim=T.ambient_dim + len(I)) foo, ring = symbolic_to_ratfun( cnt * (q - 1)**len(I) / q**(T.ambient_dim), [var('t'), var('q')]) corr_cnt = CyclotomicRationalFunction.from_laurent_polynomial( foo, ring) Phi = matrix([ cat(T.integrand[0], zero_vector(ZZ, len(I))), cat(T.integrand[1], vector(ZZ, len(I) * [-1])) ]).transpose() sm = RationalSet([P.intersection(Q)]).generating_function() for z in sm.monomial_substitution(QQ['t', 'q'], Phi): yield corr_cnt * z
def test_transform_2(t): # transform(transform(M, x, I), x, I^-1) == M x = SR.var("x") M = randpolym(x, 2) T = randpolym(x, 2) invT = T.inverse() M1 = transform(M, x, T) M2 = transform(M1, x, invT) t.assertEqual(M2.simplify_rational(), M)
def test_fuchsify_by_blocks_03(test): x, eps = SR.var("x eps") m = matrix([ [eps / x, 0, 0], [1 / x**2, 2 * eps / x, 0], [1 / x**2, 2 / x**2, 3 * eps / x], ]) b = [(0, 1), (1, 1), (2, 1)] test.assert_fuchsify_by_blocks_works(m, b, x, eps)
def test_fuchsify_by_blocks_05(test): x, eps = SR.var("x eps") m = matrix([ [eps / x, 0, 0], [0, 2 * eps / x, -eps / x], [x**2, 0, 3 * eps / x], ]) b = [(0, 1), (1, 2)] test.assert_fuchsify_by_blocks_works(m, b, x, eps)
def test_normalize_5(t): # An unnormalizable example by A. A. Bolibrukh x, e = SR.var("x eps") b = import_matrix_from_file("test/data/bolibrukh.mtx") f, ft = fuchsify(b, x) f_pranks = singularities(f, x).values() t.assertEqual(f_pranks, [0] * len(f_pranks)) with t.assertRaises(FuchsiaError): n, nt = normalize(f, x, e)
def get_background_graphic(self, **bdry_options): r""" Return a graphic object that makes the model easier to visualize. For the hyperboloid model, the background object is the hyperboloid itself. EXAMPLES:: sage: H = HyperbolicPlane().HM().get_background_graphic() """ from sage.plot.plot3d.all import plot3d from sage.all import SR hyperboloid_opacity = bdry_options.get('hyperboloid_opacity', .1) z_height = bdry_options.get('z_height', 7.0) x_max = sqrt((z_height ** 2 - 1) / 2.0) x = SR.var('x') y = SR.var('y') return plot3d((1 + x ** 2 + y ** 2).sqrt(), (x, -x_max, x_max), (y,-x_max, x_max), opacity=hyperboloid_opacity, **bdry_options)
def test_balance_2(t): # balance(P, x1, oo, x)*balance(P, oo, x1, x) == I x = SR.var("x") P = matrix([[1, 1], [0, 0]]) x1 = randint(-10, 10) b1 = balance(P, x1, oo, x) b2 = balance(P, oo, x1, x) t.assertEqual((b1 * b2).simplify_rational(), identity_matrix(P.nrows())) t.assertEqual((b2 * b1).simplify_rational(), identity_matrix(P.nrows()))
def test_fuchsify_by_blocks_06(test): x, eps = SR.var("x eps") m = matrix( [[eps / (x - 1), 0, 0], [(x**3 + x**2 - 3 * x - 3) / (2 * x**3 - 2 * x**2 - x + 1), 2 * eps / (x - 3), 0], [ -(x**3 + 3 * x**2 - 3 * x + 2) / (2 * x**3 + x**2 - 2 * x) + 2 * (x**3 - x**2 - x + 1) / (2 * x + 1), -3 * (x**3 + x - 1) / (3 * x**3 + x - 2), 4 * eps / (x - 5) ]]) b = [(0, 1), (1, 1), (2, 1)] test.assert_fuchsify_by_blocks_works(m, b, x, eps)
def assertReductionWorks(test, filename, fuchsian=False): m = import_matrix_from_file(filename) x, eps = SR.var("x eps") test.assertIn(x, m.variables()) if not fuchsian: m_pranks = singularities(m, x).values() test.assertNotEqual(m_pranks, [0]*len(m_pranks)) mt, t = epsilon_form(m, x, eps) test.assertTrue((mt-transform(m, x, t)).simplify_rational().is_zero()) test.assertTrue(is_fuchsian(mt, x)) test.assertTrue(is_normalized(mt, x, eps)) test.assertNotIn(eps, (mt/eps).simplify_rational().variables())
def test_block_triangular_form_3(t): m = matrix([ [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0], [0, 0, 0, 1] ]) mt, tt, b = block_triangular_form(m) x = SR.var("dummy") t.assertEqual(mt, transform(m, x, tt)) t.assertEqual(matrix([ [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1] ]), mt)
def assertNormalizeBlocksWorks(test, filename): x, eps = SR.var("x eps") m = import_matrix_from_file(filename) test.assertIn(x, m.variables()) test.assertIn(eps, m.variables()) test.assertFalse(is_normalized(m, x, eps)) m_pranks = singularities(m, x).values() test.assertNotEqual(m_pranks, [0] * len(m_pranks)) m, t, b = block_triangular_form(m) mt, tt = reduce_diagonal_blocks(m, x, eps, b=b) t = t * tt test.assertTrue( (mt - transform(m, x, t)).simplify_rational().is_zero()) test.assertTrue(are_diagonal_blocks_reduced(mt, b, x, eps))
def test_simplify_by_jordanification(t): x = SR.var("x") M = matrix( [[4 / (x + 1), -1 / (6 * x * (x + 1)), -1 / (3 * x * (x + 1))], [ 6 * (13 * x + 6) / (x * (x + 1)), -5 * (x + 3) / (3 * x * (x + 1)), 2 * (x - 6) / (3 * x * (x + 1)) ], [ -63 * (x - 1) / (x * (x + 1)), (5 * x - 9) / (6 * x * (x + 1)), -(x - 18) / (3 * x * (x + 1)) ]]).simplify_rational() MM, T = simplify_by_jordanification(M, x) MM = MM.simplify_rational() t.assertEqual(MM, transform(M, x, T).simplify_rational()) t.assertLess(matrix_complexity(MM), matrix_complexity(M))
def test_fuchsify_2(t): x = SR.var("x") M = matrix([[0, 1 / x / (x - 1), 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) u = matrix([[6, 3, 2, 0]]) / 7 P = u.transpose() * u M = balance_transform(M, P, 1, 0, x).simplify_rational() M = balance_transform(M, P, 1, 0, x).simplify_rational() M = balance_transform(M, P, 1, 0, x).simplify_rational() M = balance_transform(M, P, 1, 0, x).simplify_rational() M = balance_transform(M, P, 1, 0, x).simplify_rational() MM, T = fuchsify(M, x) MM = MM.simplify_rational() t.assertEqual(MM, transform(M, x, T).simplify_rational()) pranks = singularities(MM, x).values() t.assertEqual(pranks, [0] * len(pranks))
def test_balance_transform_1(t): x = SR.var("x") M = randpolym(x, 2) P = matrix([[1, 1], [0, 0]]) x1 = randint(-10, 10) x2 = randint(20, 30) b1 = balance(P, x1, x2, x) M1 = balance_transform(M, P, x1, x2, x) M2 = transform(M, x, balance(P, x1, x2, x)) t.assertEqual(M1.simplify_rational(), M2.simplify_rational()) M1 = balance_transform(M, P, x1, oo, x) M2 = transform(M, x, balance(P, x1, oo, x)) t.assertEqual(M1.simplify_rational(), M2.simplify_rational()) M1 = balance_transform(M, P, oo, x2, x) M2 = transform(M, x, balance(P, oo, x2, x)) t.assertEqual(M1.simplify_rational(), M2.simplify_rational())
def test_fuchsify_1(t): x = SR.var("x") M = matrix([[1 / x, 5, 0, 6], [0, 2 / x, 0, 0], [0, 0, 3 / x, 7], [0, 0, 0, 4 / x]]) u = matrix([[0, Rational((3, 5)), Rational((4, 5)), 0], [Rational((5, 13)), 0, 0, Rational((12, 13))]]) M = transform(M, x, balance(u.transpose() * u, 0, 1, x)) M = M.simplify_rational() u = matrix([[8, 0, 15, 0]]) / 17 M = transform(M, x, balance(u.transpose() * u, 0, 2, x)) M = M.simplify_rational() Mx, T = fuchsify(M, x) Mx = Mx.simplify_rational() t.assertEqual(Mx, transform(M, x, T).simplify_rational()) pranks = singularities(Mx, x).values() t.assertEqual(pranks, [0] * len(pranks))
def taylor_processor_naive(new_ring, Phi, scalar, alpha, I, omega): k = alpha.nrows() - 1 tau = SR.var('tau') y = [SR('y%d' % i) for i in range(k + 1)] R = PolynomialRing(QQ, len(y), y) beta = [a * Phi for a in alpha] def f(i): if i == 0: return QQ(scalar) * y[0] * exp(tau * omega[0]) elif i in I: return 1 / (1 - exp(tau * omega[i])) else: return 1 / (1 - y[i] * exp(tau * omega[i])) h = prod(f(i) for i in range(k + 1)) # Get constant term of h as a Laurent series in tau. g = h.series(tau, 1).truncate().collect(tau).coefficient(tau, 0) g = g.factor() if g else g yield CyclotomicRationalFunction.from_split_expression( g, y, R).monomial_substitution(new_ring, beta)
def test_block_triangular_form_4(t): M = matrix([ [1, 2, 3, 0, 0, 0], [4, 5, 6, 0, 0, 0], [7, 8, 9, 0, 0, 0], [2, 0, 0, 1, 2, 0], [0, 2, 0, 3, 4, 0], [0, 0, 2, 0, 0, 1] ]) x = SR.var("dummy") T = matrix.identity(6)[random.sample(xrange(6), 6),:] M = transform(M, x, T) MM, T, B = block_triangular_form(M) t.assertEqual(MM, transform(M, x, T)) t.assertEqual(sorted(s for o, s in B), [1, 2, 3]) for o, s in B: for i in xrange(s): for j in xrange(s): MM[o + i, o + j] = 0 for i in xrange(6): for j in xrange(i): MM[i, j] = 0 t.assertEqual(MM, matrix(6))
def test_fuchsify_by_blocks_07(test): x, eps = SR.var("x ep") m = matrix([[0, 0], [1 / (x**2 - x + 1)**2, 0]]) b = [(0, 1), (1, 1)] test.assert_fuchsify_by_blocks_works(m, b, x, eps)
def elliptic_cm_form(E, n, prec, aplist_only=False, anlist_only=False): """ Return q-expansion of the CM modular form associated to the n-th power of the Grossencharacter associated to the elliptic curve E. INPUT: - E -- CM elliptic curve - n -- positive integer - prec -- positive integer - aplist_only -- return list only of ap for p prime - anlist_only -- return list only of an OUTPUT: - power series with integer coefficients EXAMPLES:: sage: from psage.modform.rational.special import elliptic_cm_form sage: f = CuspForms(121,4).newforms(names='a')[0]; f q + 8*q^3 - 8*q^4 + 18*q^5 + O(q^6) sage: E = EllipticCurve('121b') sage: elliptic_cm_form(E, 3, 7) q + 8*q^3 - 8*q^4 + 18*q^5 + O(q^7) sage: g = elliptic_cm_form(E, 3, 100) sage: g == f.q_expansion(100) True """ if not E.has_cm(): raise ValueError, "E must have CM" n = ZZ(n) if n <= 0: raise ValueError, "n must be positive" prec = ZZ(prec) if prec <= 0: return [] elif prec <= 1: return [ZZ(0)] elif prec <= 2: return [ZZ(0), ZZ(1)] # Derive formula for sum of n-th powers of roots a,p,T = SR.var('a,p,T') roots = (T**2 - a*T + p).roots(multiplicities=False) s = sum(alpha**n for alpha in roots).simplify_full() # Create fast callable expression from formula g = fast_callable(s.polynomial(ZZ)) # Compute aplist for the curve v = E.aplist(prec) # Use aplist to compute ap values for the CM form attached to n-th # power of Grossencharacter. P = prime_range(prec) if aplist_only: # case when we only want the a_p (maybe for computing an # L-series via Euler product) return [g(ap,p) for ap,p in zip(v,P)] # Default cause where we want all a_n anlist = [ZZ(0),ZZ(1)] + [None]*(prec-2) for ap,p in zip(v,P): anlist[p] = g(ap,p) # Fill in the prime power a_{p^r} for r >= 2. N = E.conductor() for p in P: prm2 = 1 prm1 = p pr = p*p pn = p**n e = 1 if N%p else 0 while pr < prec: anlist[pr] = anlist[prm1] * anlist[p] if e: anlist[pr] -= pn * anlist[prm2] prm2 = prm1 prm1 = pr pr *= p # fill in a_n with n divisible by at least 2 primes extend_multiplicatively_generic(anlist) if anlist_only: return anlist f = Integer_list_to_polynomial(anlist, 'q') return ZZ[['q']](f, prec=prec)