def _symbolgen(*symbols):
"""
Generator of all symbols in the argument of the Derivative.
Example:
>> ._symbolgen(x, 3, y)
(x, x, x, y)
>> ._symbolgen(x, 10**6)
(x, x, x, x, x, x, x, ...)
The second example shows why we don't return a list, but a generator,
so that the code that calls _symbolgen can return earlier for special
cases, like x.diff(x, 10**6).
"""
last_s = sympify(symbols[len(symbols) - 1])
for i in xrange(len(symbols)):
s = sympify(symbols[i])
next_s = None
if s != last_s:
next_s = sympify(symbols[i + 1])
if isinstance(s, Integer):
continue
elif isinstance(s, Symbol):
# handle cases like (x, 3)
if isinstance(next_s, Integer):
# yield (x, x, x)
for copy_s in repeat(s, int(next_s)):
yield copy_s
else:
yield s
else:
yield s
def __new__(cls, expr, *symbols, **assumptions):
expr = sympify(expr)
if not symbols: return expr
symbols = Derivative._symbolgen(*symbols)
if not assumptions.get("evaluate", False) and not isinstance(
expr, Derivative):
obj = Basic.__new__(cls, expr, *symbols)
return obj
unevaluated_symbols = []
for s in symbols:
s = sympify(s)
if not isinstance(s, Symbol):
raise ValueError(
'Invalid literal: %s is not a valid variable' % s)
if not expr.has(s):
return S.Zero
obj = expr._eval_derivative(s)
if obj is None:
unevaluated_symbols.append(s)
elif obj is S.Zero:
return S.Zero
else:
expr = obj
if not unevaluated_symbols:
return expr
return Basic.__new__(cls, expr, *unevaluated_symbols)
def __new__(cls, expr, *symbols, **assumptions):
expr = sympify(expr)
if not symbols: return expr
symbols = Derivative._symbolgen(*symbols)
if expr.is_commutative:
assumptions["commutative"] = True
if assumptions.has_key("evaluate"):
evaluate = assumptions["evaluate"]
del assumptions["evaluate"]
else:
evaluate = False
if not evaluate and not isinstance(expr, Derivative):
obj = Basic.__new__(cls, expr, *symbols, **assumptions)
return obj
unevaluated_symbols = []
for s in symbols:
s = sympify(s)
if not isinstance(s, Symbol):
raise ValueError('Invalid literal: %s is not a valid variable' % s)
if not expr.has(s):
return S.Zero
obj = expr._eval_derivative(s)
if obj is None:
unevaluated_symbols.append(s)
elif obj is S.Zero:
return S.Zero
else:
expr = obj
if not unevaluated_symbols:
return expr
return Basic.__new__(cls, expr, *unevaluated_symbols, **assumptions)
def _symbolgen(*symbols):
"""
Generator of all symbols in the argument of the Derivative.
Example:
>> ._symbolgen(x, 3, y)
(x, x, x, y)
>> ._symbolgen(x, 10**6)
(x, x, x, x, x, x, x, ...)
The second example shows why we don't return a list, but a generator,
so that the code that calls _symbolgen can return earlier for special
cases, like x.diff(x, 10**6).
"""
last_s = sympify(symbols[len(symbols)-1])
for i in xrange(len(symbols)):
s = sympify(symbols[i])
next_s = None
if s != last_s:
next_s = sympify(symbols[i+1])
if isinstance(s, Integer):
continue
elif isinstance(s, Symbol):
# handle cases like (x, 3)
if isinstance(next_s, Integer):
# yield (x, x, x)
for copy_s in repeat(s,int(next_s)):
yield copy_s
else:
yield s
else:
yield s
def matches(pattern, expr, repl_dict={}, evaluate=False):
expr = sympify(expr)
if pattern.is_commutative and expr.is_commutative:
return AssocOp._matches_commutative(pattern, expr, repl_dict,
evaluate)
# todo for commutative parts, until then use the default matches method for non-commutative products
return Basic.matches(pattern, expr, repl_dict, evaluate)
def taylor_term(cls, n, x, *previous_terms):
"""General method for the taylor term.
This method is slow, because it differentiates n-times. Subclasses can
redefine it to make it faster by using the "previous_terms".
"""
x = sympify(x)
return cls(x).diff(x, n).subs(x, 0) * x**n / C.Factorial(n)
def taylor_term(cls, n, x, *previous_terms):
"""General method for the taylor term.
This method is slow, because it differentiates n-times. Subclasses can
redefine it to make it faster by using the "previous_terms".
"""
x = sympify(x)
return cls(x).diff(x, n).subs(x, 0) * x**n / C.Factorial(n)
def expand(e, **hints):
"""
Expand an expression using hints.
This is just a wrapper around Basic.expand(), see it's docstring of for a
thourough docstring for this function. In isympy you can just type
Basic.expand? and enter.
"""
return sympify(e).expand(**hints)
def expand(e, **hints):
"""
Expand an expression using hints.
This is just a wrapper around Basic.expand(), see it's docstring of for a
thourough docstring for this function. In isympy you can just type
Basic.expand? and enter.
"""
return sympify(e).expand(**hints)
def __xnew__(cls, name, exclude, properties, **assumptions):
obj = Symbol.__xnew__(cls, name, **assumptions)
if exclude is None:
obj.exclude = None
else:
obj.exclude = tuple([sympify(x) for x in exclude])
if properties is None:
obj.properties = None
else:
obj.properties = tuple(properties)
return obj
def __xnew__(cls, name, exclude, properties, **assumptions):
obj = Symbol.__xnew__(cls, name, **assumptions)
if exclude is None:
obj.exclude = None
else:
obj.exclude = tuple([sympify(x) for x in exclude])
if properties is None:
obj.properties = None
else:
obj.properties = tuple(properties)
return obj
def matches(pattern, expr, repl_dict={}, evaluate=False):
expr = sympify(expr)
if pattern.is_commutative and expr.is_commutative:
return AssocOp._matches_commutative(pattern, expr, repl_dict, evaluate)
# todo for commutative parts, until then use the default matches method for non-commutative products
return Basic.matches(pattern, expr, repl_dict, evaluate)