Coverage for local/lib/python2.7/site-packages/sage/rings/asymptotic/asymptotics_multivariate_generating_functions.py : 83%

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R)

sage: f = FFPD(x + y, [(y, 1), (x, 1)])

sage: g = FFPD(x**2 + y, [(y, 1), (x, 2)])

sage: FractionWithFactoredDenominatorSum([f, g])

(x + y, [(y, 1), (x, 1)]) + (x^2 + y, [(y, 1), (x, 2)])

"""

return ' + '.join(repr(r) for r in self)

def __eq__(self, other):

r"""

Return ``True`` if ``self`` is equal to ``other``.

OUTPUT:

A boolean.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R)

sage: f = FFPD(x + y, [(y, 1), (x, 1)])

sage: g = FFPD(x*(x + y), [(y, 1), (x, 2)])

sage: s = FractionWithFactoredDenominatorSum([f]); s

(x + y, [(y, 1), (x, 1)])

sage: t = FractionWithFactoredDenominatorSum([g]); t

(x + y, [(y, 1), (x, 1)])

sage: s == t

True

"""

from operator import methodcaller

return (sorted(self, key=methodcaller('_total_order_key_')) ==

sorted(other, key=methodcaller('_total_order_key_')))

def __ne__(self, other):

r"""

Return ``True`` if ``self`` is not equal to ``other``.

OUTPUT:

A boolean.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R)

sage: f = FFPD(x + y, [(y, 1), (x, 1)])

sage: g = FFPD(x + y, [(y, 1), (x, 2)])

sage: s = FractionWithFactoredDenominatorSum([f]); s

(x + y, [(y, 1), (x, 1)])

sage: t = FractionWithFactoredDenominatorSum([g]); t

(x + y, [(y, 1), (x, 2)])

sage: s != t

True

"""

return not self.__eq__(other)

@property

def denominator_ring(self):

r"""

Return the polynomial ring of the denominators of ``self``.

OUTPUT:

A ring or ``None`` if the list is empty.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R)

sage: f = FFPD(x + y, [(y, 1), (x, 1)])

sage: s = FractionWithFactoredDenominatorSum([f])

sage: s.denominator_ring

Multivariate Polynomial Ring in x, y over Rational Field

sage: g = FFPD(x + y, [])

sage: t = FractionWithFactoredDenominatorSum([g])

sage: t.denominator_ring

Multivariate Polynomial Ring in x, y over Rational Field

"""

for r in self:

return r.denominator_ring

return None

def whole_and_parts(self):

r"""

Rewrite ``self`` as a sum of a (possibly zero) polynomial

followed by reduced rational expressions.

OUTPUT:

An instance of :class:`FractionWithFactoredDenominatorSum`.

Only useful for multivariate decompositions.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R, SR)

sage: f = x**2 + 3*y + 1/x + 1/y

sage: f = FFPD(f); f

(x^3*y + 3*x*y^2 + x + y, [(y, 1), (x, 1)])

sage: FractionWithFactoredDenominatorSum([f]).whole_and_parts()

(x^2 + 3*y, []) + (x + y, [(y, 1), (x, 1)])

sage: f = cos(x)**2 + 3*y + 1/x + 1/y; f

cos(x)^2 + 3*y + 1/x + 1/y

sage: G = f.numerator()

sage: H = R(f.denominator())

sage: f = FFPD(G, H.factor()); f

(x*y*cos(x)^2 + 3*x*y^2 + x + y, [(y, 1), (x, 1)])

sage: FractionWithFactoredDenominatorSum([f]).whole_and_parts()

(0, []) + (x*y*cos(x)^2 + 3*x*y^2 + x + y, [(y, 1), (x, 1)])

"""

whole = 0

parts = []

R = self.denominator_ring

for r in self:

# Since r has already passed through FFPD.__init__()'s reducing

# procedure, r is already in lowest terms.

# Check if can write r as a mixed fraction: whole + fraction.

p = r.numerator()

q = r.denominator()

if q == 1:

# r is already whole

whole += p

else:

try:

# Coerce p into R and divide p by q

p = R(p)

a, b = p.quo_rem(q)

except TypeError:

# p is not in R and so can't divide p by q

a = 0

b = p

whole += a

parts.append(r.parent()(b, r.denominator_factored(), reduce=False))

return FractionWithFactoredDenominatorSum(

[r.parent()(whole, ())] + parts) # r.parent() is not the nicest here

def _combine_like_terms_(self):

r"""

Combine terms in ``self`` with the same denominator.

Only useful for multivariate decompositions.

OUTPUT:

An instance of :class:`FractionWithFactoredDenominatorSum`.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R, SR)

sage: f = FFPD(1/(x * y * (x*y + 1)))

sage: g = FFPD(x/(x * y * (x*y + 1)))

sage: s = FractionWithFactoredDenominatorSum([f, g, f])

sage: t = s._combine_like_terms_()

sage: s

(1, [(y, 1), (x, 1), (x*y + 1, 1)]) +

(1, [(y, 1), (x*y + 1, 1)]) +

(1, [(y, 1), (x, 1), (x*y + 1, 1)])

sage: t

(1, [(y, 1), (x*y + 1, 1)]) + (2, [(y, 1), (x, 1), (x*y + 1, 1)])

sage: H = x * y * (x*y + 1)

sage: f = FFPD(1, H.factor())

sage: g = FFPD(exp(x + y), H.factor())

sage: s = FractionWithFactoredDenominatorSum([f, g])

sage: s

(1, [(y, 1), (x, 1), (x*y + 1, 1)]) +

(e^(x + y), [(y, 1), (x, 1), (x*y + 1, 1)])

sage: t = s._combine_like_terms_()

sage: t

(e^(x + y) + 1, [(y, 1), (x, 1), (x*y + 1, 1)])

"""

if not self:

return self

from operator import methodcaller

# Combine like terms.

FFPDs = sorted(self, key=methodcaller('_total_order_key_'))

new_FFPDs = []

temp = FFPDs[0]

for f in FFPDs[1:]:

if temp.denominator_factored() == f.denominator_factored():

# Add f to temp.

num = temp.numerator() + f.numerator()

temp = f.parent()(num, temp.denominator_factored())

else:

# Append temp to new_FFPDs and update temp.

new_FFPDs.append(temp)

temp = f

new_FFPDs.append(temp)

return FractionWithFactoredDenominatorSum(new_FFPDs)

def sum(self):

r"""

Return the sum of the elements in ``self``.

OUTPUT:

An instance of :class:`FractionWithFactoredDenominator`.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, FractionWithFactoredDenominatorSum

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R, SR)

sage: df = (x, 1), (y, 1), (x*y + 1, 1)

sage: f = FFPD(2, df)

sage: g = FFPD(2*x*y, df)

sage: FractionWithFactoredDenominatorSum([f, g])

(2, [(y, 1), (x, 1), (x*y + 1, 1)]) + (2, [(x*y + 1, 1)])

sage: FractionWithFactoredDenominatorSum([f, g]).sum()

(2, [(y, 1), (x, 1)])

sage: f = FFPD(cos(x), [(x, 2)])

sage: g = FFPD(cos(y), [(x, 1), (y, 2)])

sage: FractionWithFactoredDenominatorSum([f, g])

(cos(x), [(x, 2)]) + (cos(y), [(y, 2), (x, 1)])

sage: FractionWithFactoredDenominatorSum([f, g]).sum()

(y^2*cos(x) + x*cos(y), [(y, 2), (x, 2)])

"""

if not self:

return self

# Compute the sum's numerator and denominator.

R = self.denominator_ring

summy = sum((f.quotient() for f in self))

numer = summy.numerator()

denom = R(summy.denominator())

# Compute the sum's denominator factorization.

# Could use the factor() command, but it's probably faster to use

# the irreducible factors of the denominators of self.

df = [] # The denominator factorization for the sum.

if denom == 1:

# Done

return FractionWithFactoredDenominatorRing(numer.parent())(numer, df, reduce=False)

factors = []

for f in self:

factors.extend([q for (q, e) in f.denominator_factored()])

# Eliminate repeats from factors and sort.

factors = sorted(list(set(factors)))

# The irreducible factors of denom lie in factors.

# Use this fact to build df.

for q in factors:

e = 0

quo, rem = denom.quo_rem(q)

while rem == 0:

e += 1

denom = quo

quo, rem = denom.quo_rem(q)

if e > 0:

df.append((q, e))

return FractionWithFactoredDenominatorRing(numer.parent())(numer, df, reduce=False)

#####################################################################

## Helper functions

def diff_prod(f_derivs, u, g, X, interval, end, uderivs, atc):

r"""

Take various derivatives of the equation `f = ug`,

evaluate them at a point `c`, and solve for the derivatives of `u`.

INPUT:

- ``f_derivs`` -- a dictionary whose keys are all tuples of the form

``s + end``, where ``s`` is a sequence of variables from ``X`` whose

length lies in ``interval``, and whose values are the derivatives

of a function `f` evaluated at `c`

- ``u`` -- a callable symbolic function

- ``g`` -- an expression or callable symbolic function

- ``X`` -- a list of symbolic variables

- ``interval`` -- a list of positive integers

Call the first and last values `n` and `nn`, respectively

- ``end`` -- a possibly empty list of repetitions of the

variable ``z``, where ``z`` is the last element of ``X``

- ``uderivs`` -- a dictionary whose keys are the symbolic

derivatives of order 0 to order `n-1` of ``u`` evaluated at `c`

and whose values are the corresponding derivatives evaluated at `c`

- ``atc`` -- a dictionary whose keys are the keys of `c` and all

the symbolic derivatives of order 0 to order `nn` of ``g``

evaluated `c` and whose values are the corresponding

derivatives evaluated at `c`

OUTPUT:

A dictionary whose keys are the derivatives of ``u`` up to order

`nn` and whose values are those derivatives evaluated at `c`.

This function works by differentiating the equation `f = ug`

with respect to the variable sequence ``s + end``,

for all tuples ``s`` of ``X`` of lengths in ``interval``,

evaluating at the point `c` ,

and solving for the remaining derivatives of ``u``.

This function assumes that ``u`` never appears in the

differentiations of `f = ug` after evaluating at `c`.

.. NOTE::

For internal use by

:meth:`FractionWithFactoredDenominator.asymptotics_multiple()`.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import diff_prod

sage: u = function('u')(x)

sage: g = function('g')(x)

sage: fd = {(x,):1,(x, x):1}

sage: ud = {u(x=2): 1}

sage: atc = {x: 2, g(x=2): 3, diff(g, x)(x=2): 5}

sage: atc[diff(g, x, x)(x=2)] = 7

sage: dd = diff_prod(fd, u, g, [x], [1, 2], [], ud, atc)

sage: dd[diff(u, x, 2)(x=2)]

22/9

"""

from sage.symbolic.relation import solve

for l in interval:

D = {}

rhs = []

lhs = []

for t in combinations_with_replacement(X, l):

t = list(t)

s = t + end

lhs.append(f_derivs[tuple(s)])

rhs.append(diff(u * g, s).subs(atc).subs(uderivs))

# Since Sage's solve command can't take derivatives as variable

# names, make new variables based on t to stand in for

# diff(u, t) and store them in D.

D[diff(u, t).subs(atc)] = var('zing' +

''.join(str(x) for x in t))

eqns = [lhs[i] == rhs[i].subs(uderivs).subs(D)

for i in range(len(lhs))]

variables = D.values()

sol = solve(eqns, *variables, solution_dict=True)

uderivs.update(subs_all(D, sol[ZZ.zero()]))

return uderivs

def permutation_sign(s, u):

r"""

This function returns the sign of the permutation on

``1, ..., len(u)`` that is induced by the sublist ``s`` of ``u``.

.. NOTE::

For internal use by

:meth:`FractionWithFactoredDenominator.cohomology_decomposition()`.

INPUT:

- ``s`` -- a sublist of ``u``

- ``u`` -- a list

OUTPUT:

The sign of the permutation obtained by taking indices

within ``u`` of the list ``s + sc``, where ``sc`` is ``u``

with the elements of ``s`` removed.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import permutation_sign

sage: u = ['a', 'b', 'c', 'd', 'e']

sage: s = ['b', 'd']

sage: permutation_sign(s, u)

-1

sage: s = ['d', 'b']

sage: permutation_sign(s, u)

1

"""

from sage.combinat.permutation import Permutation

# Convert lists to lists of numbers in {1,..., len(u)}

A = [i + 1 for i in range(len(u))]

B = [u.index(x) + 1 for x in s]

C = sorted(set(A).difference(set(B)))

P = Permutation(B + C)

return P.signature()

def subs_all(f, sub, simplify=False):

r"""

Return the items of `f` substituted by the dictionaries

of ``sub`` in order of their appearance in ``sub``.

INPUT:

- ``f`` -- an individual or list of symbolic expressions

or dictionaries

- ``sub`` -- an individual or list of dictionaries

- ``simplify`` -- (default: ``False``) boolean; set to ``True`` to

simplify the result

OUTPUT:

The items of ``f`` substituted by the dictionaries of ``sub`` in order

of their appearance in ``sub``. The ``subs()`` command is used. If

simplify is ``True``, then ``simplify()`` is used after substitution.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import subs_all

sage: var('x, y, z')

(x, y, z)

sage: a = {x:1}

sage: b = {y:2}

sage: c = {z:3}

sage: subs_all(x + y + z, a)

y + z + 1

sage: subs_all(x + y + z, [c, a])

y + 4

sage: subs_all([x + y + z, y^2], b)

[x + z + 2, 4]

sage: subs_all([x + y + z, y^2], [b, c])

[x + 5, 4]

::

sage: var('x, y')

(x, y)

sage: a = {'foo': x**2 + y**2, 'bar': x - y}

sage: b = {x: 1 , y: 2}

sage: subs_all(a, b)

{'bar': -1, 'foo': 5}

"""

singleton = False

if not isinstance(f, (list, tuple)):

f = [f]

singleton = True

if not isinstance(sub, (list, tuple)):

sub = [sub]

g = []

for ff in f:

for D in sub:

if isinstance(ff, dict):

ff = {k: ff[k].subs(D) for k in ff}

else:

ff = ff.subs(D)

g.append(ff)

if singleton and simplify:

if isinstance(g[0], dict):

return g[0]

return g[0].simplify()

if singleton and not simplify:

return g[0]

if not singleton and simplify:

G = []

for gg in g:

if isinstance(gg, dict):

G.append(gg)

else:

G.append(gg.simplify())

return G

return g

def diff_all(f, V, n, ending=[], sub=None, sub_final=None,

zero_order=0, rekey=None):

r"""

Return a dictionary of representative mixed partial

derivatives of `f` from order 1 up to order `n` with respect to the

variables in `V`.

The default is to key the dictionary by all nondecreasing sequences

in `V` of length 1 up to length `n`.

INPUT:

- ``f`` -- an individual or list of `\mathcal{C}^{n+1}` functions

- ``V`` -- a list of variables occurring in `f`

- ``n`` -- a natural number

- ``ending`` -- a list of variables in `V`

- ``sub`` -- an individual or list of dictionaries

- ``sub_final`` -- an individual or list of dictionaries

- ``rekey`` -- a callable symbolic function in `V` or list thereof

- ``zero_order`` -- a natural number

OUTPUT:

The dictionary ``{s_1:deriv_1, ..., sr:deriv_r}``.

Here ``s_1, ..., s_r`` is a listing of

all nondecreasing sequences of length 1 up to length `n` over the

alphabet `V`, where `w > v` in `X` if and only if ``str(w) > str(v)``,

and ``deriv_j`` is the derivative of `f` with respect to the derivative

sequence ``s_j`` and simplified with respect to the substitutions in

``sub`` and evaluated at ``sub_final``.

Moreover, all derivatives with respect to sequences of length less than

``zero_order`` (derivatives of order less than ``zero_order`` )

will be made zero.

If ``rekey`` is nonempty, then ``s_1, ..., s_r`` will be replaced

by the symbolic derivatives of the functions in ``rekey``.

If ``ending`` is nonempty, then every derivative sequence ``s_j``

will be suffixed by ``ending``.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import diff_all

sage: f = function('f')(x)

sage: dd = diff_all(f, [x], 3)

sage: dd[(x, x, x)]

diff(f(x), x, x, x)

sage: d1 = {diff(f, x): 4*x^3}

sage: dd = diff_all(f, [x], 3, sub=d1)

sage: dd[(x, x, x)]

24*x

sage: dd = diff_all(f, [x], 3, sub=d1, rekey=f)

sage: dd[diff(f, x, 3)]

24*x

sage: a = {x:1}

sage: dd = diff_all(f, [x], 3, sub=d1, rekey=f, sub_final=a)

sage: dd[diff(f, x, 3)]

24

::

sage: X = var('x, y, z')

sage: f = function('f')(*X)

sage: dd = diff_all(f, X, 2, ending=[y, y, y])

sage: dd[(z, y, y, y)]

diff(f(x, y, z), y, y, y, z)

::

sage: g = function('g')(*X)

sage: dd = diff_all([f, g], X, 2)

sage: dd[(0, y, z)]

diff(f(x, y, z), y, z)

sage: dd[(1, z, z)]

diff(g(x, y, z), z, z)

sage: f = exp(x*y*z)

sage: ff = function('ff')(*X)

sage: dd = diff_all(f, X, 2, rekey=ff)

sage: dd[diff(ff, x, z)]

x*y^2*z*e^(x*y*z) + y*e^(x*y*z)

"""

singleton = False

if not isinstance(f, list):

f = [f]

singleton = True

# Build the dictionary of derivatives iteratively from a list

# of nondecreasing derivative-order sequences.

derivs = {}

r = len(f)

if ending:

seeds = [ending]

start = ZZ.one()

else:

seeds = [[v] for v in V]

start = Integer(2)

if singleton:

for s in seeds:

derivs[tuple(s)] = subs_all(diff(f[0], s), sub)

for l in range(start, n + 1):

for t in combinations_with_replacement(V, l):

s = t + tuple(ending)

derivs[s] = subs_all(diff(derivs[s[1:]], s[0]), sub)

else:

# Make the dictionary keys of the form (j, sequence of variables),

# where j in range(r).

for s in seeds:

value = subs_all([diff(f[j], s) for j in range(r)], sub)

derivs.update({tuple([j] + s): value[j] for j in range(r)})

for l in range(start, n + 1):

for t in combinations_with_replacement(V, l):

s = t + tuple(ending)

value = subs_all([diff(derivs[(j,) + s[1:]], s[0]) for j in range(r)], sub)

derivs.update({(j,) + s: value[j] for j in range(r)})

if zero_order:

# Zero out all the derivatives of order < zero_order

if singleton:

for k in derivs:

if len(k) < zero_order:

derivs[k] = ZZ.zero()

else:

# Ignore the first of element of k, which is an index.

for k in derivs:

if len(k) - 1 < zero_order:

derivs[k] = ZZ.zero()

if sub_final:

# Substitute sub_final into the values of derivs.

for k in derivs:

derivs[k] = subs_all(derivs[k], sub_final)

if rekey:

# Rekey the derivs dictionary by the value of rekey.

F = rekey

if singleton:

# F must be a singleton.

derivs = {diff(F, list(k)): derivs[k] for k in derivs}

else:

# F must be a list.

derivs = {diff(F[k[0]], list(k)[1:]): derivs[k] for k in derivs}

return derivs

def diff_op(A, B, AB_derivs, V, M, r, N):

r"""

Return the derivatives `DD^{(l+k)}(A[j] B^l)` evaluated at a point

`p` for various natural numbers `j, k, l` which depend on `r` and `N`.

Here `DD` is a specific second-order linear differential operator

that depends on `M` , `A` is a list of symbolic functions,

`B` is symbolic function, and ``AB_derivs`` contains all the derivatives

of `A` and `B` evaluated at `p` that are necessary for the computation.

INPUT:

- ``A`` -- a single or length ``r`` list of symbolic functions in the

variables ``V``

- ``B`` -- a symbolic function in the variables ``V``.

- ``AB_derivs`` -- a dictionary whose keys are the (symbolic)

derivatives of ``A[0], ..., A[r-1]`` up to order ``2 * N-2`` and

the (symbolic) derivatives of ``B`` up to order ``2 * N``;

the values of the dictionary are complex numbers that are

the keys evaluated at a common point `p`

- ``V`` -- the variables of the ``A[j]`` and ``B``

- ``M`` -- a symmetric `l \times l` matrix, where `l` is the

length of ``V``

- ``r, N`` -- natural numbers

OUTPUT:

A dictionary.

The output is

a dictionary whose keys are natural number tuples of the form

`(j, k, l)`, where `l \leq 2k`, `j \leq r-1`, and `j+k \leq N-1`,

and whose values are `DD^(l+k)(A[j] B^l)` evaluated at a point

`p`, where `DD` is the linear second-order differential operator

`-\sum_{i=0}^{l-1} \sum_{j=0}^{l-1} M[i][j]

\partial^2 /(\partial V[j] \partial V[i])`.

.. NOTE::

For internal use by

:meth:`FractionWithFactoredDenominator.asymptotics_smooth()` and

:meth:`FractionWithFactoredDenominator.asymptotics_multiple()`.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import diff_op

sage: T = var('x, y')

sage: A = function('A')(*tuple(T))

sage: B = function('B')(*tuple(T))

sage: AB_derivs = {}

sage: M = matrix([[1, 2],[2, 1]])

sage: DD = diff_op(A, B, AB_derivs, T, M, 1, 2)

sage: sorted(DD)

[(0, 0, 0), (0, 1, 0), (0, 1, 1), (0, 1, 2)]

sage: len(DD[(0, 1, 2)])

246

"""

from itertools import product

from sage.misc.mrange import xmrange

if not isinstance(A, list):

A = [A]

# First, compute the necessary product derivatives of A and B.

product_derivs = {}

for j, k in xmrange([r, N], tuple):

if j + k < N:

for l in range(2 * k + 1):

for s in combinations_with_replacement(V, 2 * (k + l)):

DF = diff(A[j] * B ** l, list(s)).subs(AB_derivs)

product_derivs[(j, k, l) + s] = DF

# Second, compute DD^(k+l)(A[j]*B^l)(p) and store values in dictionary.

DD = {}

rows = M.nrows()

for j, k in xmrange([r, N], tuple):

if j + k < N:

for l in range(2 * k + 1):

# Take advantage of the symmetry of M by ignoring

# the upper-diagonal entries of M and multiplying by

# appropriate powers of 2.

if k + l == 0:

DD[(j, k, l)] = product_derivs[(j, k, l)]

continue

S = [(a, b) for a, b in xmrange([rows, rows], tuple) if b <= a]

P = product(S, repeat=k + l)

diffo = ZZ.zero()

for t in P:

idx = (j, k, l) + diff_seq(V, t)

if product_derivs[idx] != ZZ.zero():

MM = ZZ.one()

for (a, b) in t:

MM *= M[a][b]

if a != b:

MM *= Integer(2)

diffo += MM * product_derivs[idx]

DD[(j, k, l)] = (-ZZ.one()) ** (k + l) * diffo

return DD

def diff_seq(V, s):

r"""

Given a list ``s`` of tuples of natural numbers, return the

list of elements of ``V`` with indices the elements of the elements

of ``s``.

INPUT:

- ``V`` -- a list

- ``s`` -- a list of tuples of natural numbers in the interval

``range(len(V))``

OUTPUT:

The tuple ``tuple([V[tt] for tt in sorted(t)])``, where ``t`` is the

list of elements of the elements of ``s``.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import diff_seq

sage: V = list(var('x, t, z'))

sage: diff_seq(V,([0, 1],[0, 2, 1],[0, 0]))

(x, x, x, x, t, t, z)

.. NOTE::

This function is for internal use by :func:`diff_op()`.

"""

t = []

for ss in s:

t.extend(ss)

return tuple([V[tt] for tt in sorted(t)])

def diff_op_simple(A, B, AB_derivs, x, v, a, N):

r"""

Return `DD^(e k + v l)(A B^l)` evaluated at a point `p` for

various natural numbers `e, k, l` that depend on `v` and `N`.

Here `DD` is a specific linear differential operator that depends

on `a` and `v` , `A` and `B` are symbolic functions, and `AB_derivs`

contains all the derivatives of `A` and `B` evaluated at `p` that are

necessary for the computation.

.. NOTE::

For internal use by the function

:meth:`FractionWithFactoredDenominator.asymptotics_smooth()`.

INPUT:

- ``A, B`` -- Symbolic functions in the variable ``x``

- ``AB_derivs`` - a dictionary whose keys are the (symbolic)

derivatives of ``A`` up to order ``2 * N`` if ``v`` is even or

``N`` if ``v`` is odd and the (symbolic) derivatives of ``B``

up to order ``2 * N + v`` if ``v`` is even or ``N + v``

if ``v`` is odd; the values of the dictionary are complex numbers

that are the keys evaluated at a common point `p`

- ``x`` -- a symbolic variable

- ``a`` -- a complex number

- ``v, N`` -- natural numbers

OUTPUT:

A dictionary.

The output is

a dictionary whose keys are natural number pairs of the form `(k, l)`,

where `k < N` and `l \leq 2k` and whose values are

`DD^(e k + v l)(A B^l)` evaluated at a point `p`.

Here `e=2` if `v` is even, `e=1` if `v` is odd, and `DD` is the

linear differential operator

`(a^{-1/v} d/dt)` if `v` is even and

`(|a|^{-1/v} i \text{sgn}(a) d/dt)` if `v` is odd.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import diff_op_simple

sage: A = function('A')(x)

sage: B = function('B')(x)

sage: AB_derivs = {}

sage: sorted(diff_op_simple(A, B, AB_derivs, x, 3, 2, 2).items())

[((0, 0), A(x)),

((1, 0), 1/2*I*2^(2/3)*diff(A(x), x)),

((1, 1),

1/4*2^(2/3)*(B(x)*diff(A(x), x, x, x, x) + 4*diff(A(x), x, x, x)*diff(B(x), x) + 6*diff(A(x), x, x)*diff(B(x), x, x) + 4*diff(A(x), x)*diff(B(x), x, x, x) + A(x)*diff(B(x), x, x, x, x)))]

"""

from sage.functions.other import sqrt

I = sqrt(-ZZ.one())

DD = {}

if v.mod(Integer(2)) == ZZ.zero():

for k in range(N):

for l in range(2 * k + 1):

DD[(k, l)] = ((a ** (-ZZ.one() / v)) ** (2 * k + v * l) *

diff(A * B ** l, x,

2 * k + v * l).subs(AB_derivs))

else:

for k in range(N):

for l in range(k + 1):

DD[(k, l)] = ((abs(a) ** (-ZZ.one() / v) * I *

a / abs(a)) ** (k + v * l) *

diff(A * B ** l, x,

k + v * l).subs(AB_derivs))

return DD

def direction(v, coordinate=None):

r"""

Return ``[vv/v[coordinate] for vv in v]`` where

``coordinate`` is the last index of ``v`` if not specified otherwise.

INPUT:

- ``v`` -- a vector

- ``coordinate`` -- (optional; default: ``None``) an index for ``v``

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import direction

sage: direction([2, 3, 5])

(2/5, 3/5, 1)

sage: direction([2, 3, 5], 0)

(1, 3/2, 5/2)

"""

if coordinate is None:

coordinate = len(v) - 1

return tuple([vv / v[coordinate] for vv in v])

def coerce_point(R, p):

r"""

Coerce the keys of the dictionary ``p`` into the ring ``R``.

.. WARNING::

This method assumes that it is possible.

EXAMPLES::

sage: from sage.rings.asymptotic.asymptotics_multivariate_generating_functions import FractionWithFactoredDenominatorRing, coerce_point

sage: R.<x,y> = PolynomialRing(QQ)

sage: FFPD = FractionWithFactoredDenominatorRing(R)

sage: f = FFPD()

sage: p = {SR(x): 1, SR(y): 7/8}

sage: for k in sorted(p, key=str):

....: print("{} {} {}".format(k, k.parent(), p[k]))

x Symbolic Ring 1

y Symbolic Ring 7/8

sage: q = coerce_point(R, p)

sage: for k in sorted(q, key=str):

....: print("{} {} {}".format(k, k.parent(), q[k]))

x Multivariate Polynomial Ring in x, y over Rational Field 1

y Multivariate Polynomial Ring in x, y over Rational Field 7/8

"""

if p and list(p)[0].parent() != R:

try:

return {x: p[SR(x)] for x in R.gens()}

except TypeError:

pass

return p

« index coverage.py v4.5.1, created at 2018-05-01 10:21