def evaluate(self, initial_value, increment, iterations, function):
function = Function(function)
x = initial_value
fx = function.evaluate(initial_value)
self.values.append([0, str(initial_value), str(fx)])
if fx == 0:
return str(initial_value) + " es una raiz."
elif increment == 0:
return "El valor asignado al incremento es incorrecto"
elif iterations < 1:
return "El valor del iterador es incorrecto"
else:
x1 = initial_value + increment
contador = 1
fx1 = function.evaluate(x1)
self.values.append([contador, str(x1), str(fx1)])
while fx * fx1 > 0 and contador < iterations:
x = x1
fx = fx1
x1 = x + increment
fx1 = function.evaluate(x1)
contador += 1
self.values.append([contador, str(x1), str(fx1)])
if fx1 == 0:
return str(x1) + " es una Raiz."
elif fx * fx1 < 0:
return "Los valores "+ str(x) + " y " + str(x1) +" definen un intervalo"
else:
return "No se encontro un intervalo que contenga al menos una raiz."
def graph_c(funcion, initial_value, last_value):
function = Fun(funcion)
win = Gtk.Window()
win.connect("destroy", lambda x: Gtk.main_quit())
win.set_default_size(640, 480)
win.set_title("Embedding in GTK")
vbox = Gtk.VBox()
win.add(vbox)
fig = Figure(figsize=(5, 4), dpi=100)
ax = fig.add_subplot(111)
x = np.arange(initial_value, last_value)
y = [function.evaluate2(i) for i in x]
ax.plot(x, y)
dev = Fun(derivate_function(funcion))
derivada = [dev.evaluate2(i) for i in x]
ax.plot(x, derivada)
canvas = FigureCanvas(fig) # a Gtk.DrawingArea
vbox.pack_start(canvas, True, True, 0)
toolbar = NavigationToolbar(canvas, win)
vbox.pack_start(toolbar, False, False, 0)
win.show_all()
Gtk.main()
def evaluate(self, tol, x0, x1, fun, niter, type_error=1):
fun = Function(fun)
fx0 = fun.evaluate(x0)
if fx0 == 0:
return f"{x0} es raiz"
elif niter < 1:
return "El valor del iterador es incorrecto"
else:
fx1 = fun.evaluate(x1)
cont = 0
self.values.append([-1, str(x0), str("{:.2e}".format(fx0)), None])
self.values.append(
[cont, str(x1), str("{:.2e}".format(fx1)), None])
error = tol + 1
den = fx1 - fx0
while error > tol and fx1 != 0 and den != 0 and cont < niter:
x2 = x1 - (fx1 * (x1 - x0) / den)
if type_error == 0:
error = abs(x2 - x1)
else:
error = abs((x2 - x1) / x2)
x0 = x1
fx0 = fx1
x1 = x2
fx1 = fun.evaluate(x2)
den = fx1 - fx0
cont = cont + 1
self.values.append([
cont,
str(x2),
str("{:.2e}".format(fx1)),
str("{:.2e}".format(error))
])
if fx1 == 0:
return f"{x1} es raíz"
elif error < tol:
return f"{x1} es una aprox. a una raíz con una tolerancia = {tol}"
elif den == 0:
return f"Hay una posible raíz multiple"
else:
return f"Fracasó en {niter} iteraciones"
def evaluate(self, tol, xi, niter, fun, dfun, type_error=1):
fun = Function(fun)
dfun = Function(dfun)
fx = fun.evaluate2(xi)
dfx = dfun.evaluate2(xi)
if fx == 0:
return str(fx) + " es una raiz."
elif dfun == 0:
return "La derivada no puede ser 0"
elif niter < 1:
return "El valor del iterador es incorrecto"
else:
contador = 0
error = tol + 1
self.values.append(
[contador,
str(xi),
str("{:.2e}".format(fx)),
str(dfx), None])
while error > tol and fx != 0 and dfx != 0 and contador < niter:
xn = xi - (fx / dfx)
fx = fun.evaluate2(xn)
dfx = dfun.evaluate2(xn)
if type_error == 0:
error = abs(xn - xi)
else:
error = abs((xn - xi) / xn)
xi = xn
contador = contador + 1
self.values.append([
contador,
str(xn),
str("{:.2e}".format(fx)),
str(dfx),
str("{:.2e}".format(error))
])
if fx == 0:
return f"{xi} es raiz"
elif error < tol:
return f"{xn} es una aprox. a una raiz con una tolerancia = {tol}"
elif dfx == 0:
return f"{xn} es una posible raiz multiple"
else:
return f"El método fracasó en {niter} iteraciones"
def evaluate(self,
xi,
tolerancia,
iter,
function,
g_function,
type_error=1):
fun = Function(function)
gx = Function(g_function)
fx = fun.evaluate2(xi)
if fx == 0:
return f"{xi} es raiz"
if iter < 1:
return "El valor del iterador es incorrecto"
if tolerancia < 0:
return "Error en la tolerancia, debe ser mayor o igual a 0"
self.values.append([0, str(xi), str("{:.2e}".format(fx)), None])
contador = 0
error = tolerancia + 0.1
while fx != 0 and error > tolerancia and contador < iter:
xn = gx.evaluate2(xi)
fi = fun.evaluate2(xn)
if type_error == 0:
error = abs(xn - xi)
else:
error = abs((xn - xi) / xn)
xi = xn
contador = contador + 1
self.values.append([
contador,
str(xn),
str("{:.2e}".format(fi)),
str("{:.2e}".format(error))
])
if fx == 0:
return f"{xi} es raiz"
elif error < tolerancia:
return f"{xi} es una aprox. con una tolerancia = {tolerancia}"
else:
return f"El método fracasó en {iter} iteraciones"
def evaluate(self, xi, xs, tolerancia, iter, function, type_error=1):
funcion = Function(function)
fxi = funcion.evaluate(xi)
fxs = funcion.evaluate(xs)
if iter < 1:
return "El valor del iterador es incorrecto"
if tolerancia < 0:
return "Error en la tolerancia, debe ser mayor o igual a 0"
if fxi == 0:
return f"{xi} es una raiz"
elif fxs == 0:
return f"{xs} es una raiz"
elif fxi * fxs < 0:
xm = xi - ((fxi * (xi - xs)) / (fxi - fxs))
fxm = funcion.evaluate(xm)
contador = 1
error = tolerancia + 1
self.values.append([
contador,
str(xi),
str(xs),
str(xm),
str("{:.2e}".format(fxm)), None
])
while error > tolerancia and fxm != 0 and contador < iter:
if fxm * fxi < 0:
xs = xm
fxs = fxm
else:
xi = xm
fxi = fxm
xaux = xm
xm = xi - ((fxi * (xi - xs)) / (fxi - fxs))
fxm = funcion.evaluate(xm)
if type_error == 0:
error = abs(xm - xaux)
else:
error = abs((xm - xaux) / xm)
contador += 1
self.values.append([
contador,
str(xi),
str(xs),
str(xm),
str("{:.2e}".format(fxm)),
str("{:.2e}".format(error))
])
if fxm == 0:
return f"{xm} es raiz"
elif (error < tolerancia):
return f"{xm} es una aprox. a una raiz con tolerancia = {tolerancia}"
else:
return f"fracaso en {iter} iteraciones"
else:
return "el intervalo es inadecuado"
def evaluate(self, tol, xi, iter, function, d1, dd2, type_error=1):
fun = Function(function)
der1 = Function(d1)
der2 = Function(dd2)
fx = fun.evaluate2(xi)
dfx = der1.evaluate2(xi)
ddfx = der2.evaluate2(xi)
if fx == 0:
return str(fx) + " es una raiz."
elif iter < 1:
return "El valor del iterador es incorrecto"
else:
contador = 0
self.values.append([
contador,
str(xi),
str("{:.2e}".format(fx)),
str("{:.2e}".format(dfx)),
str(ddfx), None
])
error = tol + 1
while error > tol and fx != 0 and ddfx != 0 and contador < iter:
x = xi
xi = x - (fx * dfx) / ((dfx**2) - fx * ddfx)
fx = fun.evaluate2(xi)
dfx = der1.evaluate2(xi)
ddfx = der2.evaluate2(xi)
if type_error == 0:
error = abs(xi - x)
else:
error = abs((xi - x) / xi)
contador += 1
self.values.append([
contador,
str(xi),
str("{:.2e}".format(fx)),
str("{:.2e}".format(dfx)),
str(ddfx),
str("{:.2e}".format(error))
])
if fx == 0:
return f"{xi} es raiz"
elif error < tol:
return f"{xi} es una aprox. a una raiz con una tolerancia = {tol}"
else:
return f"El método fracasó en {iter} iteraciones"