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 test_03(self):
#(x+11)/(x-3) ^3
print('\n***** Test 03 ***********')
q = make_quot(make_plus(make_pwr('x', 1.0), make_const(11.0)),
make_plus(make_pwr('x', 1.0), make_const(-3.0)))
pex = make_pwr_expr(q, 3.0)
print('-- function expression is:\n')
print(pex)
pexdrv = deriv(pex)
assert not pexdrv is None
print('\n - - derivative is:\n')
print(pexdrv)
pexdrvf = tof(pexdrv)
assert not pexdrvf is None
gt = lambda x: -42.0 * (((x + 11.0)**2) / ((x - 3.0)**4))
err = 0.00001
print('\n - -comparison with ground truth:\n')
for i in range(10):
if i != 3.0:
print(pexdrvf(i), gt(i))
#print("gt: ",gt(0))
assert abs(pexdrvf(i) - gt(i)) <= err
#print("pexdrvf(0): ",pexdrvf(0),"gt(i): ", gt(0))
print('Test 03:pass')
def ln_deriv(expr):
assert isinstance(expr, ln)
Denom = expr.get_expr()
if isinstance(Denom, absv):
Denom = Denom.get_expr()
quotPart = make_quot(make_const(1), Denom)
derrivExpr = deriv(Denom)
return make_prod(quotPart, derrivExpr)
def find_poly_1_zeros(expr):
firstpart = expr.get_elt1()
a = firstpart.get_mult1()
b = expr.get_elt2()
fex1 = prod(mult1=b, mult2=-1)
fex2 = make_quot(1, a)
return const(val=prod(mult1=fex1, mult2=fex2))
def test_assign_05_prob_05_ut_01(self):
print('\n***** Assign 05: Problem 05: Unit Test 01 *****')
fex0 = make_quot(make_const(18000.0), make_pwr('p', 1.0))
deq = make_plus(fex0, make_const(-1500.0))
## change these to assertions later
print(demand_elasticity(deq, make_const(6.0)))
print(is_demand_elastic(deq, make_const(6.0)))
print(expected_rev_dir(deq, make_const(6.0), make_const(-1.0)))
print('Assign 05: Problem 05: Unit Test 01: pass')
def problem_1_deriv(): # still has problems
# f(x) =(x+1)(2x+1)(3x+1) /(4x+1)^.5
fex1 = make_plus(make_pwr('x', 1.0), const(1.0))
fex2 = make_plus(make_prod(const(2.0), make_pwr('x', 1.0)), const(1.0))
fex3 = make_plus(make_prod(const(3.0), make_pwr('x', 1.0)), const(1.0))
fex4 = make_prod(fex1, fex2)
fex5 = make_prod(fex4, fex3)
fex6 = make_pwr_expr(
make_plus(make_prod(const(4.0), make_pwr('x', 1.0)), const(1.0)), 0.5)
fex = make_quot(fex5, fex6)
print(fex)
drv = deriv(fex)
print('drv: ', drv)
drvf = tof(drv)
def gt_drvf(x):
n = (60.0 * x**3) + (84 * x**2) + 34 * x + 4
d = (4 * x + 1)**(3 / 2)
return n / d
for i in range(1, 10):
print(drvf(i), gt_drvf(i))
assert abs(gt_drvf(i) - drvf(i)) <= 0.001
assert drv is not None
print(drv)
# zeros = find_poly_2_zeros(drv)
# print(zeros)
f1 = tof(fex)
f2 = tof(deriv(fex))
xvals = np.linspace(1, 5, 10000)
yvals1 = np.array([f1(x) for x in xvals])
yvals2 = np.array([f2(x) for x in xvals])
fig1 = plt.figure(1)
fig1.suptitle('Graph')
plt.xlabel('x')
plt.ylabel('y')
plt.ylim()
plt.xlim()
plt.grid()
plt.plot(xvals, yvals1, label=fex.__str__(), c='r')
plt.plot(xvals, yvals2, label=deriv(fex).__str__(), c='g')
plt.legend(loc='best')
plt.show()
def nra_ut_15():
f1 = make_prod(
const(60.0),
make_quot(
make_plus(
const(1.0),
make_prod(
const(-1.0),
make_pwr_expr(make_plus(const(1.0), make_pwr('x', 1.0)),
const(-6)))), make_pwr('x', 1.0)))
f2 = make_prod(
const(995.0),
make_pwr_expr(make_plus(const(1.0), make_pwr('x', 1.0)), const(-6.5)))
fsum = make_plus(f1, f2)
fexpr = make_plus(fsum, const(-970))
approx = nra(fexpr, const(0.03), const(1000000))
print(approx)
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_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_assign_03_prob_01_ut_10(self):
print('\n***** Assign 03: Problem 01: Unit Test 10 *****')
q = make_quot(make_plus(make_pwr('x', 1.0), make_const(11.0)),
make_plus(make_pwr('x', 1.0), make_const(-3.0)))
pex = make_pwr_expr(q, 3.0)
print('-- function expression is:\n')
print(pex)
pexdrv = deriv(pex)
assert not pexdrv is None
print('\n-- derivative is:\n')
print(pexdrv)
pexdrvf = tof(pexdrv)
assert not pexdrvf is None
gt = lambda x: -42.0 * (((x + 11.0)**2) / ((x - 3.0)**4))
err = 0.00001
print('\n--comparison with ground truth:\n')
for i in range(10):
if i != 3.0:
#print(pexdrvf(i), gt(i))
assert abs(pexdrvf(i) - gt(i)) <= 0.001
print('Assign 03: Problem 01: Unit Test 10: 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 test_assign_03_prob_01_ut_09(self):
print('\n***** Assign 03: Problem 01: Unit Test 09 *****')
n1 = make_plus(make_pwr('x', 2.0),
make_prod(make_const(0.0), make_pwr('x', 1.0)))
n = make_plus(n1, make_const(-1.0))
d1 = make_plus(make_pwr('x', 2.0),
make_prod(make_const(0.0), make_pwr('x', 1.0)))
d = make_plus(d1, make_const(1.0))
q = make_quot(n, d)
qdrv = deriv(q)
assert not qdrv is None
print(qdrv)
qdrvf = tof(qdrv)
assert not qdrvf is None
def gt_drvf(x):
return (4.0 * x) / ((x**2 + 1.0)**2)
err = 0.0001
for i in range(10):
#print qdrvf(i), gt_drvf(i)
assert abs(qdrvf(i) - gt_drvf(i)) <= err
print('Assign 03: Problem 01: Unit Test 09: pass')
def test_08(self):
print("****Unit Test 07********")
p = make_plus(make_quot(make_const(18000.0), make_pwr('p', 1.0)), make_const(-1500.0))
return expected_rev_dir(p, make_const(6.0), const(-1.0))
def test_07(self):
print("****Unit Test 07********")
p = make_plus(make_quot(make_const(18000.0), make_pwr('p', 1.0)), make_const(-1500.0))
q = demand_elasticity(p, make_const(6.0))
#q = is_demand_elastic(p, make_const(6.0))
print(q)
