Same setup as before : x = var('x', domain='positive')
f(x) = (3/174465461165747500*pi*(-1750000*I*pi*x^3 - 31250000*(224*pi + 45*sqrt(448*pi + 2025) + 2025)*x^2 + 17500000000000000*I*pi*x)*sqrt(92821652156334811582567480952850314403/10*pi^2/(224*pi + 45*sqrt(448*pi + 2025) + 2025) + 98489794142024498175862287197250000*pi*sqrt(448*pi + 2025)/(224*pi + 45*sqrt(448*pi + 2025) + 2025) + 7713517620898636162808584411766250000*pi/(224*pi + 45*sqrt(448*pi + 2025) + 2025) + 659225266976959904108326638192187500*sqrt(448*pi + 2025)/(224*pi + 45*sqrt(448*pi + 2025) + 2025) + 29665137013963195684874698718648437500/(224*pi + 45*sqrt(448*pi + 2025) + 2025))/(63*pi^2*x^4 - (504000*I*pi^2 + 67500*I*pi*(sqrt(448*pi + 2025) + 45))*x^3 - 3000000*(560224*pi^2 + 45*pi*(sqrt(448*pi + 2025) + 45))*x^2 + 8400000000000000000000*pi^2 - (-5040000000000000*I*pi^2 - 675000000000000*I*pi*(sqrt(448*pi + 2025) + 45))*x)) In order to understand the structure of the expression, one can replace numerical constants by symbolic ones : def Symb(ex, MaxPower=None): # Replace numerical constants by sumbols in a symbolic expression # (Sagemath version) def Nums(ex): # Collect numerical constants of a numerical expression # (Sagemath version) if ex._sympy_().is_number: return [ex] if ex.is_symbol() : return [] # Uniq give a shmewhat orchidoclasic version... return uniq(reduce(union, map(Nums, ex.operands()))) L = Nums(ex) # Optionally, keep small integer powers (often exponents) if MaxPower is not None: L = [u for u in L if not (u.is_integer() and u.abs() <= MaxPower)] V = var("c", n=len(L)) D = dict(zip(L, V)) iD = dict(zip(V, L)) E = ex.subs(D) return tuple([E, D, iD]) E, D, iD = Symb(f(x)) Unfortunately, the result is nonsensical (a constant) : E iD[c2] c2 -100/69786184466299 The same algorithm can be coded using sympy tools and expressions : def SymbS(ex, MaxPower=None): # Collect numerical constants of a numerical expression # (Sympy-in-Sagemath version) def Nums(ex): # Collect numerical constants of a numerical expression # (Sagemath version) # This *expected* to give results slightly different from # the Sage version : x.is_numeric() ==> x._sympy_().is_number, but # the inverse is not true... from functools import reduce if ex.is_number: return set([ex]) if ex.is_symbol: return set() return reduce(lambda a, b:a.union(b), map(Nums, ex.args)) import sympy L = Nums(ex) if MaxPower is not None: L = [u for u in L if not (u.is_integer and sympy.Abs(u) <= MaxPower)] else: L = list(L) V = sympy.var("s:%d"%len(L)) D = dict(zip(L, V)) iD = dict(zip(V, L)) E = ex.subs(D) return tuple([E, D, iD]) SE, SD, SiD = SymbS(f(x)._sympy_(), MaxPower=4) SE -100*s10*s12*(s10*s3*s4*x + s10*s4*s5*x**3 + s14*s15*x**2)/(69786184466299*s13 - 69786184466299000000*s16*x**2 - 104679276699448500*s6*x**3 + 1046792766994485000000000000*s6*x + 1465509873792279*s9*x**4) The results make sense (notwhistanding the presence of some numerical constants in the result, possibly due to premature or delayed numerical simplifications), and are numerically consistent with f : [image: realpart.png] [image: imagpart.png] One can check that using the numerical constants created by sympy to create a Sage expressin also give a nonsensical constant function : D2D=dict(zip(SiD.keys(),var("k", n=len(SiD)))) f(x).subs({u:D2D[SD[u]] for u in SD.keys()}) k2 Conversely, using the numerical constants created by sage to create a sympy expression (possibly converted to sage) gives sensible results : import sympy D2D2=dict(zip(map(lambda u:u._sympy_(), list(D.keys())),sympy.var("l:%d"%len(D)))) f(x)._sympy_().subs(D2D2)._sage_() -100*(l11*l13*x^l5 + l3*l7*x + l4*l7*x^l6)*(-69786184466299000000*l14*x^l5 + 1046792766994485000000000000*l18*x - 104679276699448500*l18*x^l6 + 1465509873792279*l9*x^l8 + 69786184466299*l17)^l1*l16*l7 Therefore, one can conclude that Sage's handling of expressions is buggy in this case. Questions : * Does this deserve filing a ticket ? * Is so, how to file it efficiently ? Le jeudi 8 juillet 2021 à 19:39:48 UTC+2, Nils Bruin a écrit : > On Thursday, 8 July 2021 at 09:49:18 UTC-7 Emmanuel Charpentier wrote: > >> Dear Nils, dear list, >> >> Le jeudi 8 juillet 2021 à 01:01:44 UTC+2, Nils Bruin a écrit : >> >>> I think the main problem in f(x) is a preparser problem: >>> https://trac.sagemath.org/ticket/11621 >>> >> >> This is likely ; I don't see how to check this, but I'll accept it for >> now. >> >> You can check it in the following way, which makes it behave as the > problem on the ticket: move the plus at the start of the second line to the > end of the first line. Now the preparser mangles the string into an > ungrammatical one, rather than a grammatical one with a different meaning. > -- You received this message because you are subscribed to the Google Groups "sage-support" group. To unsubscribe from this group and stop receiving emails from it, send an email to sage-support+unsubscr...@googlegroups.com. To view this discussion on the web visit https://groups.google.com/d/msgid/sage-support/cb860048-c2f5-488c-acaa-fe6086503f71n%40googlegroups.com.