def find_root_newtonRaphson(function_string, x):
"""
:param function_string: the equation which we want to get the root
:param x: the initial guess of the root
:return: the root of the equation and NONE if the equation diverged or the number of iterations is above MAX_ITERATIONS
"""
formatter = Formatter()
formatter.add_entry("Xi", "f(Xi)", "F'(Xi)", "Xi+1")
fun = Func(function_string)
found = False
for i in range(0, constants.MAX_ITERATIONS):
fx = (fun.get_value_at(x))
gx = (fun.get_derivative_value_at(x)) # gx is d/dx (fx)
formatter.add_entry(x, fx, gx, x - fx / gx)
# print(x , fx , gx , x-x-fx/gx,sep = "<><><><><>")
r = (fx / gx)
if abs(r) < constants.EPS:
found = True
break
x = x - r
if not found:
print(
"The method diverged .Sorry but we can not solve this equation using newton "
)
return None
else:
formatter.display_steps()
return x
def find_root_bisection(function_string, l, r):
formatter = Formatter()
formatter.add_entry("l", "r", "f(l)", "f(r)", "mid", "f(mid)")
fun = Func(function_string)
fl = fun.get_value_at(l)
fr = fun.get_value_at(r)
if fl * fr > 0:
print(
"Sorry but Bisection method can not solve an equation with the given interval"
)
return None
# print("eps ", constants.EPS)
itr = 0
while abs(r - l) > constants.EPS and itr < constants.MAX_ITERATIONS:
m = l + (r - l) / 2
fm = fun.get_value_at(m)
# print(l, r, fl, fr, m, fm, sep=' <><> ')
formatter.add_entry(l, r, fl, fr, m, fm)
if fm * fl > 0:
l = m
else:
r = m
if abs(r - l) > constants.EPS:
print(
"Bisection method has iterated more than the maximum number of iterations "
)
formatter.display_steps()
return (r + l) / 2
def draw(function_string, left, right):
seg = (right - left) / constants.PLOT_POINTS
fun = Func(function_string)
xs = list()
ys = list()
while left < right:
#print(left)
xs.append(left)
ys.append(fun.get_value_at(left))
left += seg
draw_from_lists(xs, ys)
def find_root_falsePosition(function_string, xl, xu):
'''
:param function_string: the function formatted as a string
You can get the value of the function by importing the Function module
:param xl: the lowerbound x
:param xu: the upperbound x
:return: the root of the equation or None if the method diverged
'''
formatter = Formatter()
formatter.add_entry("Xl", "Xu", "F(Xl)", "F(Xu)", "Xr", "F(Xr)")
func = Func(function_string)
fl = func.get_value_at((xl))
fu = func.get_value_at((xu))
if ((fl < 0 and fu < 0) or ((fu > 0) and (fl > 0))):
print(
"Sorry but False_position method can not solve an equation with the given interval"
)
return None
for i in range(0, constants.MAX_ITERATIONS):
xrnew = (xl * fu - xu * fl) / (fu - fl)
fr = func.get_value_at(xrnew)
formatter.add_entry(xl, fl, xu, fu, xrnew, fr)
if fr == 0: # the exact root is found.
print('exact root is found using false position ')
formatter.display_steps()
return xrnew
elif fr * fl > 0:
xl = xrnew
fl = fr
else:
xu = xrnew
fu = fr
if (i > 0) and (abs(xrnew - xrold) < eps):
print('False Position method has converged ')
formatter.display_steps()
return xrnew
xrold = xrnew
print(
"The method diverged .Sorry but we can not solve this equation using False_position "
)
return None
#print(find_root_falsePosition("2*x**3 - 1" , -1 , 2))
# get_root_false_position()
def __init__(self, parent, eqn, excution_time, left, right):
self.parent = parent
self.eqn = eqn
large_font = ('Verdana', 10)
equation_label = Label(parent,
text='the equation:',
bg='black',
fg='orange')
equation_label.pack(fill=X, padx=5)
eqn_text = Text(parent, bg='black', fg='white')
eqn_text.insert(INSERT, self.eqn.replace('*', ''))
eqn_text.config(state='disabled')
eqn_text.pack(fill=X, padx=5)
excution_time_label = Label(parent,
text='excution time: ' +
str(excution_time),
bg='black',
fg='orange',
font=large_font)
excution_time_label.pack(fill=X, padx=5)
label = Label(parent,
text='Enter the value to be calculated!',
bg='black',
fg='orange')
label.pack(fill=X, padx=5)
self.entry = Entry(parent, font=large_font)
self.entry.pack(fill=X, padx=5, pady=5)
self.ans_label = Label(parent, bg='black', fg='white', font=large_font)
self.ans_label.pack(fill=X, padx=5, pady=5)
button = Button(parent,
text='calculate',
command=self.calculate,
bg='black',
fg='orange')
button.pack(fill=X, padx=5, pady=5)
self.func = Function(eqn)
try:
draw(eqn, left, right)
except:
print("can't draw!")
def find_root_secant(function_string, x_prev=0, x_cur=1):
"""
:param x_prev:
:param x_cur:
:param function_string: the function given in string format
:return: the value at which the function is zero (if exists )
"""
formatter = Formatter()
formatter.add_entry("Xprev", "Xcur", "F(Xprev)", "F(Xcur)", "Xnext")
fun = Func(function_string)
found = False
f_prev = (fun.get_value_at(x_prev))
f_cur = (fun.get_value_at(x_cur))
for i in range(0, constants.MAX_ITERATIONS):
r = f_cur * ((x_cur - x_prev) / (f_cur - f_prev))
x_next = (x_cur - r)
formatter.add_entry(x_prev, x_cur, f_prev, x_cur, x_next)
#print(x_prev, x_cur, f_prev, f_cur, x_next, sep=' <><><> ')
if abs(r) < constants.EPS:
found = true
break
x_prev = x_cur
f_prev = f_cur
x_cur = x_next
f_cur = round(fun.get_value_at(x_cur))
if found == false:
print(
"The method diverged , Try using another initial or make sure the function has a root and is continuous"
)
return None
formatter.display_steps()
return x_cur
#find_root_secant("exp(-x) - x " , 0 , 1 )
class queries():
def __init__(self, parent, eqn, excution_time, left, right):
self.parent = parent
self.eqn = eqn
large_font = ('Verdana', 10)
equation_label = Label(parent,
text='the equation:',
bg='black',
fg='orange')
equation_label.pack(fill=X, padx=5)
eqn_text = Text(parent, bg='black', fg='white')
eqn_text.insert(INSERT, self.eqn.replace('*', ''))
eqn_text.config(state='disabled')
eqn_text.pack(fill=X, padx=5)
excution_time_label = Label(parent,
text='excution time: ' +
str(excution_time),
bg='black',
fg='orange',
font=large_font)
excution_time_label.pack(fill=X, padx=5)
label = Label(parent,
text='Enter the value to be calculated!',
bg='black',
fg='orange')
label.pack(fill=X, padx=5)
self.entry = Entry(parent, font=large_font)
self.entry.pack(fill=X, padx=5, pady=5)
self.ans_label = Label(parent, bg='black', fg='white', font=large_font)
self.ans_label.pack(fill=X, padx=5, pady=5)
button = Button(parent,
text='calculate',
command=self.calculate,
bg='black',
fg='orange')
button.pack(fill=X, padx=5, pady=5)
self.func = Function(eqn)
try:
draw(eqn, left, right)
except:
print("can't draw!")
def calculate(self):
try:
self.ans_label.configure(text=self.func.get_value_at(
float(self.entry.get())),
fg='orange')
except:
self.ans_label.configure(text='check you Entered valid value!',
fg='red')
# o = Tk()
#
# queries(o,'x')
#
# o.mainloop()