def problem_3_tangent():
fex = make_e_expr(make_pwr('x', 1.0))
print("f(x)= ", fex)
drv = deriv(fex)
print("f'(x)= ", drv)
drvf = tof(drv)
print("f'(-1)= ", drvf(-1))
def test_06(self):
#x^-3+7e^(5x)+4*x^-1 => (1/-2)*(x^-2)+0 +(7*(1/5)*e(5x)+ (4*ln|x|)
print("****Unit Test 06********")
fex1 = make_pwr('x', -3.0)
fex2 = make_prod(
make_const(7.0),
make_e_expr(make_prod(make_const(5.0), make_pwr('x', 1.0))))
fex3 = make_prod(make_const(4.0), make_pwr('x', -1.0))
fex4 = make_plus(fex1, fex2)
fex = make_plus(fex4, fex3)
print(fex)
afex = antideriv(fex)
assert not afex is None
def gt(x):
v1 = -0.5 * (x**(-2.0))
v2 = (7.0 / 5.0) * (math.e**(5.0 * x))
v3 = 4.0 * (math.log(abs(x), math.e))
return v1 + v2 + v3
afexf = tof(afex)
assert not afexf is None
err = 0.001
for i in range(1, 10):
print(afexf(i), gt(i))
assert abs(afexf(i) - gt(i)) <= err * gt(i)
print("Unit Test 06 pass")
def solve_pdeq(k1, k2):
#k1*y' = k2*y
assert isinstance(k1, const)
assert isinstance(k2, const)
return make_prod(
make_const(1.0),
make_e_expr(make_prod(make_quot(k2, k1), make_pwr('t', 1.0))))
def spread_of_news_model(p, k):
assert isinstance(p, const) and isinstance(k, const)
#t0 = 4
#t1 = ?
#p = .5 * P => P(1 - e^(-k*4)) = .5*P (where t=4) => k = -0.25*ln(0.5) ~= 1.73 => f(t) = P(1 - e^(-1.73*t))
#p1 = .9 * P (p0 and p1 given)
#we can now compute t1
#0.9*P = P(1 - e^(-1.73*t)) => t ~= 13.3
#generally
#f(t) = P(1-e^(-kt)) we know that f(0) = 0
#where p0 is initial knowing pop at time t0
#and p1 is pop at time t1
#return f(t)
#where f(t) = p*(1 - e^(-k*t))
#where k = (1/t0)*ln(p0)
#so return p*(1 - e^(( -( (1/t0)*ln(p0) ) )*t)) #if given p0 and t0
#we are given k so:
#return p*(1 - e^(-k*t))
return prod(
p,
plus(
1,
prod(const(-1.0),
make_e_expr(prod(prod(const(-1), k), make_pwr('t', 1))))))
def spread_of_disease_model(p, t0, p0, t1, p1):
assert isinstance(p, const) and isinstance(t0, const)
assert isinstance(p0, const) and isinstance(t1, const)
#f(t) = P/(1+B*e^(-c*t))
#p = 500,000
#let t0 = 0 such that f(t0) = f(0)
#this would make t1 = delta_t
#where delta_t = t1 - t0
#f(0) = p0 = 200 = 500,000/(1+B*e^0) = 500,000/(1+B) => B = 2499
#generally: B = (p-p0)/p0
#f(1) = p1 = 500 = 500,000/(1+2499*e^(-c*1)) => c = .92
#generally: c = -ln((p-p1)/(p1*B))/t
#so we get f(t) = p/(1+((p-p0)/p0)*e^(-(-ln((p-p1)/(p1*((p-p0)/p0))))*t))
#or f(t) = p/(1+((p-p0)/p0)*e^((ln((p-p1)/(p1*((p-p0)/p0)))/(t1-t0)*t))
#return f(t)
return quot(
p,
plus(
const(1.0),
prod(
quot(plus(p, prod(const(-1.0), p0)), p0),
make_e_expr(
ln(
prod(
quot(
quot(
plus(p, prod(const(-1.0), p1)),
prod(
p1,
quot(plus(p, prod(const(-1.0), p0)),
p0))),
plus(t1, prod(const(-1.0), t0))),
make_pwr('t', 1)))))))
def gt21_02(x):
''' ground truth for 2nd taylor of fexpr2_01. '''
fexpr2_01 = make_prod(make_pwr('x', 1.0), make_e_expr(make_pwr('x', 1.0)))
f0 = tof(fexpr2_01)
f1 = tof(deriv(fexpr2_01))
f2 = tof(deriv(deriv(fexpr2_01)))
return f0(2.0) + f1(2.0) * (x - 2.0) + (f2(2.0) / 2) * (x - 2.0)**2
def radioactive_decay(lmbda, p0, t):
assert isinstance(lmbda, const)
assert isinstance(p0, const)
assert isinstance(t, const)
#exponential decay is P(t) = p0 * e^(-lambda * t)
return prod(p0, make_e_expr(prod(lmbda, make_pwr('t', 1))))
def test_05():
fexpr2_01 = make_prod(make_pwr('x', 1.0), make_e_expr(make_pwr('x', 1.0)))
print(gt21_02(2.001))
fex = taylor_poly(fexpr2_01, make_const(2.001), make_const(2))
print(fex)
fex_tof = tof(fex)
print(fex_tof(2.001))
def plant_growth_model(m, t1, x1, t2, x2):
assert isinstance(m, const) and isinstance(t1, const)
assert isinstance(x1, const) and isinstance(x2, const)
assert isinstance(x2, const)
#B,M,k
#M is 1000 (maximum population)
#B is 9 (which is (M-x1)/x1)
#k is 0.00037 (which is (ln((m-x2)/(x2*B))/(-M*(t2-t1))) )
#f(t) = M / (1+B*e^(-Mkt)
#or f(t) = m / (1+((m-x1)/x1)*e^(-Mkt))
return quot(
m,
plus(
const(1.0),
prod(
quot(plus(m, prod(const(-1.0), x1)), x1),
make_e_expr(
prod(
prod(
prod(const(-1.0), m),
quot(
ln(
plus(m, prod(const(-1.0), x2)),
prod(
x2,
quot(plus(m, prod(const(-1.0), x1)),
x1))),
prod(prod(const(-1.0), m),
plus(t2, prod(const(-1.0), t1))))),
make_pwr('t', 1))))))
def percent_retention_model(lmbda, a):
assert isinstance(lmbda, const)
assert isinstance(a, const)
#r(t) = (100 - a)*e^(-lmda*t) + a
return plus(
prod(plus(const(100.0), prod(const(-1.0), a)),
make_e_expr(prod(prod(const(-1.0), lmbda), make_pwr('t', 1)))), a)
def nra_ut_10():
''' Approximating e^(5-x) = 10 - x. '''
fexpr = make_e_expr(
make_plus(make_const(5.0),
make_prod(make_const(-1.0), make_pwr('x', 1.0))))
fexpr = make_plus(fexpr, make_pwr('x', 1.0))
fexpr = make_plus(fexpr, make_const(-10.0))
print(nra(fexpr, make_const(1.0), make_const(10000)))
def solve_pdeq_with_init_cond(y0, k):
assert isinstance(y0, const)
assert isinstance(k, const)
#y` = ky
#y(0) = P_0
#and
#y = P(t) = y(0)*e^(kt) = P_0*e^(kt)
#return y0 * e^(k*x)
return prod(y0, make_e_expr(prod(k, make_pwr('x', 1.0))))
def spread_of_news_model(p, k):
assert isinstance(p, const) and isinstance(k, const)
expon = const(-1.0 * k.get_val())
return make_prod(
p,
make_plus(
const(1.0),
make_prod(const(-1.0),
make_e_expr(make_prod(expon, make_pwr('t', 1.0))))))
def find_growth_model(p0, t, n):
assert isinstance(p0, const)
assert isinstance(t, const)
assert isinstance(n, const)
#p0 is C
#n is k
#t is t
return prod(p0, make_e_expr(prod(quot(ln(n), t), make_pwr('t', 1))))
def percent_retention_model(lmbda, a):
#r(t) = (100-a)e^(-lmbda*t) + a
assert isinstance(lmbda, const)
assert isinstance(a, const)
left = const(100.0 - a.get_val())
right = make_e_expr(
make_prod(const(-1.0 * lmbda.get_val()), make_pwr('t', 1.0)))
return make_plus(make_prod(left, right), a)
def problem_1_decay():
fex = make_e_expr(make_prod(const(-0.021), make_pwr('x', 1.0)))
print(fex)
P0 = const(8.0)
expr, decay_const = fun1(fex, P0)
print("f(x)= ", expr, "lambda=", decay_const)
remaining = fun2(expr, 3.0)
print("remaining= ", remaining)
remaining_after_n_years = fun3(expr, 33.0, 40.0)
print("after n years", remaining_after_n_years)
def solve_pdeq(k1, k2):
assert isinstance(k1, const)
assert isinstance(k2, const)
#k1*y` = k2*y
#y` = (k2/k1) * y
#let k2/k1 = k
#y` = k*y
#therefore y = C*e^(kt) and y` = k*C*e^(kt) or y` = (k2/k1)*C*e^(kt)
#I am going to let C = 1/k
#so we get:
#return e^((k2/k1)*x)
# return prod(quot(k2,k1), make_e_expr(prod(quot(k2,k1),make_pwr('x',1.0)))) #C = 1
return make_e_expr(prod(quot(k2, k1), make_pwr('x', 1.0))) #C = 1/k
def test_prob_01_ut_02(self):
print('\n***** Problem 01: UT 02 ************')
fex = make_e_expr(make_plus(make_pwr('x', 2.0),
make_const(-1.0)))
print(fex)
drv = deriv(fex)
assert not drv is None
print(drv)
drvf = tof(drv)
assert not drvf is None
gt = lambda x: 2*x*(math.e**(x**2 - 1.0))
err = 0.0001
for i in range(10):
#print(drvf(i), gt(i))
assert abs(gt(i) - drvf(i)) <= err
print('Problem 01: UT 02: pass')
def spread_of_disease_model(p, t0, p0, t1, p1):
assert isinstance(p, const) and isinstance(t0, const)
assert isinstance(p0, const) and isinstance(t1, const)
# find B
B = const(((p.get_val() / p0.get_val()) - 1.0) / math.e**(t0.get_val()))
x = const(((p.get_val() / p1.get_val()) - 1.0) / B.get_val())
#find k
k = const(math.log(x.get_val()) / (-1.0 * p.get_val() * t1.get_val()))
#simplify exponent before creating it
expon = const(-1.0 * p.get_val() * k.get_val())
bottom = make_plus(
make_const(1.0),
make_prod(B, make_e_expr(make_prod(expon, make_pwr('t', 1.0)))))
return make_quot(p, bottom)
def test_prob_01_ut_01(self):
print('\n***** Problem 01: UT 01 ************')
fex = make_e_expr(make_prod(make_const(5.0),
make_pwr('x', 1.0)))
print(fex)
drv = deriv(fex)
assert not drv is None
print(drv)
drvf = tof(drv)
assert not drvf is None
gt = lambda x: 5.0*(math.e**(5.0*x))
err = 0.0001
for i in range(10):
#print(drvf(i), gt(i))
# the numbers get pretty large pretty fast.
assert abs(gt(i) - drvf(i)) <= err
print('Problem 01: UT 01: pass')
def test_02(self):
#e^(-2x)=> -0.5e^(-2x)
print("****Unit Test 02********")
fex = make_e_expr(make_prod(make_const(-2.0), make_pwr('x', 1.0)))
print(fex)
afex = antideriv(fex)
assert not afex is None
def gt(x):
return (-0.5) * (math.e**(-2.0 * x))
afexf = tof(afex)
assert not afexf is None
err = 0.0001
for i in range(0, 101):
assert abs(afexf(i) - gt(i)) <= err
print(afex)
print("Unit Test 02: pass")
def plant_growth_model(m, t1, x1, t2, x2):
assert isinstance(m, const) and isinstance(t1, const)
assert isinstance(x1, const) and isinstance(x2, const)
assert isinstance(x2, const)
b = (m.get_val() / x1.get_val()) - 1
k = (np.log(((m.get_val() / x2.get_val()) - 1.0) /
b)) / (-1 * m.get_val() * t2.get_val())
expr = quot(
m,
plus(
const(1.0),
prod(
const(b),
make_e_expr(
prod(const(m.get_val() * -1),
prod(const(k), pwr(var("t"), const(1.0))))))))
return expr
def test_prob_01_ut_03(self):
print('\n***** Problem 01: UT 03 ************')
fex1 = make_quot(make_const(-1.0), make_pwr('x', 1.0))
fex2 = make_e_expr(make_plus(make_pwr('x', 1.0), fex1))
print(fex2)
drv = deriv(fex2)
assert not drv is None
print(drv)
drvf = tof(drv)
assert not drvf is None
def gt_drvf(x):
d = (x - 1.0/x)
return (math.e**d)*(1.0 + 1.0/(x**2))
err = 0.0001
for i in range(1, 10):
#print drvf(i), gt_drvf(i)
# the numbers are too large.
assert abs(gt_drvf(i) - drvf(i)) <= err
print('Problem 01: UT 03: pass')
def plant_growth_model(m, t0, h0, t1, h1):
assert isinstance(m, const) and isinstance(t0, const)
assert isinstance(h0, const) and isinstance(t1, const)
assert isinstance(h1, const)
t_new = abs(t0.get_val() - t1.get_val())
B = const((m.get_val() / h0.get_val()) - 1)
k = const(
math.log(((m.get_val() / h1.get_val()) - 1) / B.get_val()) /
(-1.0 * m.get_val() * t_new))
# # simplify exponent before creating it
expon = const(-1.0 * m.get_val() * k.get_val())
bottom = make_plus(
make_const(1.0),
make_prod(B, make_e_expr(make_prod(expon, make_pwr('t', 1.0)))))
return make_quot(m, bottom)
def test_prob_01_ut_07(self):
print('\n***** Problem 01: UT 07 ************')
fex0 = make_prod(make_pwr('x', 1.0),
make_e_expr(make_pwr('x', 1.0)))
fex = make_ln(fex0)
print(fex)
drv = deriv(fex)
assert not drv is None
print(drv)
drvf = tof(drv)
assert not drvf is None
gt = lambda x: (x + 1.0)/x
err = 0.0001
for i in range(1, 10):
#print(drvf(i), gt(i))
assert abs(gt(i) - drvf(i)) <= err
for i in range(-10, -1):
#print(drvf(i), gt(i))
assert abs(gt(i) - drvf(i)) <= 0.001
print('Problem 01: UT 07: pass')
def test_prob_01_ut_04(self):
print('\n***** Problem 01: UT 04 ************')
n = make_prod(make_const(3.0),
make_e_expr(make_prod(make_const(2.0),
make_pwr('x', 1.0))))
d = make_plus(make_const(1.0), make_pwr('x', 2.0))
fex = make_quot(n, d)
print(fex)
drv = deriv(fex)
assert not drv is None
print(drv)
drvf = tof(drv)
assert not drvf is None
def gt_drvf(x):
n = 6.0*(math.e**(2.0*x))*(x**2 - x + 1.0)
d = (1 + x**2)**2
return n/d
for i in range(-10, 10):
#print drvf(i), gt_drvf(i)
# the numbers get pretty large.
assert abs(gt_drvf(i) - drvf(i)) <= 0.001
print('Problem 01: UT 04: pass')
def solve_pdeq_with_init_cond(y0, k):
# solve y'=3y y(0) =1
assert isinstance(y0, const)
assert isinstance(k, const)
return make_prod(y0, make_e_expr(make_prod(k, make_pwr('t', 1.0))))
def find_growth_model(p0, t, n):
assert isinstance(p0, const)
assert isinstance(t, const)
assert isinstance(n, const)
k = math.log(n.get_val() / p0.get_val()) / t.get_val()
return make_prod(p0, make_e_expr(make_prod(const(k), make_pwr('t', 1.0))))
def radioactive_decay(lmbda, p0, t):
assert isinstance(lmbda, const)
assert isinstance(p0, const)
assert isinstance(t, const)
return make_prod(p0,
make_e_expr(make_prod(make_prod(const(-1.0), lmbda), t)))
def nra_ut_05():
''' Approximating e^-x = x^2. '''
fexpr = make_e_expr(make_prod(make_const(-1.0), make_pwr('x', 1.0)))
fexpr = make_plus(fexpr, make_prod(make_const(-1.0), make_pwr('x', 2.0)))
print(nra(fexpr, make_const(1.0), make_const(10000)))
