from Polinomio import Polinomio

import sympy
import numpy as np
import matplotlib.pyplot as plt
from math import *
import math
import sys

"""
TALLER MARVIN MOLINA 2023-1

By: Leandro Alfaro - Antonio Escorsia - Daniel Rivera

"""
def decimal_binario(deci):
binario = ' '
bin(int(num))
binarios = int(bin(deci)[2:])
return binarios

def binario_decimal(bina):
deci = int(str(bina), 2)
return deci

def parte_decimal_binaria(deci):
binarioDecimal = ''
deci = float("0." + str(deci))
for i in range(10):
deci = deci * 2
if (str(deci)[0] == "0"):
binarioDecimal = binarioDecimal + "0"
elif (str((deci)[0] == "1")):
deci = deci - 1
binarioDecimal = binarioDecimal + "1"
return binarioDecimal

def partes_enteras(num):
num_entero = ""
num_string = str(num)
punto_posicion = len(num_string)
for i in range(len(num_string)):
if (num_string[i] != "."):
num_entero += num_string[i]
elif (num_string[i] == "."):
punto_posicion = i
 break
return int(num_entero), punto_posicion

def partes_decimales(num, punto_referencia):

decimales = ""
num = str(num)
for i in range(len(num)):
if (i > punto_referencia):
decimales += num[i]
entero_decimal = int(decimales)
return entero_decimal

def separacion_numeros(num):
decimales = 0
enteros, punto_posicion = partes_enteras(num)
if (punto_posicion != len(str(num))):
decimales = partes_decimales(num, punto_posicion)
return enteros, decimales

def extracion_signo(num):
sig = "0"
if (num[0] == "0"):
sig = "1"
num[0] = ""
return sig

def calculo_exponentes_maximos(exp):
bits_exp = len(str(exp))
max_exp = 2 ** bits_exp
return max_exp

def calculos_exponente(exp, exponenete_maximo):

decimal_exp = binario_decimal(exp)
resultado = decimal_exp - exponenete_maximo // 2
return resultado

def binario_punto_float(sig, exp, mantis):

numero_binario = sig + ' ' + exp + ' ' + mantis
print(numero_binario)
num_sig = " "
if sig == "1":
num_sig += "-"
def epsilon():
epsilon = 1
while ((epsilon + 1) > 1):
epsilon /= 2
epsilon = 2 * epsilon
print("epsilon", epsilon)

def Redondeo_de_pi():
print("El valor original de PI es (", math.pi, ")")
print("Se redondeo PI a 4 cifras y su resultado es (",
round(math.pi, 4), ")")

def Redondeo_de_LogE():
print("El valor base de logaritmo natural es ", math.log(math.e))
print("Se redondeo logaritmo natural a cuatro cifras y su
resultado es (",
round(math.log(math.e, 4)), ")")
op_e = int(input("""¿Deseas hallar el redondeo de otro numero?
1. si
2. no
Digite la opcion que desea """))
while (op_e != 2):
if (op_e == 1):
num = float(input("ingrese el número:"))
print("el numero ingresado es", num,
" y se redondeo a 4 cifras con ", round(num, 4))
break
else:
print("Fin del programa")

def Redondeo_raiz_cuadrada():
print("El valor base de la raiz cuadrada es ", math.sqrt(2))
print("Se redondeo la raiz cuadrada a cuatro cifras ( ",
round(math.sqrt(2), 4), " )")
op_rC = int(input("""¿Deseas hallar el redondeo de otro numero?
1. si
2. no
Digite la opcion que desea """))
while (op_rC != 2):
if (op_rC == 1):
num = float(input("ingrese el número:"))
print("el numero ingresado es", num,
" y se redonde a 4 cifras con ",
round(math.sqrt(num), 4))
break
else:
print("Fin del programa")
 def Redondeo_raiz_cubica():
resultadoUno = np.cbrt(7)
print("El número redondeado a cuatro cifras es (",
round(resultadoUno, 4), " )")
op_rCubica = int(input("""¿Deseas hallar el redondeo de otro
numero?
1. si
2. no
Digite la opcion que desea """))
while (op_rCubica != 2):
if (op_rCubica == 1):
num = float(input("ingrese el número:"))
resultadoUno = np.cbrt(num)
print("el numero ingresado es", num,
" y se redonde a 4 cifras con ",
round(resultadoUno, 4))
break
else:
print("Fin del programa")

Opciones = """
MENU METODOS NUMERICOS
------------------------
1-Resolver Polinomio
2-Metodo Langrage
3-Metodo Runge-Kutta
4-Biseccion Polinomica
5-Redondeo de logaritmo natural
6-Redondeo de pi
7-Redondeo raiz cuadrada de 2
8-Redondeo raiz cubica de 7
9-Convertir numero de decimal a binario
10-Convertir numero de binario a decimal
11-Calcular el valor de epsilon
12-Metodo Gaus-Jordan
13-Metodo Newthon-Rhapson
14-Metedo Gauss-Seidel
15-Metodo LU
------------------------
"""
show = True;

while show == True:

print(Opciones)
print("")
 op = int(input(""))
if op == 1:
# Leer grado
grado = int(input("Introduce el grado del polinomio: "))

# Pedir los coeficientes del polinomio, comenzando por el término

independiente
print("Introduce los coeficientes del polinomio comenzando por el
término independiente\n" +
"Coeficientes:")
coeficientes = []

for i in range(grado + 1):

coeficiente = float(input(f"a[{i}]: "))
coeficientes.append(coeficiente)

print()

# Leer intervalos
a = float(input("Introduce el inicio del intervalo: a = "))
b = float(input("Introduce el fin del intervalo: b = "))

# Leer cifras significativas

cifras_significativas = int(input("Introduce la cantidad de
cifras significativas: "))
print()

# Leer regla de integración aproximada

print("Elige la regla de integración aproximada: \n 1. Trapecio \
n 2. Simpson 1/3.")
regla = int(input("Introduce el número de la opción deseada: "))
print()

# Tolerancia al error relativo normalizado porcentual ERNP

tolerancia = 0.5 * pow(10, 2 - cifras_significativas)

p = Polinomio(coeficientes, grado)

long_arc = 0.0
subintervalos = 0

if regla == 1:
long_arc, subintervalos = p.long_arc_trapecio(a, b,
tolerancia)
elif regla == 2:
long_arc, subintervalos = p.long_arc_simpson13(a, b,
tolerancia)

long_arc = round(long_arc, cifras_significativas)

 print(f"Longitud de arco: {long_arc}")
print(f"Subintervalos: {subintervalos}")

elif op == 2:

def algoritmo(i, j):

x_sim = sympy.symbols('x')
return (x_sim - x[i]) / (x[j] - x[i]) if i != j else 1

def interpol_lagrange(x, y, num_puntos=100):

x_sim = sympy.symbols('x')

# Cantidad de puntos
points = len(x)

lj = []
for k in range(points):
lk = np.prod([algoritmo(i, k) for i in range(points)])
lj.append(lk)

# Lagrange
pol = sum(y * lj)
x_test = np.linspace(min(x), max(x), num_puntos)
y_pol = [pol.subs(x_sim, i) for i in x_test]

return x_test, y_pol

# Datos del problema

v1 = float(input("Digite 1er valor para y: "))

v2 = float(input("Digite 2do valor para y: "))
v3 = float(input("Digite 3er valor para y: "))
v4 = float(input("Digite 4to valor para y: "))

x = np.array([-3, -1, 2, 4])

y = np.array([v1, v2, v3, v4])

# Puntos generados por lagrange

x_test, y_pol = interpol_lagrange(x, y)

# Mostrando lagrafica
plt.plot(x_test, y_pol)
plt.scatter(x, y)
 plt.legend(['Lagrange', 'Datos'], loc='lower right')
plt.show()

elif op == 3:

# Defining the general model

def lotkaVolterraModel(x, params):
a = params["a"]

b = params["b"]

c = params["c"]

d = params["d"]

# time to relative other states

# functions
xdot = np.array([a * x[0] - b * x[0] * x[1], d * x[0] * x[1]
- c * x[1]])
return xdot

# RK4 Method

def rungeKutta4(f, x0, t0, tf, h):

t = np.arange(t0, tf, h)
nt = t.size

nx = x0.size
# filling with zeros nx, nt)
x = np.zeros((nx, nt))

x[:, 0] = x0

for i in range(nt - 1):

k1 = h * f(t[i], x[:, i])
k2 = h * f(t[i] + h / 2, x[:, i] + k1 / 2)
k3 = h * f(t[i] + h / 2, x[:, i] + k2 / 2)
k4 = h * f(t[i] + h, x[:, i] + k3)

dx = (k1 + 2 * k2 + 2 * k3 + k4) / 6

x[:, i + 1] = x[:, i] + dx

return (x, t)

# Definimg Params
 params = {"a": 2 * 1.2, "b": 2 * 0.6, "c": 2 * 0.8, "d": 2 * 0.3}

f = lambda t, x: lotkaVolterraModel(x, params)

# x_initialization
x0 = np.array([2, 1])

# solve the diff eq.

t0 = 0
tf = 30
h = 0.1
x, t = rungeKutta4(f, x0, t0, tf, h)

# Plot Results

plt.subplot(1, 2, 1)
plt.plot(t, x[0, :], "r", label="Preyers")
plt.plot(t, x[1, :], "b", label="Predators")
plt.xlabel("Time (t)")
plt.grid()
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(x[0, :], x[1, :])
plt.xlabel("Preys")
plt.ylabel("Predators")
plt.grid()

plt.show()

elif op == 4:

def pol(x):
return -0.42 * x ** 2 + 2.2 * x + 4.7

def trig(x):
return x * cos(x - 1) - sin(x)

def bisec(fun, inter, fin_inter, e, n_max):

i = 1
while i <= n_max:
p = inter + (fin_inter - inter) / 2
print("i = {0:<2}, p = {1: .12f}".format(i, p))
 if abs(fun(p)) <= 1e-15 or (fin_inter - inter) / 2 < e:
return p
i = i + 1
if fun(inter) * fun(p) > 0:
inter = p
else:
fin_inter = p
print("Se acabaron las iteraciones: Error!")
return None

print("Biseccion polinomica(x):")
bisec(pol, 1, 2, 1e-8, 100)
"""pol(x), inter=1, fin_inter=2, e=10**-8, N_0=100"""

print("\nBiseccion de funcion trigonometrica (x):")

bisec(trig, 4, 6, 1e-8, 100)
"""trig(x), inter=4, fin_inter=6, e=10**-8, N_0=100"""

elif op == 5:

print("El valor base de logaritmo natural es ", math.log(math.e))

print("Se redondeo logaritmo natural a cuatro cifras y su
resultado es (",
round(math.log(math.e, 4)), ")")
op_e = int(input("""¿Deseas hallar el redondeo de otro numero?
1. si
2. no
Digite la opcion que desea """))
while (op_e != 2):
if (op_e == 1):
num = float(input("ingrese el número:"))
print("el numero ingresado es", num,
" y se redondeo a 4 cifras con ", round(num, 4))
break
else:
print("Fin del programa")

elif op == 6:

print("El valor original de PI es (", math.pi, ")")

print("Se redondeo PI a 4 cifras y su resultado es (",
round(math.pi, 4), ")")

elif op == 7:
 print("El valor base de la raiz cuadrada es ", math.sqrt(2))
print("Se redondeo la raiz cuadrada a cuatro cifras ( ",
round(math.sqrt(2), 4), " )")
op_rC = int(input("""¿Deseas hallar el redondeo de otro
numero?
1. si
2. no
Digite la opcion que desea """))
while (op_rC != 2):
if (op_rC == 1):
num = float(input("ingrese el número:"))
print("el numero ingresado es", num,
" y se redonde a 4 cifras con ",
round(math.sqrt(num), 4))
break
else:
print("Fin del programa")

elif op == 8:

resultadoUno = np.cbrt(7)
print("El número redondeado a cuatro cifras es (",
round(resultadoUno, 4), " )")
op_rCubica = int(input("""¿Deseas hallar el redondeo de otro
numero?
1. si
2. no
Digite la opcion que desea """))
while (op_rCubica != 2):
if (op_rCubica == 1):
num = float(input("ingrese el número:"))
resultadoUno = np.cbrt(num)
print("el numero ingresado es", num,
" y se redonde a 4 cifras con ",
round(resultadoUno, 4))
break

else:

print("Fin del programa")

elif op == 9:

print("ingrese el numero ")

num = float(input())
ent, dec = separacion_numeros(num)
print("parte entera", ent)
 print("parte decimal", dec)
num_bin = str(decimal_binario(ent)) + \
"." + parte_decimal_binaria(dec)
print("el número de binario a decimal ", num_bin)

elif op == 10:

print("ingrese un numero")
num2 = float(input())
ent, dec = separacion_numeros(num2)
num_dec = str(binario_decimal(ent)) + \
"." + parte_decimal_binaria(dec)
# numero_decimal = str(binario_decimal(num_dec))
print("el numero de decimal a binario", num_dec)

elif op == 11:

epsilon()

elif op == 12:

def main():

n = int(input('Digita el tamaño de la matriz: '))

a = np.zeros((n, n + 1))

x = np.zeros(n)

print('Digita valor para la posicion: ')

for i in range(n):
for j in range(n + 1):
a[i][j] = float(input('a[' + str(i) + '][' + str(j) +
']='))

for i in range(n):
if a[i][i] == 0.0:
sys.exit('Division por 0 detectada ')

for j in range(n):
if i != j:
ratio = a[j][i] / a[i][i]

for k in range(n + 1):

 a[j][k] = a[j][k] - ratio * a[i][k]

for i in range(n):
x[i] = a[i][n] / a[i][i]

print('\n La matriz simplificada es: ')

print("")
for i in range(n):
print('X%d = %0.2f' % (i, x[i]), end='\t')
print("")

main()

elif op == 13:

if _name_ == "_main_":
v1 = float(input("Asigne valor a la 1er variable: "))
v2 = float(input("Asigne valor a la 2da variable: "))

def funcion(x):
value = x ** 2 - 2
return value

def derivada(x):
return 2 * x # The derivative of the main function

def newton(funcion, derivada, x0, tol, max_iter=100):

x1 = 0

if abs(x0 - x1) <= tol and abs((x0 - x1) / x0) <= tol:
return x0
print("")
print("k\t x0\t\t funcion(x0)")
print("")
k = 1

while k <= max_iter:

x1 = x0 - (funcion(x0) / derivada(x0))
print("")
print("x%d\t%e\t%e" % (k, x1, funcion(x1)))
print("")
if abs(x0 - x1) <= tol and abs((x0 - x1) / x0) <= tol:
 plt.plot(x0, funcion(x0), 'or')
return x1

x0 = x1
k = k + 1
plt.plot(x0, funcion(x0), 'or')

# Stops the method if it hits the number of maximum

iterations
if k > max_iter:
print("")
print("ERROR: excede el numero de las iteraciones")
print("")
return x1 # Returns the value

sqrt = newton(funcion, derivada, 1.7, 0.0000001)

print("")
print("El valor aproximado de x es: " + str(sqrt))
print("")
# Configurar los limites de la grafica
w = u ** v1 - v2
u = np.arange(1.0, 2.0, 0.0001)

plt.plot(u, w)
plt.axhline(y=0.0, color='black', linestyle='-')
plt.title('Newton-Raphson Grafica')
plt.xlabel('X')
plt.ylabel('Y')
plt.grid(True)
plt.legend(['Xn'], loc='upper left')
plt.show()