Boilerplate to make the doctester work.
In [68]:
import sys
import os
sys.path.insert(1, os.path.join(os.path.pardir, "ipython_doctester"))
from sympy import *
from ipython_doctester import test
x, y, z = symbols('x y z')
For each exercise, fill in the function according to its docstring. Execute the cell to see if you did it right.
In each exercise, apply specific simplification functions to get the desired result.
In [69]:
@test
def polysimp1(expr):
"""
>>> polysimp1(cos(x)*sin(x) + cos(x))
(sin(x) + 1)*cos(x)
>>> polysimp1(cos(x)*sin(x) + cos(x) + 1)
(sin(x) + 1)*cos(x) + 1
"""
return collect(expr, cos(x))
In [70]:
@test
def polysimp2(expr):
"""
>>> polysimp2((2*x + 1)/(x**2 + x))
1/(x + 1) + 1/x
>>> polysimp2((x**2 + 3*x + 1)/(x**3 + 2*x**2 + x))
1/(x**2 + 2*x + 1) + 1/x
"""
return expand(apart(expr))
In each exercise, apply specific simplification functions to get the desired result.
In [71]:
@test
def powersimp1(expr):
"""
>>> powersimp1(exp(x)*(exp(y) + 1))
exp(x) + exp(x + y)
"""
return powsimp(expand(expr))
In [72]:
@test
def powersimp2(expr):
"""
>>> powersimp2(2**x*x**x)
(2*x)**x
>>> powersimp2(x**x*x**x)
(x**2)**x
"""
return powsimp(expr, force=True)
In [73]:
@test
def powersimp3(expr):
"""
>>> a, b, c = symbols('a b c')
>>> powersimp3((a**b)**c)
a**(b*c)
>>> powersimp3((a**b)**(c + 1))
a**(b*c + b)
"""
return powdenest(expand_power_exp(expr), force=True)
In [74]:
@test
def logsimp1(expr):
"""
>>> a, b = symbols('a b', positive=True)
>>> logsimp1(log(x**y*a**b))
y*log(x) + log(a**b)
>>> logsimp1(log(x*y*a*b))
log(x) + log(y) + log(a*b)
"""
return logcombine(expand_log(expr, force=True))
In [75]:
@test
def miscsimp1(expr):
"""
>>> miscsimp1(sin(x + y))
2*(-tan(x/2)**2 + 1)*tan(y/2)/((tan(x/2)**2 + 1)*(tan(y/2)**2 + 1)) + 2*(-tan(y/2)**2 + 1)*tan(x/2)/((tan(x/2)**2 + 1)*(tan(y/2)**2 + 1))
"""
return expand_trig(expr).rewrite(tan)
In [66]:
@test
def miscsimp2(expr):
"""
>>> miscsimp2(gamma(x + 4))
x**4*gamma(x) + 6*x**3*gamma(x) + 11*x**2*gamma(x) + 6*x*gamma(x)
"""
return expand(expand_func(expr))
In [77]:
def list_to_frac(l):
expr = Integer(0)
for i in reversed(l[1:]):
expr += i
expr = 1/expr
return l[0] + expr
In [78]:
a0, a1, a2, a3, a4 = symbols('a0:5')
Determine the list used to create the continued fraction $$\frac{a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{3} a_{4} + a_{0} + a_{1} a_{2} a_{3} + a_{1} a_{3} a_{4} + a_{1} + a_{3}}{a_{0} a_{1} a_{2} a_{4} + a_{0} a_{4} + a_{1} a_{2} + a_{1} a_{4} + 1}.$$
In [88]:
@test
def continued_frac():
"""
Determine the original list used to create the fraction.
Return the original list from this function.
>>> orig_frac = (a0*a1*a2*a3*a4 + a0*a1*a2 + a0*a3*a4 + a0 + a1*a2*a3 + a1*a3*a4 + a1 + a3)/(a0*a1*a2*a4 + a0*a4 + a1*a2 + a1*a4 + 1)
>>> pprint(orig_frac, use_unicode=False, wrap_line=False)
a0*a1*a2*a3*a4 + a0*a1*a2 + a0*a3*a4 + a0 + a1*a2*a3 + a1*a3*a4 + a1 + a3
-------------------------------------------------------------------------
a0*a1*a2*a4 + a0*a4 + a1*a2 + a1*a4 + 1
>>> cancel(list_to_frac(continued_frac())) == orig_frac
True
"""
return [a3, a4, a0, a2, a1]
In [ ]: