SHARE
TWEET

Untitled

a guest Oct 10th, 2019 103 in 25 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #FELIPE SUEMITSU, NICOLAS NEBELUNG
  2.  
  3. import numpy as np
  4.  
  5. # =================================================================================================================
  6. # ====================================           BISSECÇÃO          ===============================================
  7. # =================================================================================================================
  8. def funcaoBissecao(x):
  9.     y = x**2 + x -1
  10.     return y
  11.  
  12. def bissecao():
  13.    
  14.     a=float(input('Digite o valor de a:'))
  15.     b=float(input('Digite o valor de b:'))
  16.     precisao=float(input('Digite a precisão:'))
  17.     print('Precisão recomendada: 0.001')
  18.  
  19.     x = 0
  20.     cp = 0.1
  21.     ultimoValor = 0
  22.  
  23.     for k in range (1, 1000):
  24.  
  25.         x = (a+b)/2      
  26.        
  27.         fA = funcaoBissecao(a)
  28.         fX = funcaoBissecao(x)
  29.  
  30.         d = fA*fX
  31.        
  32.         if d > 0:
  33.  
  34.             a = x
  35.  
  36.     # Teste da bissecção - condição
  37.         if d < 0:
  38.  
  39.             b = x  
  40.  
  41.         try:
  42.             cp = abs((x - ultimoValor)/x)
  43.  
  44.         except ZeroDivisionError:
  45.  
  46.             cp = 0.1
  47.  
  48.         if cp < precisao:
  49.             print("Critério de parada ativado!")
  50.             break
  51.  
  52.         ultimoValor = x
  53.  
  54.     print('Raíz: ' ,x)
  55.  
  56. # =================================================================================================================
  57. # =========================================    FUNÇÃO NEWTON     ==================================================
  58. # =================================================================================================================
  59.  
  60. def funcaonewton(x):
  61.     y=x**2 + x -1
  62.     return y
  63.  
  64. def DerivadaNewton(x):
  65.     h = 1./1000.
  66.     a = funcaonewton(x + h) - funcaonewton(x)
  67.  
  68.     # TESTA A DERIVADA DE NEWTON != 0  
  69.     if rise == 0:
  70.  
  71.         print('A derivada é 0!')
  72.         return False
  73.    
  74.     b = h
  75.     derivative = a / b
  76.     return derivative
  77.  
  78. def newton():
  79.     ultimoValor=float(input('Valor inicial aproximado: '))
  80.     precisao=float(input('Precisão desejada: '))
  81.     for k in range (1,1000):
  82.         fX = funcaonewton(ultimoValor)
  83.         dX = DerivadaNewton(ultimoValor)
  84.         Xk = ultimoValor - (fX/dX)
  85.        
  86.         cp=abs(Xk-ultimoValor)/abs(Xk)
  87.         if cp < precisao:
  88.             print('Critério de parada ativado!')
  89.             break
  90.  
  91.         ultimoValor=Xk
  92.     print('Raíz:'   ,   Xk)
  93.  
  94. # =================================================================================================================
  95. # ========================================    FUNÇÃO SECANTES     =================================================
  96. # =================================================================================================================
  97.  
  98. def funcaosecantes(x):
  99.     y=x**2 + x -1
  100.     return y
  101.  
  102. def secantes():
  103.     v = [1, 1.1]
  104.     x0 = float(input('Valor Xo:'))
  105.     x1 = float(input('Valor X1:'))
  106.  
  107.     if (x0 - x1) == 0:
  108.  
  109.         print('Os valores não podem ser idênticos!!')
  110.         return False
  111.  
  112.     v.append(x0)  
  113.     v.append(x1)
  114.  
  115.     precisao = float(input('Precisão desejada:'))
  116.    
  117.     for k in range (1,1000):
  118.  
  119.         try:
  120.            
  121.             Xk = (v[len(v)-1]*funcaosecantes(v[len(v)-2])-v[len(v)-2]*funcaosecantes(v[len(v)-1]))/(funcaosecantes(v[len(v)-2])-funcaosecantes(v[len(v)-1]))
  122.             v.append(Xk)
  123.  
  124.             try:
  125.            
  126.                 cp = abs((Xk - v[len(v)-1])/Xk)
  127.  
  128.             except ZeroDivisionError:
  129.  
  130.                 cp = 0.1
  131.  
  132.                 if cp < precisao:
  133.                     print("Critério de parada ativado!")
  134.                     break
  135.  
  136.         except ZeroDivisionError:
  137.  
  138.             pass
  139.  
  140.  
  141.     print(v[len(v)-1])
  142.  
  143. # =================================================================================================================
  144. # ========================================    ELIMINAÇÃO GAUSS    =================================================
  145. # =================================================================================================================
  146.  
  147.  
  148. def eliminacaogauss():
  149.  
  150.     A = []
  151.     B = []
  152.     Coef = []
  153.    
  154.     m=int(input('Insira o numero de linhas: '))
  155.     matriz=np.zeros([m,m])
  156.     A=np.zeros([m,m])
  157.     #B=np.zeros([m,m])
  158.     print('Insira os elementos da matriz')
  159.  
  160.     for l in range(0,m):
  161.          
  162.           for c in range(0,m):
  163.              
  164.                 matriz[l,c]=(input('Elemento a['+str(l+1)+","+str(c+1)+"] da matriz A (coeficientes): "))
  165.                 matriz[l,c]=float(matriz[l,c])
  166.                 A[l,c]=matriz[l,c]
  167.  
  168.     for j in range(0, m):
  169.        
  170.             Coef.append(0)
  171.             B.append(0)
  172.             B[j] = float(input('Elemento[' +str(j+1)+ '] da matriz B:'))
  173.    
  174.     for k in range (0, m-1):
  175.  
  176.         # Testa se A[k][k] é diferente de zero:
  177.         if A[k][k] == 0:
  178.  
  179.             print('A[k][k] é zero! erro na matemática básica ;)')
  180.             break
  181.             return False
  182.        
  183.         for i in range (k+1, m):
  184.  
  185.             # Pivot
  186.             aux = (A[i][k]/A[k][k])
  187.            
  188.             for j in range (k, m):
  189.  
  190.                
  191.                 A[i][j] = A[i][j]- A[k][j]*aux
  192.                
  193.             B[i] = B[i] - B[k]*aux
  194.  
  195.         if k == m-2:
  196.  
  197.                     print('Apresentando o sistema escalonado:')
  198.                     print('Matriz A (coeficientes):', A)
  199.                     print('Matriz B:', B)
  200.                     print('Sistema escolanado apresentado com sucesso!')
  201.  
  202.                     for u in range (m , 0, -1):
  203.                        
  204.                         c = 0
  205.                         parte = 0
  206.  
  207.                         for v in range (0 , m, 1):
  208.                        
  209.                             parte += A[u-1][m-1-v]*Coef[m-1-v]
  210.                            
  211.                         c = (B[u-1] - parte) / A[u-1][u-1]
  212.                         Coef[u-1] = float(c)
  213.  
  214.                     for w in range (0, len(Coef)):
  215.  
  216.                         print('Coeficiente ' + str(w+1) + ":", Coef[w])
  217.                    
  218.  
  219. # =================================================================================================================
  220. # ========================================     DECOMPOSIÇÃO LU     ================================================
  221. # =================================================================================================================
  222.  
  223. def decomplu():
  224.  
  225.     CoefY = []
  226.     CoefX = []
  227.     B = []
  228.    
  229.     print('Decomposição LU em matrizes quadradas')
  230.     m=int(input('Insira o numero de linhas: '))
  231.     matriz=np.zeros([m,m])
  232.     U=np.zeros([m,m])
  233.     L=np.zeros([m,m])
  234.     print('Favor inserir os elementos da matriz:')
  235.  
  236.     for l in range(0,m):
  237.           B.append(0)
  238.           CoefY.append(0)
  239.           CoefX.append(0)
  240.          
  241.           for c in range(0,m):
  242.                 matriz[l,c]=(input('Elemento a['+str(l+1)+","+str(c+1)+"]: "))
  243.                 matriz[l,c]=float(matriz[l,c])
  244.                 U[l,c]=matriz[l,c]
  245.  
  246.     for p in range(0,m):
  247.           valorvetorB = float(input('Elemento B['+str(p+1)+']: '))
  248.           B[p] = valorvetorB
  249.          
  250.     #operaçoes para zerar abaixo da diagonal principal
  251.  
  252.     for k in range(0,m):
  253.           for l in range(0,m):
  254.                 if (k==l):
  255.                     L[k,l]=1
  256.                 if (k<l):
  257.                     fator=(matriz[l,k]/matriz[k,k])
  258.                     L[l,k]=fator
  259.                     for c in range(0,m):
  260.                           matriz[l,c]=matriz[l,c]-(fator*matriz[k,c])
  261.                           U[l,c]=matriz[l,c]
  262.                          
  263.          
  264.     print('Apresentação dos resultados:')
  265.     print('Matriz L:')
  266.     print(L)
  267.     print('Matriz U:')
  268.     print(U)
  269.  
  270.  
  271.     # RESOLUÇÃO DE LY=B
  272.     for u in range (0 , m, 1):
  273.                        
  274.         c = 0
  275.         parte = 0
  276.  
  277.         for v in range (0 , m, 1):
  278.                        
  279.             parte += L[u][v]*CoefY[v]
  280.                            
  281.         c = (B[u] - parte) / L[u][u]
  282.         CoefY[u] = float(round(c, 4))
  283.  
  284.     print('Resultado LY=B:' , CoefY)
  285.  
  286.     # RESOLUÇÃO DE UX=Y
  287.     for u in range (m , 0, -1):
  288.                        
  289.         c = 0
  290.         parte = 0
  291.  
  292.         for v in range (0 , m, 1):
  293.                        
  294.            parte += U[u-1][m-1-v]*CoefX[m-1-v]
  295.                            
  296.         c = (CoefY[u-1] - parte) / U[u-1][u-1]
  297.         CoefX[u-1] = float(round(c, 4))
  298.  
  299.     print('Resultado UX=Y:' , CoefX)
  300.  
  301.    
  302.  
  303.  
  304. # =================================================================================================================
  305. # =====================================     JACOBI E GAUSS-SEIDEL    ==============================================
  306. # =================================================================================================================
  307.  
  308.  
  309. def verificaMatriz ():
  310.  
  311.     # Já implementado internamente
  312.     pass
  313.  
  314.  
  315. def Jacobi ():
  316.  
  317.     verificaMatriz()
  318.  
  319.     A = []
  320.     B = []
  321.     Coef = []
  322.     x = []
  323.     xnew = []
  324.    
  325.     m=int(input('Insira o numero de linhas: '))
  326.     precisao = float(input('Precisão desejada:'))
  327.     matriz=np.zeros([m,m])
  328.     A=np.zeros([m,m])
  329.     #B=np.zeros([m,m])
  330.     print('Insira os elementos da matriz')
  331.  
  332.     for l in range(0,m):
  333.          
  334.           for c in range(0,m, 1):
  335.              
  336.                 matriz[l,c]=(input('Elemento a['+str(l+1)+","+str(c+1)+"] da matriz A (coeficientes): "))
  337.                 matriz[l,c]=float(matriz[l,c])
  338.                 A[l,c]=matriz[l,c]
  339.  
  340.     for j in range(0, m):
  341.        
  342.             Coef.append(0)
  343.             B.append(0)
  344.             B[j] = float(input('Elemento[' +str(j+1)+ '] da matriz B:'))
  345.  
  346.     for l in range (0, m):
  347.  
  348.         valorx = float(input('Digite um valor para x'+str(l+1)+': '))
  349.         x.append(valorx)
  350.         xnew.append(0.1)
  351.    
  352.  
  353.  
  354.     #x1, x2, x3 = funcaoAux()
  355.  
  356.     tempList = [0., 0., 0.]
  357.  
  358.     # Ajeita a matriz
  359.     for u in range (0 , m):
  360.        
  361.         pivot = A[u][u]
  362.         B[u] = B[u] / A[u][u]
  363.  
  364.         for v in range (m , 0, -1):
  365.  
  366.             A[u][v-1] = A[u][v-1] / pivot
  367.  
  368.     valorxnew = 0
  369.  
  370.     for t in range (0, 1000, 1):
  371.  
  372.         for c in range (0, m, 1):
  373.  
  374.             parte = 0
  375.  
  376.             for d in range (0, m, 1):
  377.  
  378.                 if d != c:
  379.                     parte += A[c][d]*x[d]
  380.  
  381.             valorxnew = B[c] - parte
  382.             tempList[c] = valorxnew
  383.            
  384.  
  385.         for i in range (0, len(x), 1):
  386.  
  387.             x[i] = tempList[i]
  388.  
  389.         print(x)
  390.                
  391.         try:
  392.  
  393.             cp = abs(xnew[len(xnew)-1] - valorxnew) / abs(xnew[len(xnew)-1])        
  394.  
  395.             if cp < precisao:
  396.  
  397.                 print('Critério de parada ativado!')
  398.                 print('O cálculo foi completado em apenas: ' + str(t) + ' processos!')
  399.                 break
  400.  
  401.             for i in range (0, len(xnew), 1):
  402.  
  403.                 xnew[i] = x[i]
  404.  
  405.  
  406.         except ZeroDivisionError:
  407.  
  408.             pass
  409.  
  410.    
  411.  
  412.     print('Conjunto de soluções:', xnew)
  413.  
  414. def GaussSeidel ():
  415.  
  416.     verificaMatriz()
  417.  
  418.     A = []
  419.     B = []
  420.     Coef = []
  421.     x = []
  422.     xnew = []
  423.    
  424.     m=int(input('Insira o numero de linhas: '))
  425.     precisao = float(input('Precisão desejada:'))
  426.     matriz=np.zeros([m,m])
  427.     A=np.zeros([m,m])
  428.     #B=np.zeros([m,m])
  429.     print('Insira os elementos da matriz')
  430.  
  431.     for l in range(0,m):
  432.          
  433.           for c in range(0,m, 1):
  434.              
  435.                 matriz[l,c]=(input('Elemento a['+str(l+1)+","+str(c+1)+"] da matriz A (coeficientes): "))
  436.                 matriz[l,c]=float(matriz[l,c])
  437.                 A[l,c]=matriz[l,c]
  438.  
  439.     for j in range(0, m):
  440.        
  441.             Coef.append(0)
  442.             B.append(0)
  443.             B[j] = float(input('Elemento[' +str(j+1)+ '] da matriz B:'))
  444.  
  445.     for l in range (0, m):
  446.  
  447.         valorx = float(input('Digite um valor para x'+str(l+1)+': '))
  448.         x.append(valorx)
  449.         xnew.append(0.1)
  450.  
  451.  
  452.     # Ajeita a matriz
  453.     for u in range (0 , m):
  454.        
  455.         pivot = A[u][u]
  456.         B[u] = B[u] / A[u][u]
  457.  
  458.         for v in range (m , 0, -1):
  459.  
  460.             A[u][v-1] = A[u][v-1] / pivot
  461.  
  462.     valorxnew = 0
  463.  
  464.     for t in range (0, 1000, 1):
  465.  
  466.         for c in range (0, m, 1):
  467.  
  468.             parte = 0
  469.  
  470.             for d in range (0, m, 1):
  471.  
  472.                 if d != c:
  473.                     parte += A[c][d]*x[d]
  474.  
  475.             valorxnew = B[c] - parte
  476.  
  477.             x[c] = valorxnew
  478.  
  479.         print(x)
  480.                
  481.         try:
  482.  
  483.             cp = abs(xnew[len(xnew)-1] - valorxnew) / abs(xnew[len(xnew)-1])        
  484.  
  485.             if cp < precisao:
  486.  
  487.                 print('Critério de parada ativado!')
  488.                 print('O cálculo foi completado em apenas: ' + str(t) + ' processos!')
  489.                 break
  490.  
  491.             for i in range (0, len(xnew), 1):
  492.  
  493.                 xnew[i] = x[i]
  494.  
  495.  
  496.         except ZeroDivisionError:
  497.  
  498.             pass
  499.  
  500.    
  501.  
  502.     print('Conjunto de soluções:', xnew)
  503.  
  504.  
  505. # =================================================================================================================
  506. # =====================================   INTERPOLADOR DE LAGRANGE   ==============================================
  507. # =================================================================================================================
  508.  
  509. def interpolLagrange():
  510.  
  511.     m = int(input('Insira o grau do polinômio: '))
  512.     matriz=np.zeros([m+1])
  513.     A=np.zeros([m+1,m+1])
  514.     B=np.zeros([m+1])
  515.     print("Insira os pontos:")
  516.  
  517.     for e in range(0, m+1):
  518.                      
  519.                 matriz[e]=(input('X' + str(e+1) + ": "))
  520.                 B[e]=(input('Y' + str(e+1) + ": "))
  521.  
  522.                 #A[e,1]=matriz[e,1]
  523.                 #A[e,2]=matriz[e,2]
  524.  
  525.     # Calcula os coeficientes e atualiza na matriz A
  526.     for k in range (0, m+1):
  527.  
  528.         for p in range (0, m+1):
  529.            
  530.             A[k, p] = matriz[k]**p
  531.  
  532.  
  533.     #--------------------
  534.     # Resolve a fucking mnatriz A com muita raiva
  535.     # GAUSS-SEIDEL!!
  536.     #--------------------
  537.  
  538.     x = []
  539.  
  540.     for i in range (0, m+1):
  541.  
  542.         x.append(0)
  543.  
  544.     # Ajeita a matriz
  545.     for u in range (0 , m+1):
  546.        
  547.         pivot = A[u][u]
  548.         B[u] = B[u] / A[u][u]
  549.  
  550.         for v in range (m+1 , 0, -1):
  551.  
  552.             A[u][v-1] = A[u][v-1] / pivot
  553.  
  554.     valorxnew = 0
  555.  
  556.     for t in range (0, 1000, 1):
  557.  
  558.         for c in range (0, m+1, 1):
  559.  
  560.             parte = 0
  561.  
  562.             for d in range (0, m+1, 1):
  563.  
  564.                 if d != c:
  565.                     parte += A[c][d]*x[d]
  566.  
  567.             valorxnew = B[c] - parte
  568.  
  569.             x[c] = valorxnew
  570.    
  571.     meuPolinomio = ""
  572.  
  573.     for b in range (1, 4):
  574.  
  575.         meuPolinomio += " (" + str(round(x[b], 2)) + "x^" + str(b) +") + "
  576.  
  577.     print('Polinômio interpolador: ' + str(round(x[b], 2)) + " " + meuPolinomio)
  578.  
  579.     print(x)
  580.    
  581.  
  582.                
  583.  
  584. # =================================================================================================================
  585. # =====================================    INTERPOLADOR DE NEWTON    ==============================================
  586. # =================================================================================================================
  587.  
  588. def multiplicadorPolinomial(a, b):
  589.  
  590.     # a = n° de polinomios
  591.     # b = lista contendo os valores de cada polinômio
  592.     m = a
  593.  
  594.     EstruturaDePol = []
  595.     MeuResultado = []
  596.     Pol = []
  597.  
  598.     for i in range (0, m):
  599.  
  600.         Pol.append(0)
  601.  
  602.     for i in range (0, m+1):
  603.  
  604.         EstruturaDePol.append(0)
  605.         MeuResultado.append(0)
  606.  
  607.     for i in range (0, m):
  608.  
  609.         Pol[i] = b[i]
  610.  
  611.     # Constrói o primeiro polinômio base - (k + j)
  612.     #A = K1*K2
  613.     #B = J1 + J2
  614.     #C = J1*J2
  615.     # Modelo básico: Ck = Ck*Kn + Bk-1*Jn
  616.  
  617.     MeuResultado[0] = 1
  618.     MeuResultado[1] = Pol[0] + Pol[1]
  619.     MeuResultado[2] = Pol[0]*Pol[1]
  620.  
  621.     # Construtor de polinômio
  622.     for k in range (0 ,m):
  623.  
  624.         EstruturaDePol[k] = MeuResultado[k]
  625.        
  626.     if (m > 2):
  627.  
  628.             for i in range (2, m):
  629.  
  630.                 for k in range (0, m+1):
  631.  
  632.                     if k == 0:
  633.  
  634.                         MeuResultado[k] = EstruturaDePol[k]*1
  635.  
  636.                     if k == m:
  637.  
  638.                         MeuResultado[k] = EstruturaDePol[k-1]*Pol[i]
  639.  
  640.                     else:
  641.  
  642.                         MeuResultado[k] = EstruturaDePol[k]*1 + EstruturaDePol[k-1]*Pol[i]
  643.  
  644.                 for j in range (0 , m+1):
  645.  
  646.                     EstruturaDePol[j] = MeuResultado[j]
  647.  
  648.  
  649.                    
  650.     return MeuResultado
  651.  
  652. def interpolNewton():
  653.  
  654.  
  655.     q = 1
  656.  
  657.     m = int(input('Insira o grau do polinômio: '))
  658.     PolNewton = np.zeros([m+1])
  659.     matriz=np.zeros([m+1])
  660.     X=np.zeros([m+1])
  661.     Y=np.zeros([m+1])
  662.     Dif=np.zeros([m+1, m+1])
  663.     print("Insira os pontos:")
  664.  
  665.     for e in range(0, m+1):
  666.                      
  667.                 X[e]=(input('X' + str(e+1) + ": "))
  668.                 Y[e]=(input('Y' + str(e+1) + ": "))
  669.  
  670.  
  671.     # Diferenças divididas
  672.  
  673.     # Diferença - f[x]  
  674.     for k in range (0, m+1):
  675.        
  676.             Dif[0][k] = Y[k]
  677.  
  678.     for i in range (1, m+1):
  679.        
  680.         for v in range (0, m-i+1):
  681.  
  682.             if i == m:
  683.  
  684.                 Dif[i][v] = (Dif[i-1][v+1] - Dif[i-1][v]) / (X[i] - X[0])
  685.  
  686.             else:
  687.  
  688.                 Dif[i][v] = (Dif[i-1][v+1] - Dif[i-1][v]) / (X[v+1] - X[v])
  689.  
  690.            
  691.  
  692.     #print(Dif[0])
  693.     #print(Dif[1])
  694.     #print(Dif[2])
  695.  
  696.  
  697.     PolNewton[len(PolNewton)-1] = Dif[0][0]
  698.  
  699.  
  700.     # Polinômio interpolador de newton
  701.     # Calcula cada "parte" do polinômio de Newton
  702.  
  703.     TermoPolinomial = np.zeros([m+1])
  704.  
  705.     # Representas cada "parte" (X-X10)*f[X0,X1] ...
  706.     for i in range (0, m):
  707.  
  708.         if i == 0:
  709.  
  710.             #TermoPolinomial[m] = 1
  711.             TermoPolinomial[len(TermoPolinomial)-1] = Dif[0][0]
  712.             TermoPolinomial[len(TermoPolinomial)-1] = TermoPolinomial[len(TermoPolinomial)-1] + (X[0]*(-1) * Dif[1][0])
  713.             TermoPolinomial[len(TermoPolinomial)-2] = Dif[1][0]
  714.  
  715.         else:
  716.  
  717.             ListaTest = []
  718.             for j in range (0, m):
  719.                
  720.                 ListaTest.append(X[j]*(-1))
  721.  
  722.             Lista = multiplicadorPolinomial(i+1, ListaTest)
  723.  
  724.             # Produtório & Somatório
  725.             for k in range (len(Lista)-1, -1, -1):
  726.  
  727.                 TermoPolinomial[len(TermoPolinomial)-len(Lista)+k] = TermoPolinomial[len(TermoPolinomial)-len(Lista)+k] + (Lista[k] * Dif[i+1][0])
  728.  
  729.  
  730.        
  731.  
  732.     print(TermoPolinomial)
  733.  
  734.    
  735.    
  736.  
  737.    
  738.  
  739.    
  740.  
  741.  
  742.  
  743.  
  744. # =================================================================================================================
  745. # =======================================   CORPO PRINCIPAL DO PROGRAMA  ==========================================
  746. # =================================================================================================================
  747.  
  748.  
  749. while True:
  750.     print('*******************************************************************************')
  751.     print('*                                    MENU                                     *')
  752.     print('*                                                                             *')
  753.     print('*ESCOLHA O ASSUNTO:                                                           *')
  754.     print('*                                                                             *')
  755.     print('*⬛ 1. RAÍZES                                                                 *')
  756.     print('*                                                                             *')
  757.     print('*⬛ 2. SISTEMA DE EQUAÇÕES LINEARES                                           *')
  758.     print('*                                                                             *')
  759.     print('*⬛ 3. INTERPOLAÇÃO                                                           *')
  760.     print('*                                                                             *')
  761.     print('*⬛ 4. INTEGRAÇÃO NUMÉRICA                                                    *')
  762.     print('*                                                                             *')
  763.     print('*⬛ 5. EQUAÇÕES DIFERENCIAIS ORDINÁRIAS                                       *')
  764.     print('*                                                                             *')
  765.     print('*******************************************************************************')
  766.  
  767.     resposta= input('Digite o número correspondente ao assunto desejado ou s para encerrar:')
  768.  
  769.     if resposta == '1':
  770.         print('*******************************************************************************')
  771.         print('*ESCOLHA O MÉTODO:                                                            *')
  772.         print('*                                                                             *')
  773.         print('*⬛ 1. BISSECÇÃO                                                              *')
  774.         print('*                                                                             *')
  775.         print('*⬛ 2. NEWTON                                                                 *')
  776.         print('*                                                                             *')
  777.         print('*⬛ 3. SECANTES                                                               *')
  778.         print('*                                                                             *')
  779.         print('*******************************************************************************')
  780.  
  781.         resposta2= input('Digite o método desejado:')
  782.         if resposta2=='1':
  783.             bissecao()
  784.         if resposta2=='2':
  785.             newton()
  786.         if resposta2=='3':
  787.             secantes()
  788.            
  789.     if resposta == '2':
  790.             print('*******************************************************************************')
  791.             print('*ESCOLHA O MÉTODO:                                                            *')
  792.             print('*                                                                             *')
  793.             print('*⬛ 1. ELIMINAÇÃO DE GAUSS                                                    *')
  794.             print('*                                                                             *')
  795.             print('*⬛ 2. DECOMPOSIÇÃO LU                                                        *')
  796.             print('*                                                                             *')
  797.             print('*⬛ 3. JACOBI RICHARDSON                                                      *')
  798.             print('*                                                                             *')
  799.             print('*⬛ 4. GAUSS SEIDEL                                                           *')
  800.             print('*                                                                             *')
  801.             print('*******************************************************************************')
  802.             resposta2= input('Digite o método desejado:')
  803.             if resposta2 == '1':
  804.                 eliminacaogauss()
  805.             if resposta2 == '2':
  806.                 decomplu()
  807.             if resposta2 == "3":
  808.                 Jacobi()
  809.             if resposta2 == "4":
  810.                 GaussSeidel()
  811.          
  812.                
  813.     if resposta == '3':
  814.        
  815.             print('*******************************************************************************')
  816.             print('*ESCOLHA O MÉTODO:                                                            *')
  817.             print('*                                                                             *')
  818.             print('*⬛ 1. LAGRANGE                                                               *')
  819.             print('*                                                                             *')
  820.             print('*⬛ 2. NEWTON                                                                 *')
  821.             print('*                                                                             *')
  822.             print('*******************************************************************************')
  823.            
  824.             resposta3= input('Digite o método desejado:')
  825.  
  826.             if (resposta3 == "1"):
  827.  
  828.                 interpolLagrange()
  829.  
  830.             if (resposta3 == "2"):
  831.  
  832.                 interpolNewton()
  833.            
  834.     if resposta == '4':
  835.        
  836.             print('*******************************************************************************')
  837.             print('*ESCOLHA O MÉTODO:                                                            *')
  838.             print('*                                                                             *')
  839.             print('*⬛ 1. TRAPÉZIO                                                               *')
  840.             print('*                                                                             *')
  841.             print('*⬛ 2. 1/3 SIMPSON                                                            *')
  842.             print('*                                                                             *')
  843.             print('*⬛ 3. 3/8 DE SIMPSON                                                         *')
  844.             print('*                                                                             *')
  845.             print('*******************************************************************************')
  846.            
  847.             resposta4= input('Digite o método desejado:')
  848.            
  849.     if resposta == '5':
  850.        
  851.             print('*******************************************************************************')
  852.             print('*ESCOLHA O MÉTODO:                                                            *')
  853.             print('*                                                                             *')
  854.             print('*⬛ 1. RUNGE KUTTA 4ª ORDEM                                                    *')
  855.             print('*                                                                             *')
  856.             print('*******************************************************************************')
  857.            
  858.             resposta5= input('Digite o método desejado:')        
  859.    
  860.     if resposta == 's':
  861.         print('Obrigado por usar nosso programa! Esperamos que tenha gostado da experiência!')
  862.         break
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top