def ParamPlot2D(self, funcs, rng, color='blue', legend="", thickness=1):
"""
Appends a parametric curve to the Graphics object. The parameters are as follows:
- ``funcs``: the tupleof functions to be plotted,
- ``rng``: a triple of the form `(t, a, b)`, where `t` is the `funcs`'s independents variable, over the range `[a, b]`,
- ``color``: the color of the current curve,
- ``legend``: the text for the legend of the current crve.
"""
if self.PlotType == '':
self.PlotType = '2D'
elif self.PlotType != '2D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_0 = funcs[0]
f_1 = funcs[1]
elif self.Env == 'sympy':
from sympy import lambdify
f_0 = lambdify(rng[0], funcs[0], "numpy")
f_1 = lambdify(rng[0], funcs[1], "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_0 = fast_callable(funcs[0], vars=[rng[0]])
f_1 = fast_callable(funcs[1], vars=[rng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_f0 = sympify(funcs[0])
t_f1 = sympify(funcs[1])
f_0 = lambdify((xrng[0], yrng[0]), t_f0, "numpy")
f_1 = lambdify((xrng[0], yrng[0]), t_f1, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted.")
# if self.X == []:
stp_lngt = float(rng[2] - rng[1]) / self.NumPoints
line_points = [rng[1] + i *
stp_lngt for i in range(self.NumPoints + 1)]
TempX = [f_0(t) for t in line_points]
self.X.append(TempX)
if self.xmin is None:
self.xmin = min(TempX)
self.xmax = max(TempX)
else:
self.xmin = min(min(TempX), self.xmin)
self.xmax = max(max(TempX), self.xmax)
TempY = [f_1(t) for t in line_points]
if self.ymin is None:
self.ymin = min(TempY)
self.ymax = max(TempY)
else:
self.ymin = min(min(TempY), self.ymin)
self.ymax = max(max(TempY), self.ymax)
self.Y.append(TempY)
self.color.append(color)
self.legend.append(legend)
self.thickness.append(thickness)
self.PlotCount += 1
def Plot3D(self, func, xrng, yrng):
"""
Sets a surface to the Graphics object. The parameters are as follows:
- ``func``: the function to be plotted,
- ``xrng``: a triple of the form `(x, a, b)`, where `x` is the first `func`s independents variable, over the range `[a, b]`,
- ``yrng``: a triple of the form `(y, c, d)`, where `x` is the second `func`'s independents variable, over the range `[c, d]`.
"""
import numpy as np
if self.PlotType == '':
self.PlotType = '3D'
elif self.PlotType != '3D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_ = func
elif self.Env == 'sympy':
from sympy import lambdify
f_ = lambdify((xrng[0], yrng[0]), func, "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_ = fast_callable(func, vars=[xrng[0], yrng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_func = sympify(func)
f_ = lambdify((xrng[0], yrng[0]), t_func, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted."
)
# self.f_ = f_
x_stp_lngt = float(xrng[2] - xrng[1]) / self.NumPoints
y_stp_lngt = float(yrng[2] - yrng[1]) / self.NumPoints
if self.X == []:
self.X = [
xrng[1] + i * x_stp_lngt for i in range(self.NumPoints + 1)
]
self.xmin = xrng[1]
self.xmax = xrng[2]
self.Y = [
yrng[1] + i * y_stp_lngt for i in range(self.NumPoints + 1)
]
self.ymin = yrng[1]
self.ymax = yrng[2]
X = np.array(self.X)
Y = np.array(self.Y)
self.X, self.Y = np.meshgrid(X, Y)
self.Z = f_(self.X, self.Y)
self.intX, self.intY = np.mgrid[xrng[1]:xrng[2]:x_stp_lngt,
yrng[1]:yrng[2]:y_stp_lngt]
self.intZ = f_(self.intX, self.intY)
def __init__(self, RS, *args):
"""Create a differential on the Riemann surface `RS`.
"""
if (len(args) < 1) or (len(args) > 2):
raise ValueError('Instantiate Differential with Sympy expression '
'or numerator/denominator pair.')
# determine the numerator and denominator of the differentials
if len(args) == 1:
self.numer = args[0].numerator()
self.denom = args[0].denominator()
elif len(args) == 2:
self.numer = args[0]
self.denom = args[1]
x,y = RS.f.parent().gens()
self.RS = RS
self.differential = self.numer / self.denom
self.numer_n = fast_callable(self.numer.change_ring(CC), vars=[x,y],
domain=numpy.complex)
self.denom_n = fast_callable(self.denom.change_ring(CC), vars=[x,y],
domain=numpy.complex)
def __init__(self, RS, *args):
"""Create a differential on the Riemann surface `RS`.
"""
if (len(args) < 1) or (len(args) > 2):
raise ValueError('Instantiate Differential with Sympy expression '
'or numerator/denominator pair.')
# determine the numerator and denominator of the differentials
if len(args) == 1:
self.numer = args[0].numerator()
self.denom = args[0].denominator()
elif len(args) == 2:
self.numer = args[0]
self.denom = args[1]
x,y = RS.f.parent().gens()
self.RS = RS
self.differential = self.numer / self.denom
self.numer_n = fast_callable(self.numer.change_ring(CC), vars=[x,y],
domain=numpy.complex)
self.denom_n = fast_callable(self.denom.change_ring(CC), vars=[x,y],
domain=numpy.complex)
def Plot2D(self, func, xrng, color='blue', legend="", thickness=1):
"""
Appends a curve to the Graphics object. The parameters are as follows:
- `func`: the function to be plotted,
- `xrng`: a triple of the form `(x, a, b)`, where `x` is the `func`'s independents variable, over the range `[a, b]`,
- `color`: the color of the current curve,
- `legend`: the text for the legend of the current crve.
"""
if self.PlotType == '':
self.PlotType = '2D'
elif self.PlotType != '2D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_ = func
elif self.Env == 'sympy':
from sympy import lambdify
f_ = lambdify(xrng[0], func, "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_ = fast_callable(func, vars=[xrng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_func = sympify(func)
f_ = lambdify(xrng[0], t_func, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted."
)
# if self.X == []:
stp_lngt = float(xrng[2] - xrng[1]) / self.NumPoints
self.X.append(
[xrng[1] + i * stp_lngt for i in range(self.NumPoints + 1)])
self.xmin = xrng[1]
self.xmax = xrng[2]
TempY = [f_(x) for x in self.X[-1]]
if self.ymin is None:
self.ymin = min(TempY)
self.ymax = max(TempY)
else:
self.ymin = min(min(TempY), self.ymin)
self.ymax = max(max(TempY), self.ymax)
self.Y.append(TempY)
self.color.append(color)
self.legend.append(legend)
self.thickness.append(thickness)
self.PlotCount += 1
def __init__(self, riemann_surface, complex_path, y0, ncheckpoints=16):
# store a list of all y-derivatives of f (including the zeroth deriv)
degree = riemann_surface.degree
f = riemann_surface.f.change_ring(CC)
x,y = f.parent().gens()
df = [
fast_callable(f.derivative(y,k), vars=(x,y), domain=complex)
for k in range(degree+1)
]
self.degree = degree
self.df = df
RiemannSurfacePathPrimitive.__init__(
self, riemann_surface, complex_path, y0, ncheckpoints=ncheckpoints)
def Plot3D(self, func, xrng, yrng):
"""
Sets a surface to the Graphics object. The parameters are as follows:
- ``func``: the function to be plotted,
- ``xrng``: a triple of the form `(x, a, b)`, where `x` is the first `func`s independents variable, over the range `[a, b]`,
- ``yrng``: a triple of the form `(y, c, d)`, where `x` is the second `func`'s independents variable, over the range `[c, d]`.
"""
import numpy as np
if self.PlotType == '':
self.PlotType = '3D'
elif self.PlotType != '3D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_ = func
elif self.Env == 'sympy':
from sympy import lambdify
f_ = lambdify((xrng[0], yrng[0]), func, "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_ = fast_callable(func, vars=[xrng[0], yrng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_func = sympify(func)
f_ = lambdify((xrng[0], yrng[0]), t_func, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted.")
# self.f_ = f_
x_stp_lngt = float(xrng[2] - xrng[1]) / self.NumPoints
y_stp_lngt = float(yrng[2] - yrng[1]) / self.NumPoints
if self.X == []:
self.X = [xrng[1] + i *
x_stp_lngt for i in range(self.NumPoints + 1)]
self.xmin = xrng[1]
self.xmax = xrng[2]
self.Y = [yrng[1] + i *
y_stp_lngt for i in range(self.NumPoints + 1)]
self.ymin = yrng[1]
self.ymax = yrng[2]
X = np.array(self.X)
Y = np.array(self.Y)
self.X, self.Y = np.meshgrid(X, Y)
self.Z = f_(self.X, self.Y)
self.intX, self.intY = np.mgrid[xrng[1]:xrng[
2]:x_stp_lngt, yrng[1]:yrng[2]:y_stp_lngt]
self.intZ = f_(self.intX, self.intY)
def Plot2D(self, func, xrng, color='blue', legend="", thickness=1):
"""
Appends a curve to the Graphics object. The parameters are as follows:
- `func`: the function to be plotted,
- `xrng`: a triple of the form `(x, a, b)`, where `x` is the `func`'s independents variable, over the range `[a, b]`,
- `color`: the color of the current curve,
- `legend`: the text for the legend of the current crve.
"""
if self.PlotType == '':
self.PlotType = '2D'
elif self.PlotType != '2D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_ = func
elif self.Env == 'sympy':
from sympy import lambdify
f_ = lambdify(xrng[0], func, "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_ = fast_callable(func, vars=[xrng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_func = sympify(func)
f_ = lambdify(xrng[0], t_func, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted.")
# if self.X == []:
stp_lngt = float(xrng[2] - xrng[1]) / self.NumPoints
self.X.append(
[xrng[1] + i * stp_lngt for i in range(self.NumPoints + 1)])
self.xmin = xrng[1]
self.xmax = xrng[2]
TempY = [f_(x) for x in self.X[-1]]
if self.ymin is None:
self.ymin = min(TempY)
self.ymax = max(TempY)
else:
self.ymin = min(min(TempY), self.ymin)
self.ymax = max(max(TempY), self.ymax)
self.Y.append(TempY)
self.color.append(color)
self.legend.append(legend)
self.thickness.append(thickness)
self.PlotCount += 1
def __init__(self, riemann_surface, complex_path, y0, ncheckpoints=16):
# store a list of all y-derivatives of f (including the zeroth deriv)
degree = riemann_surface.degree
f = riemann_surface.f.change_ring(CC)
x, y = f.parent().gens()
df = [
fast_callable(f.derivative(y, k), vars=(x, y), domain=complex)
for k in range(degree + 1)
]
self.degree = degree
self.df = df
RiemannSurfacePathPrimitive.__init__(self,
riemann_surface,
complex_path,
y0,
ncheckpoints=ncheckpoints)
def inner(self, f, g):
"""
Computes the inner product of the two parameters with respect to
the measure ``measure``.
"""
if self.Env == "sympy":
from sympy import lambdify
F = lambdify(self.Vars, f * g, "numpy")
elif self.Env == "sage":
from sage.all import fast_callable
h = f * g + self.Vars[0] * 0
H = fast_callable(h, vars=self.Vars)
F = lambda *x: H(*x)
elif self.Env == 'symengine':
from symengine import Lambdify
F = lambda *x: Lambdify(self.Vars, [f * g])(x)[0]
m = self.measure.integral(F)
return m
def inner(self, f, g):
"""
Computes the inner product of the two parameters with respect to
the measure ``measure``.
"""
if self.Env == "sympy":
from sympy import lambdify
F = lambdify(self.Vars, f * g, "numpy")
elif self.Env == "sage":
from sage.all import fast_callable
h = f * g + self.Vars[0] * 0
H = fast_callable(h, vars=self.Vars)
F = lambda *x: H(*x)
elif self.Env == 'symengine':
from symengine import Lambdify
F = lambda *x: Lambdify(self.Vars, [f * g])(x)[0]
m = self.measure.integral(F)
return m
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)
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)
def ParamPlot2D(self, funcs, rng, color='blue', legend="", thickness=1):
"""
Appends a parametric curve to the Graphics object. The parameters are as follows:
- ``funcs``: the tupleof functions to be plotted,
- ``rng``: a triple of the form `(t, a, b)`, where `t` is the `funcs`'s independents variable, over the range `[a, b]`,
- ``color``: the color of the current curve,
- ``legend``: the text for the legend of the current crve.
"""
if self.PlotType == '':
self.PlotType = '2D'
elif self.PlotType != '2D':
raise Exception("Cannot combine 2d and 3d plots")
if self.Env == 'numeric':
f_0 = funcs[0]
f_1 = funcs[1]
elif self.Env == 'sympy':
from sympy import lambdify
f_0 = lambdify(rng[0], funcs[0], "numpy")
f_1 = lambdify(rng[0], funcs[1], "numpy")
elif self.Env == 'sage':
from sage.all import fast_callable
f_0 = fast_callable(funcs[0], vars=[rng[0]])
f_1 = fast_callable(funcs[1], vars=[rng[0]])
elif self.Env == 'symengine':
from symengine import sympify
from sympy import lambdify
t_f0 = sympify(funcs[0])
t_f1 = sympify(funcs[1])
f_0 = lambdify((xrng[0], yrng[0]), t_f0, "numpy")
f_1 = lambdify((xrng[0], yrng[0]), t_f1, "numpy")
else:
raise Exception(
"The function type is not recognized. Only 'numeric', 'sympy' and 'sage' are accepted."
)
# if self.X == []:
stp_lngt = float(rng[2] - rng[1]) / self.NumPoints
line_points = [
rng[1] + i * stp_lngt for i in range(self.NumPoints + 1)
]
TempX = [f_0(t) for t in line_points]
self.X.append(TempX)
if self.xmin is None:
self.xmin = min(TempX)
self.xmax = max(TempX)
else:
self.xmin = min(min(TempX), self.xmin)
self.xmax = max(max(TempX), self.xmax)
TempY = [f_1(t) for t in line_points]
if self.ymin is None:
self.ymin = min(TempY)
self.ymax = max(TempY)
else:
self.ymin = min(min(TempY), self.ymin)
self.ymax = max(max(TempY), self.ymax)
self.Y.append(TempY)
self.color.append(color)
self.legend.append(legend)
self.thickness.append(thickness)
self.PlotCount += 1
