passagemath-symbolics 10.8.1a1__cp311-cp311-macosx_13_0_arm64.whl

sage/calculus/predefined.py

@@ -0,0 +1,51 @@
+# sage_setup: distribution = sagemath-symbolics
+from sage.symbolic.ring import var as _var
+
+a = _var('a')
+b = _var('b')
+c = _var('c')
+d = _var('d')
+f = _var('f')
+g = _var('g')
+h = _var('h')
+j = _var('j')
+k = _var('k')
+l = _var('l')
+m = _var('m')
+n = _var('n')
+o = _var('o')
+p = _var('p')
+q = _var('q')
+r = _var('r')
+s = _var('s')
+t = _var('t')
+u = _var('u')
+v = _var('v')
+w = _var('w')
+x = _var('x')
+y = _var('y')
+z = _var('z')
+A = _var('A')
+B = _var('B')
+C = _var('C')
+D = _var('D')
+E = _var('E')
+F = _var('F')
+G = _var('G')
+H = _var('H')
+J = _var('J')
+K = _var('K')
+L = _var('L')
+M = _var('M')
+N = _var('N')
+P = _var('P')
+Q = _var('Q')
+R = _var('R')
+S = _var('S')
+T = _var('T')
+U = _var('U')
+V = _var('V')
+W = _var('W')
+X = _var('X')
+Y = _var('Y')
+Z = _var('Z')

sage/calculus/tests.py

@@ -0,0 +1,225 @@
+# sage_setup: distribution = sagemath-symbolics
+r"""
+Calculus Tests and Examples
+
+Compute the Christoffel symbol.
+
+::
+
+    sage: var('r t theta phi')
+    (r, t, theta, phi)
+    sage: m = matrix(SR, [[(1-1/r),0,0,0],[0,-(1-1/r)^(-1),0,0],[0,0,-r^2,0],[0,0,0,-r^2*(sin(theta))^2]])
+    sage: m
+    [         -1/r + 1                 0                 0                 0]
+    [                0       1/(1/r - 1)                 0                 0]
+    [                0                 0              -r^2                 0]
+    [                0                 0                 0 -r^2*sin(theta)^2]
+
+::
+
+    sage: def christoffel(i, j, k, vars, g):
+    ....:     s = 0
+    ....:     ginv = g^(-1)
+    ....:     for l in range(g.nrows()):
+    ....:         s = s + (1/2)*ginv[k,l]*(g[j,l].diff(vars[i])+g[i,l].diff(vars[j])-g[i,j].diff(vars[l]))
+    ....:     return s
+
+::
+
+    sage: christoffel(3,3,2, [t,r,theta,phi], m)
+    -cos(theta)*sin(theta)
+    sage: X = christoffel(1,1,1,[t,r,theta,phi],m)
+    sage: X
+    1/2/(r^2*(1/r - 1))
+    sage: X.rational_simplify()
+     -1/2/(r^2 - r)
+
+Some basic things::
+
+    sage: f(x,y) = x^3 + sinh(1/y)
+    sage: f
+    (x, y) |--> x^3 + sinh(1/y)
+    sage: f^3
+    (x, y) |--> (x^3 + sinh(1/y))^3
+    sage: (f^3).expand()
+    (x, y) |--> x^9 + 3*x^6*sinh(1/y) + 3*x^3*sinh(1/y)^2 + sinh(1/y)^3
+
+A polynomial over a symbolic base ring::
+
+    sage: R = SR['x']
+    sage: f = R([1/sqrt(2), 1/(4*sqrt(2))])
+    sage: f
+    1/8*sqrt(2)*x + 1/2*sqrt(2)
+    sage: -f
+    -1/8*sqrt(2)*x - 1/2*sqrt(2)
+    sage: (-f).degree()
+    1
+
+A big product.  Notice that simplifying simplifies the product further::
+
+    sage: A = exp(I*pi/7)
+    sage: b = A^14
+    sage: b
+    1
+
+We check a statement made at the beginning of Friedlander and
+Joshi's book on Distributions::
+
+    sage: f(x) = sin(x^2)
+    sage: g(x) = cos(x) + x^3
+    sage: u = f(x+t) + g(x-t)
+    sage: u
+    -(t - x)^3 + cos(-t + x) + sin((t + x)^2)
+    sage: u.diff(t,2) - u.diff(x,2)
+    0
+
+Restoring variables after they have been turned into functions::
+
+    sage: x = function('x')
+    sage: type(x)
+    <class 'sage.symbolic.function_factory...NewSymbolicFunction'>
+    sage: x(2/3)
+    x(2/3)
+    sage: restore('x')
+    sage: sin(x).variables()
+    (x,)
+
+MATHEMATICA: Some examples of integration and differentiation taken
+from some Mathematica docs::
+
+    sage: var('x n a')
+    (x, n, a)
+    sage: diff(x^n, x)        # the output looks funny, but is correct
+    n*x^(n - 1)
+    sage: diff(x^2 * log(x+a), x)
+    2*x*log(a + x) + x^2/(a + x)
+    sage: derivative(arctan(x), x)
+    1/(x^2 + 1)
+    sage: derivative(x^n, x, 3)
+    (n - 1)*(n - 2)*n*x^(n - 3)
+    sage: derivative( function('f')(x), x)
+    diff(f(x), x)
+    sage: diff( 2*x*f(x^2), x)
+    4*x^2*D[0](f)(x^2) + 2*f(x^2)
+    sage: integrate( 1/(x^4 - a^4), x)
+    -1/2*arctan(x/a)/a^3 - 1/4*log(a + x)/a^3 + 1/4*log(-a + x)/a^3
+    sage: expand(integrate(log(1-x^2), x))
+    x*log(-x^2 + 1) - 2*x + log(x + 1) - log(x - 1)
+
+This is an apparent regression in Maxima 5.39.0, although
+the antiderivative is correct, assuming we work with
+(poly)logs of complex argument. More convenient form is
+1/2*log(x^2)*log(-x^2 + 1) + 1/2*dilog(-x^2 + 1).
+See also https://sourceforge.net/p/maxima/bugs/3275/::
+
+    sage: integrate(log(1-x^2)/x, x)
+    log(-x)*log(x + 1) + log(x)*log(-x + 1) + dilog(x + 1) + dilog(-x + 1)
+
+No problems here::
+
+    sage: integrate(exp(1-x^2),x)
+    1/2*sqrt(pi)*erf(x)*e
+    sage: integrate(sin(x^2),x)
+    1/16*sqrt(pi)*((I + 1)*sqrt(2)*erf((1/2*I + 1/2)*sqrt(2)*x) + (I - 1)*sqrt(2)*erf((1/2*I - 1/2)*sqrt(2)*x) - (I - 1)*sqrt(2)*erf(sqrt(-I)*x) + (I + 1)*sqrt(2)*erf((-1)^(1/4)*x))
+
+    sage: integrate((1-x^2)^n,x)  # long time
+    x*hypergeometric((1/2, -n), (3/2,), x^2*exp_polar(2*I*pi))
+    sage: integrate(x^x,x)
+    integrate(x^x, x)
+    sage: integrate(1/(x^3+1),x)
+    1/3*sqrt(3)*arctan(1/3*sqrt(3)*(2*x - 1)) - 1/6*log(x^2 - x + 1) + 1/3*log(x + 1)
+    sage: integrate(1/(x^3+1), x, 0, 1)
+    1/9*sqrt(3)*pi + 1/3*log(2)
+
+::
+
+    sage: forget()
+    sage: c = var('c')
+    sage: assume(c > 0)
+    sage: integrate(exp(-c*x^2), x, -oo, oo)
+    sqrt(pi)/sqrt(c)
+    sage: forget()
+
+Other examples that now (:issue:`27958`) work::
+
+    sage: integrate(log(x)*exp(-x^2), x)  # long time
+    1/2*sqrt(pi)*erf(x)*log(x) - x*hypergeometric((1/2, 1/2), (3/2, 3/2), -x^2)
+
+    sage: integrate(log(1+sqrt(1+4*x)/2)/x, x, 0, 1)
+    Traceback (most recent call last):
+    ...
+    ValueError: Integral is divergent.
+
+The following is an example of integral that Mathematica
+can do, but Sage currently cannot do::
+
+    sage: integrate(ceil(x^2 + floor(x)), x, 0, 5, algorithm='maxima')
+    integrate(ceil(x^2) + floor(x), x, 0, 5)
+
+MAPLE: The basic differentiation and integration examples in the
+Maple documentation::
+
+    sage: diff(sin(x), x)
+    cos(x)
+    sage: diff(sin(x), y)
+    0
+    sage: diff(sin(x), x, 3)
+    -cos(x)
+    sage: diff(x*sin(cos(x)), x)
+    -x*cos(cos(x))*sin(x) + sin(cos(x))
+    sage: diff(tan(x), x)
+    tan(x)^2 + 1
+    sage: f = function('f'); f
+    f
+    sage: diff(f(x), x)
+    diff(f(x), x)
+    sage: diff(f(x,y), x, y)
+    diff(f(x, y), x, y)
+    sage: diff(f(x,y), x, y) - diff(f(x,y), y, x)
+    0
+    sage: g = function('g')
+    sage: var('x y z')
+    (x, y, z)
+    sage: diff(g(x,y,z), x,z,z)
+    diff(g(x, y, z), x, z, z)
+    sage: integrate(sin(x), x)
+    -cos(x)
+    sage: integrate(sin(x), x, 0, pi)
+    2
+
+::
+
+    sage: var('a b')
+    (a, b)
+    sage: integrate(sin(x), x, a, b)
+    cos(a) - cos(b)
+
+::
+
+    sage: integrate( x/(x^3-1), x)
+    1/3*sqrt(3)*arctan(1/3*sqrt(3)*(2*x + 1)) - 1/6*log(x^2 + x + 1) + 1/3*log(x - 1)
+    sage: integrate(exp(-x^2), x)
+    1/2*sqrt(pi)*erf(x)
+    sage: integrate(exp(-x^2)*log(x), x)  # long time
+    1/2*sqrt(pi)*erf(x)*log(x) - x*hypergeometric((1/2, 1/2), (3/2, 3/2), -x^2)
+    sage: f = exp(-x^2)*log(x)
+    sage: f.nintegral(x, 0, 999)
+    (-0.87005772672831..., 7.5584...e-10, 567, 0)
+    sage: integral(1/sqrt(2*t^4 - 3*t^2 - 2), t, 2, 3)     # long time  # todo: maple can do this
+    integrate(1/(sqrt(2*t^2 + 1)*sqrt(t^2 - 2)), t, 2, 3)
+    sage: integral(integral(x*y^2, x, 0, y), y, -2, 2)
+    32/5
+
+We verify several standard differentiation rules::
+
+    sage: function('f, g')
+    (f, g)
+    sage: diff(f(t)*g(t),t)
+    g(t)*diff(f(t), t) + f(t)*diff(g(t), t)
+    sage: diff(f(t)/g(t), t)
+    diff(f(t), t)/g(t) - f(t)*diff(g(t), t)/g(t)^2
+    sage: diff(f(t) + g(t), t)
+    diff(f(t), t) + diff(g(t), t)
+    sage: diff(c*f(t), t)
+    c*diff(f(t), t)
+"""

sage/calculus/var.pyx

@@ -0,0 +1,401 @@
+# sage_setup: distribution = sagemath-symbolics
+# cython: old_style_globals=True
+"""
+Symbolic variables
+"""
+
+from sage.symbolic.function_factory import function as new_function
+from sage.symbolic.ring import SR
+
+
+def var(*args, **kwds):
+    r"""
+    Create a symbolic variable with the name *s*.
+
+    INPUT:
+
+    - ``args`` -- a single string ``var('x y')``, a list of strings
+      ``var(['x','y'])``, or multiple strings ``var('x', 'y')``. A
+      single string can be either a single variable name, or a space
+      or comma separated list of variable names. In a list or tuple of
+      strings, each entry is one variable. If multiple arguments are
+      specified, each argument is taken to be one variable. Spaces
+      before or after variable names are ignored.
+
+    - ``kwds`` -- keyword arguments can be given to specify domain and
+      custom latex_name for variables; see EXAMPLES for usage
+
+    .. NOTE::
+
+        The new variable is both returned and automatically injected
+        into the global namespace. If you need a symbolic variable in
+        library code, you must use either ``SR.var()``
+        or ``SR.symbol()``.
+
+    OUTPUT:
+
+    If a single symbolic variable was created, the variable
+    itself. Otherwise, a tuple of symbolic variables. The variable
+    names are checked to be valid Python identifiers and a
+    :exc:`ValueError` is raised otherwise.
+
+    EXAMPLES:
+
+    Here are the different ways to define three variables ``x``, ``y``,
+    and ``z`` in a single line::
+
+        sage: var('x y z')
+        (x, y, z)
+        sage: var('x, y, z')
+        (x, y, z)
+        sage: var(['x', 'y', 'z'])
+        (x, y, z)
+        sage: var('x', 'y', 'z')
+        (x, y, z)
+        sage: var('x'), var('y'), var(z)
+        (x, y, z)
+
+    We define some symbolic variables::
+
+        sage: var('n xx yy zz')
+        (n, xx, yy, zz)
+
+    Then we make an algebraic expression out of them::
+
+        sage: f = xx^n + yy^n + zz^n; f
+        xx^n + yy^n + zz^n
+
+    By default, var returns a complex variable. To define real or positive
+    variables we can specify the domain as::
+
+        sage: x = var('x', domain=RR); x; x.conjugate()
+        x
+        x
+        sage: y = var('y', domain='real'); y.conjugate()
+        y
+        sage: y = var('y', domain='positive'); y.abs()
+        y
+
+    Custom latex expression can be assigned to variable::
+
+        sage: x = var('sui', latex_name='s_{u,i}'); x._latex_()
+        '{s_{u,i}}'
+
+    In notebook, we can also colorize latex expression::
+
+        sage: x = var('sui', latex_name='\\color{red}{s_{u,i}}'); x._latex_()
+        '{\\color{red}{s_{u,i}}}'
+
+    We can substitute a new variable name for n::
+
+        sage: f(n = var('sigma'))
+        xx^sigma + yy^sigma + zz^sigma
+
+    If you make an important built-in variable into a symbolic variable,
+    you can get back the original value using restore::
+
+        sage: var('QQ RR')
+        (QQ, RR)
+        sage: QQ
+        QQ
+        sage: restore('QQ')
+        sage: QQ
+        Rational Field
+
+    We make two new variables separated by commas::
+
+        sage: var('theta, gamma')
+        (theta, gamma)
+        sage: theta^2 + gamma^3
+        gamma^3 + theta^2
+
+    The new variables are of type Expression, and belong
+    to the symbolic expression ring::
+
+        sage: type(theta)
+        <class 'sage.symbolic.expression.Expression'>
+        sage: parent(theta)
+        Symbolic Ring
+    """
+    if len(args) == 1:
+        name = args[0]
+    else:
+        name = args
+    G = globals()  # this is the reason the code must be in Cython.
+    v = SR.var(name, **kwds)
+    if isinstance(v, tuple):
+        for x in v:
+            G[repr(x)] = x
+    else:
+        G[repr(v)] = v
+    return v
+
+
+def function(s, **kwds):
+    r"""
+    Create a formal symbolic function with the name *s*.
+
+    INPUT:
+
+    - ``nargs=0`` -- number of arguments the function accepts, defaults to
+      variable number of arguments, or 0
+    - ``latex_name`` -- name used when printing in latex mode
+    - ``conversions`` -- dictionary specifying names of this function in
+      other systems, this is used by the interfaces internally during conversion
+    - ``eval_func`` -- method used for automatic evaluation
+    - ``evalf_func`` -- method used for numeric evaluation
+    - ``evalf_params_first`` -- boolean to indicate if parameters should be
+      evaluated numerically before calling the custom evalf function
+    - ``conjugate_func`` -- method used for complex conjugation
+    - ``real_part_func`` -- method used when taking real parts
+    - ``imag_part_func`` -- method used when taking imaginary parts
+    - ``derivative_func`` -- method to be used for (partial) derivation
+      This method should take a keyword argument deriv_param specifying
+      the index of the argument to differentiate w.r.t
+    - ``tderivative_func`` -- method to be used for derivatives
+    - ``power_func`` -- method used when taking powers
+      This method should take a keyword argument power_param specifying
+      the exponent
+    - ``series_func`` -- method used for series expansion
+      This method should expect keyword arguments
+      - ``order`` -- order for the expansion to be computed
+      - ``var`` -- variable to expand w.r.t.
+      - ``at`` -- expand at this value
+    - ``print_func`` -- method for custom printing
+    - ``print_latex_func`` -- method for custom printing in latex mode
+
+    Note that custom methods must be instance methods, i.e., expect the instance
+    of the symbolic function as the first argument.
+
+    .. NOTE::
+
+        The new function is both returned and automatically injected
+        into the global namespace.  If you use this function in library
+        code, it is better to use sage.symbolic.function_factory.function,
+        since it will not touch the global namespace.
+
+    EXAMPLES:
+
+    We create a formal function called supersin ::
+
+        sage: function('supersin')
+        supersin
+
+    We can immediately use supersin in symbolic expressions::
+
+        sage: y, z, A = var('y z A')
+        sage: supersin(y+z) + A^3
+        A^3 + supersin(y + z)
+
+    We can define other functions in terms of supersin::
+
+        sage: g(x,y) = supersin(x)^2 + sin(y/2)
+        sage: g
+        (x, y) |--> supersin(x)^2 + sin(1/2*y)
+        sage: g.diff(y)
+        (x, y) |--> 1/2*cos(1/2*y)
+        sage: k = g.diff(x); k
+        (x, y) |--> 2*supersin(x)*diff(supersin(x), x)
+
+    We create a formal function of one variable, write down
+    an expression that involves first and second derivatives,
+    and extract off coefficients::
+
+        sage: r, kappa = var('r,kappa')
+        sage: psi = function('psi', nargs=1)(r); psi
+        psi(r)
+        sage: g = 1/r^2*(2*r*psi.derivative(r,1) + r^2*psi.derivative(r,2)); g
+        (r^2*diff(psi(r), r, r) + 2*r*diff(psi(r), r))/r^2
+        sage: g.expand()
+        2*diff(psi(r), r)/r + diff(psi(r), r, r)
+        sage: g.coefficient(psi.derivative(r,2))
+        1
+        sage: g.coefficient(psi.derivative(r,1))
+        2/r
+
+    Custom typesetting of symbolic functions in LaTeX, either using latex_name
+    keyword::
+
+        sage: function('riemann', latex_name='\\mathcal{R}')
+        riemann
+        sage: latex(riemann(x))
+        \mathcal{R}\left(x\right)
+
+    or passing a custom callable function that returns a latex expression::
+
+        sage: mu,nu = var('mu,nu')
+        sage: def my_latex_print(self, *args): return "\\psi_{%s}"%(', '.join(map(latex, args)))
+        sage: function('psi', print_latex_func=my_latex_print)
+        psi
+        sage: latex(psi(mu,nu))
+        \psi_{\mu, \nu}
+
+    Defining custom methods for automatic or numeric evaluation, derivation,
+    conjugation, etc. is supported::
+
+        sage: def ev(self, x): return 2*x
+        sage: foo = function("foo", nargs=1, eval_func=ev)
+        sage: foo(x)
+        2*x
+        sage: foo = function("foo", nargs=1, eval_func=lambda self, x: 5)
+        sage: foo(x)
+        5
+        sage: def ef(self, x): pass
+        sage: bar = function("bar", nargs=1, eval_func=ef)
+        sage: bar(x)
+        bar(x)
+
+        sage: def evalf_f(self, x, parent=None, algorithm=None): return 6
+        sage: foo = function("foo", nargs=1, evalf_func=evalf_f)
+        sage: foo(x)
+        foo(x)
+        sage: foo(x).n()
+        6
+
+        sage: foo = function("foo", nargs=1, conjugate_func=ev)
+        sage: foo(x).conjugate()
+        2*x
+
+        sage: def deriv(self, *args, **kwds): print("{} {}".format(args, kwds)); return args[kwds['diff_param']]^2
+        sage: foo = function("foo", nargs=2, derivative_func=deriv)
+        sage: foo(x,y).derivative(y)
+        (x, y) {'diff_param': 1}
+        y^2
+
+        sage: def pow(self, x, power_param=None): print("{} {}".format(x, power_param)); return x*power_param
+        sage: foo = function("foo", nargs=1, power_func=pow)
+        sage: foo(y)^(x+y)
+        y x + y
+        (x + y)*y
+
+        sage: from pprint import pformat
+        sage: def expand(self, *args, **kwds):
+        ....:     print("{} {}".format(args, pformat(kwds)))
+        ....:     return sum(args[0]^i for i in range(kwds['order']))
+        sage: foo = function("foo", nargs=1, series_func=expand)
+        sage: foo(y).series(y, 5)
+        (y,) {'at': 0, 'options': 0, 'order': 5, 'var': y}
+        y^4 + y^3 + y^2 + y + 1
+
+        sage: def my_print(self, *args):
+        ....:     return "my args are: " + ', '.join(map(repr, args))
+        sage: foo = function('t', nargs=2, print_func=my_print)
+        sage: foo(x,y^z)
+        my args are: x, y^z
+
+        sage: latex(foo(x,y^z))
+        t\left(x, y^{z}\right)
+        sage: foo = function('t', nargs=2, print_latex_func=my_print)
+        sage: foo(x,y^z)
+        t(x, y^z)
+        sage: latex(foo(x,y^z))
+        my args are: x, y^z
+        sage: foo = function('t', nargs=2, latex_name='foo')
+        sage: latex(foo(x,y^z))
+        foo\left(x, y^{z}\right)
+
+    Chain rule::
+
+        sage: def print_args(self, *args, **kwds): print("args: {}".format(args)); print("kwds: {}".format(kwds)); return args[0]
+        sage: foo = function('t', nargs=2, tderivative_func=print_args)
+        sage: foo(x,x).derivative(x)
+        args: (x, x)
+        kwds: {'diff_param': x}
+        x
+        sage: foo = function('t', nargs=2, derivative_func=print_args)
+        sage: foo(x,x).derivative(x)
+        args: (x, x)
+        kwds: {'diff_param': 0}
+        args: (x, x)
+        kwds: {'diff_param': 1}
+        2*x
+
+    Since Sage 4.0, basic arithmetic with unevaluated functions is no
+    longer supported::
+
+        sage: x = var('x')
+        sage: f = function('f')
+        sage: 2*f
+        Traceback (most recent call last):
+        ...
+        TypeError: unsupported operand parent(s) for *: 'Integer Ring' and '<class 'sage.symbolic.function_factory...NewSymbolicFunction'>'
+
+    You now need to evaluate the function in order to do the arithmetic::
+
+        sage: 2*f(x)
+        2*f(x)
+
+    Since Sage 4.0, you need to use :meth:`substitute_function` to
+    replace all occurrences of a function with another::
+
+        sage: var('a, b')
+        (a, b)
+        sage: cr = function('cr')
+        sage: f = cr(a)
+        sage: g = f.diff(a).integral(b)
+        sage: g
+        b*diff(cr(a), a)
+        sage: g.substitute_function(cr, cos)
+        -b*sin(a)
+
+        sage: g.substitute_function(cr, (sin(x) + cos(x)).function(x))
+        b*(cos(a) - sin(a))
+
+    TESTS:
+
+    Make sure that :issue:`15860` is fixed and whitespaces are removed::
+
+        sage: function('A, B')
+        (A, B)
+        sage: B
+        B
+    """
+    G = globals()  # this is the reason the code must be in Cython.
+    v = new_function(s, **kwds)
+    if isinstance(v, tuple):
+        for x in v:
+            G[repr(x)] = x
+    else:
+        G[repr(v)] = v
+    return v
+
+
+def clear_vars():
+    """
+    Delete all 1-letter symbolic variables that are predefined at
+    startup of Sage.
+
+    Any one-letter global variables that are not symbolic variables
+    are not cleared.
+
+    EXAMPLES::
+
+        sage: var('x y z')
+        (x, y, z)
+        sage: (x+y)^z
+        (x + y)^z
+        sage: k = 15
+        sage: clear_vars()
+        sage: (x+y)^z
+        Traceback (most recent call last):
+        ...
+        NameError: name 'x' is not defined
+        sage: expand((e + i)^2)
+        e^2 + 2*I*e - 1
+        sage: k
+        15
+    """
+    from sage.structure.element import Expression
+
+    G = globals()
+    for i in list(range(65, 65 + 26)) + list(range(97, 97 + 26)):
+        chr_i = chr(i)
+        if chr_i in G and isinstance(G[chr_i], Expression) and G[chr_i].is_symbol():
+            # We check to see if there is a corresponding pyobject
+            # associated with the expression.  This will work for
+            # constants which we want to keep, but will fail for
+            # variables that we want to delete.
+            try:
+                G[chr(i)].pyobject()
+            except TypeError:
+                del G[chr(i)]

sage/dynamics/all__sagemath_symbolics.py

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-symbolics
+from sage.misc.lazy_import import lazy_import
+
+lazy_import('sage.dynamics.complex_dynamics.mandel_julia',
+            ["mandelbrot_plot", "external_ray", "kneading_sequence", "julia_plot"])
+del lazy_import

sage/dynamics/complex_dynamics/all.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-symbolics
+from sage.misc.lazy_import import lazy_import
+lazy_import("sage.dynamics.complex_dynamics.mandel_julia",
+            ["mandelbrot_plot", "external_ray", "kneading_sequence", "julia_plot"])
+del lazy_import