API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 12th, 2019
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.52 KB | None | 0 0
raw download clone embed print report
  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 multiplicadorPolinomial(a, b):
  510.  
  511. # a = n° de polinomios
  512. # b = lista contendo os valores de cada polinômio
  513. m = a
  514.  
  515. EstruturaDePol = []
  516. MeuResultado = []
  517. Pol = []
  518.  
  519. for i in range (0, m):
  520.  
  521. Pol.append(0)
  522.  
  523. for i in range (0, m+1):
  524.  
  525. EstruturaDePol.append(0)
  526. MeuResultado.append(0)
  527.  
  528. for i in range (0, m):
  529.  
  530. Pol[i] = b[i]
  531.  
  532. # Constrói o primeiro polinômio base - (k + j)
  533. #A = K1*K2
  534. #B = J1 + J2
  535. #C = J1*J2
  536. # Modelo básico: Ck = Ck*Kn + Bk-1*Jn
  537.  
  538. MeuResultado[0] = 1
  539. MeuResultado[1] = Pol[0] + Pol[1]
  540. MeuResultado[2] = Pol[0]*Pol[1]
  541.  
  542. # Construtor de polinômio
  543. for k in range (0 ,m):
  544.  
  545. EstruturaDePol[k] = MeuResultado[k]
  546.  
  547. if (m > 2):
  548.  
  549. for i in range (2, m):
  550.  
  551. for k in range (0, m+1):
  552.  
  553. if k == 0:
  554.  
  555. MeuResultado[k] = EstruturaDePol[k]*1
  556.  
  557. if k == m:
  558.  
  559. MeuResultado[k] = EstruturaDePol[k-1]*Pol[i]
  560.  
  561. else:
  562.  
  563. MeuResultado[k] = EstruturaDePol[k]*1 + EstruturaDePol[k-1]*Pol[i]
  564.  
  565. for j in range (0 , m+1):
  566.  
  567. EstruturaDePol[j] = MeuResultado[j]
  568.  
  569.  
  570.  
  571. return MeuResultado
  572.  
  573.  
  574.  
  575.  
  576. def interpolLagrange():
  577.  
  578. m = int(input('Insira o grau do polinômio: '))
  579. matriz=np.zeros([m+1])
  580. A=np.zeros([m+1,m+1])
  581. B=np.zeros([m+1])
  582. print("Insira os pontos:")
  583.  
  584. listaAuxiliar = []
  585.  
  586.  
  587. l = np.zeros([m+1,m+1])
  588.  
  589. for e in range(0, m+1):
  590.  
  591. matriz[e]=(input('X' + str(e+1) + ": "))
  592. B[e]=(input('Y' + str(e+1) + ": "))
  593.  
  594. #l.append(0)
  595. listaAuxiliar.append(matriz[e])
  596.  
  597. if matriz[e] in listaAuxiliar:
  598.  
  599. if listaAuxiliar.count(matriz[e]) > 1:
  600.  
  601. print("Erro, há dois valores iguais!")
  602. return False
  603.  
  604. valorDesconhecido = float(input("Valor a ser calculado no polinômio: "))
  605.  
  606.  
  607. for i in range (0, m):
  608.  
  609. listaAuxiliar2 = []
  610. den = 1
  611.  
  612. for k in range (0, m+1):
  613.  
  614. if k == i:
  615.  
  616. pass
  617.  
  618. else:
  619.  
  620. listaAuxiliar2.append((-1)*matriz[k])
  621. den = den*(matriz[i]-matriz[k])
  622.  
  623. num = multiplicadorPolinomial(len(listaAuxiliar2), listaAuxiliar2)
  624.  
  625. # Divide a lista (coeficientes) pelo denominador
  626. for k in range (0, m+1):
  627.  
  628. l[i][k] = B[i]*(num[k] / den)
  629.  
  630. x = []
  631.  
  632. for a in range (0, m+1):
  633. soma = 0
  634. for b in range (0, m+1):
  635.  
  636. soma += l[b][a]
  637.  
  638. x.append(soma)
  639.  
  640. print(x)
  641.  
  642. meuPolinomio = ""
  643.  
  644. for b in range (1, len(x)):
  645.  
  646. meuPolinomio += " (" + str(round(x[b], 2)) + "x^" + str(b) +") + "
  647.  
  648. print('Polinômio interpolador: ' + str(round(x[0], 2)) + " + " + meuPolinomio)
  649.  
  650. resultadoValorDesconhecido = 0
  651. for i in range (0, len(x), 1):
  652.  
  653. resultadoValorDesconhecido += x[i]*(valorDesconhecido**i)
  654.  
  655. print('Pn('+ str(valorDesconhecido) + ') = ' + str(resultadoValorDesconhecido))
  656.  
  657. print('Coeficientes:' , x)
  658. print('Formato dos coeficientes: c1 + c2*x + c3*x^2 + ... + cn*x^n')
  659.  
  660.  
  661.  
  662.  
  663.  
  664.  
  665. # =================================================================================================================
  666. # ===================================== INTERPOLADOR DE NEWTON ==============================================
  667. # =================================================================================================================
  668.  
  669. def multiplicadorPolinomial(a, b):
  670.  
  671. # a = n° de polinomios
  672. # b = lista contendo os valores de cada polinômio
  673. m = a
  674.  
  675. EstruturaDePol = []
  676. MeuResultado = []
  677. Pol = []
  678.  
  679. for i in range (0, m):
  680.  
  681. Pol.append(0)
  682.  
  683. for i in range (0, m+1):
  684.  
  685. EstruturaDePol.append(0)
  686. MeuResultado.append(0)
  687.  
  688. for i in range (0, m):
  689.  
  690. Pol[i] = b[i]
  691.  
  692. # Constrói o primeiro polinômio base - (k + j)
  693. #A = K1*K2
  694. #B = J1 + J2
  695. #C = J1*J2
  696. # Modelo básico: Ck = Ck*Kn + Bk-1*Jn
  697.  
  698. MeuResultado[0] = 1
  699. MeuResultado[1] = Pol[0] + Pol[1]
  700. MeuResultado[2] = Pol[0]*Pol[1]
  701.  
  702. # Construtor de polinômio
  703. for k in range (0 ,m):
  704.  
  705. EstruturaDePol[k] = MeuResultado[k]
  706.  
  707. if (m > 2):
  708.  
  709. for i in range (2, m):
  710.  
  711. for k in range (0, m+1):
  712.  
  713. if k == 0:
  714.  
  715. MeuResultado[k] = EstruturaDePol[k]*1
  716.  
  717. if k == m:
  718.  
  719. MeuResultado[k] = EstruturaDePol[k-1]*Pol[i]
  720.  
  721. else:
  722.  
  723. MeuResultado[k] = EstruturaDePol[k]*1 + EstruturaDePol[k-1]*Pol[i]
  724.  
  725. for j in range (0 , m+1):
  726.  
  727. EstruturaDePol[j] = MeuResultado[j]
  728.  
  729.  
  730.  
  731. return MeuResultado
  732.  
  733. def interpolNewton():
  734.  
  735.  
  736. q = 1
  737.  
  738. m = int(input('Insira o grau do polinômio: '))
  739. PolNewton = np.zeros([m+1])
  740. matriz=np.zeros([m+1])
  741. X=np.zeros([m+1])
  742. Y=np.zeros([m+1])
  743. Dif=np.zeros([m+1, m+1])
  744. print("Insira os pontos:")
  745.  
  746. listaAuxiliar = []
  747.  
  748. for e in range(0, m+1):
  749.  
  750. X[e]=(input('X' + str(e+1) + ": "))
  751. Y[e]=(input('Y' + str(e+1) + ": "))
  752.  
  753. listaAuxiliar.append(matriz[e])
  754.  
  755. if matriz[e] in listaAuxiliar:
  756.  
  757. if listaAuxiliar.count(X[e]) > 1:
  758.  
  759. print("Erro, há dois valores iguais!")
  760. return False
  761.  
  762. valorDesconhecido = float(input("Valor a ser calculado no polinômio: "))
  763.  
  764. listaParalela = np.zeros([m+1, m+1])
  765.  
  766. # Diferenças divididas
  767.  
  768. # Diferença - f[x]
  769. for k in range (0, m+1):
  770.  
  771. Dif[0][k] = Y[k]
  772.  
  773. for i in range (1, m+1):
  774.  
  775. for v in range (0, m-i+1):
  776.  
  777. Dif[i][v] = (Dif[i-1][v+1] - Dif[i-1][v]) / (X[v+i] - X[v])
  778.  
  779.  
  780.  
  781.  
  782. #print(Dif[0])
  783. #print(Dif[1])
  784. #print(Dif[2])
  785.  
  786.  
  787. PolNewton[len(PolNewton)-1] = Dif[0][0]
  788.  
  789.  
  790. # Polinômio interpolador de newton
  791. # Calcula cada "parte" do polinômio de Newton
  792.  
  793. TermoPolinomial = np.zeros([m+1])
  794.  
  795. # Representas cada "parte" (X-X10)*f[X0,X1] ...
  796. for i in range (0, m):
  797.  
  798. if i == 0:
  799.  
  800. #TermoPolinomial[m] = 1
  801. TermoPolinomial[len(TermoPolinomial)-1] = Dif[0][0]
  802. TermoPolinomial[len(TermoPolinomial)-1] = TermoPolinomial[len(TermoPolinomial)-1] + (X[0]*(-1) * Dif[1][0])
  803. TermoPolinomial[len(TermoPolinomial)-2] = Dif[1][0]
  804.  
  805. else:
  806.  
  807. ListaTest = []
  808. for j in range (0, m):
  809.  
  810. ListaTest.append(X[j]*(-1))
  811.  
  812. Lista = multiplicadorPolinomial(i+1, ListaTest)
  813.  
  814. # Produtório & Somatório
  815. for k in range (len(Lista)-1, -1, -1):
  816.  
  817. TermoPolinomial[len(TermoPolinomial)-len(Lista)+k] = TermoPolinomial[len(TermoPolinomial)-len(Lista)+k] + (Lista[k] * Dif[i+1][0])
  818.  
  819.  
  820. print("Diferenças:")
  821. print(str(Dif))
  822. print("Coeficientes: " + str(TermoPolinomial))
  823. print('Formato dos coeficientes: c1*x^n + c2*x^n-1 + c3*x^n-2 + ... + cn*x^0')
  824.  
  825. resultadoValorDesconhecido = 0
  826. for i in range (0, len(TermoPolinomial), 1):
  827.  
  828. exp = len(TermoPolinomial) - i - 1
  829. resultadoValorDesconhecido += TermoPolinomial[i]*(valorDesconhecido**exp)
  830.  
  831. print('Pn('+ str(valorDesconhecido) +') = ' + str(resultadoValorDesconhecido))
  832.  
  833.  
  834.  
  835. # =================================================================================================================
  836. # ======================================= TRAPÉZIO ==========================================
  837. # =================================================================================================================
  838.  
  839. def funcaoTrapezio(x):
  840.  
  841. y = x**2 + 10*x
  842. return y
  843.  
  844. def trapezio ():
  845.  
  846. h = float(input("Diferencial (h): "))
  847. a = float(input("Intervalo inferior (a): "))
  848. b = float(input("Intervalo superior (b): "))
  849. n = (b-a) / h
  850. n = int(round(n , 0))
  851.  
  852. soma = 0
  853. for i in range (1, n):
  854.  
  855. soma += funcaoTrapezio(a+h*i)
  856.  
  857. f0 = funcaoTrapezio(a)
  858. fn = funcaoTrapezio(a+h*n)
  859.  
  860. Integral = (h/2) * (f0 + 2*(soma) + fn)
  861. print('Valor da integral numérica:' , Integral)
  862.  
  863. # =================================================================================================================
  864. # ======================================= SIMPSON 1/3 ==========================================
  865. # =================================================================================================================
  866.  
  867. def funcaoSimpson13(x):
  868.  
  869. y = x**2 + 10*x
  870. return y
  871.  
  872. def simpson13 ():
  873.  
  874. h = float(input("Diferencial (h): "))
  875. a = float(input("Intervalo inferior (a): "))
  876. b = float(input("Intervalo superior (b): "))
  877. n = (b-a) / (2*h)
  878. n = int(round(n , 0))
  879.  
  880. soma = 0
  881. for i in range (1, 2*n):
  882.  
  883. ## Checa se é par
  884. if (i % 2 == 0):
  885.  
  886. soma += 2*funcaoSimpson13(a+h*i)
  887.  
  888. else:
  889.  
  890. soma += 4*funcaoSimpson13(a+h*i)
  891.  
  892.  
  893.  
  894. f0 = funcaoSimpson13(a)
  895. fn = funcaoSimpson13(a+(h*2*n))
  896.  
  897. Integral = (h/3) * (f0 + soma + fn)
  898. print('Valor da integral numérica:' , Integral)
  899.  
  900. # =================================================================================================================
  901. # ======================================= SIMPSON 3/8 ==========================================
  902. # =================================================================================================================
  903.  
  904. def funcaoSimpson38(x):
  905.  
  906. y = x**2 + 10*x
  907. return y
  908.  
  909. def simpson38 ():
  910.  
  911. h = float(input("Diferencial (h): "))
  912. a = float(input("Intervalo inferior (a): "))
  913. b = float(input("Intervalo superior (b): "))
  914. n = (b-a) / (3*h)
  915. n = int(round(n , 0))
  916.  
  917. soma = 0
  918. k = 0
  919. for i in range (1, 3*n):
  920.  
  921. ## Checa se é núltiplo de três
  922. if (k == 2):
  923.  
  924. soma += 2*funcaoSimpson38(a+h*i)
  925. k = 0
  926.  
  927.  
  928. else:
  929.  
  930. soma += 3*funcaoSimpson38(a+h*i)
  931. k += 1
  932.  
  933.  
  934.  
  935. f0 = funcaoSimpson38(a)
  936. fn = funcaoSimpson38(a+(h*3*n))
  937.  
  938. Integral = (3*h/8) * (f0 + soma + fn)
  939. print('Valor da integral numérica:' , Integral)
  940.  
  941.  
  942. # =================================================================================================================
  943. # ======================================= RUNGE-KUTTA ==========================================
  944. # =================================================================================================================
  945.  
  946. def funcaoRungeKutta(x , y):
  947.  
  948. dy = - y + x + 2
  949. return dy
  950.  
  951. def rungeKutta ():
  952.  
  953. h = float(input("Diferencial (h): "))
  954. a = float(input("Intervalo inferior (a): "))
  955. b = float(input("Intervalo superior (b): "))
  956. Xn = float(input("X(0): "))
  957. Yn = float(input("Y(0): "))
  958. n = (b-a) / (h)
  959. n = int(round(n , 0))
  960.  
  961. #k1 = 0
  962. #k2 = 0
  963. #k3 = 0
  964. #k4 = 0
  965. for i in range (0, n):
  966.  
  967. k1 = funcaoRungeKutta(Xn, Yn)
  968. print("n = "+str(i+1)+ " k1 = " , k1)
  969. k2 = funcaoRungeKutta(Xn + h/2, Yn + (k1*h)/2)
  970. print("n = "+str(i+1)+ " k2 =" , k2)
  971. k3 = funcaoRungeKutta(Xn + h/2, Yn + (k2*h)/2)
  972. print("n = "+str(i+1)+ " k3 =" , k3)
  973. k4 = funcaoRungeKutta(Xn + h/2, Yn + (k3*h))
  974. print("n = "+str(i+1)+ " k4 =" , k4)
  975.  
  976. Xn = Xn + h
  977. Yn = Yn + (h/6)*(k1 + 2*k2 + 2*k3 + k4)
  978.  
  979. print("Xn:" , Xn)
  980. print("Yn:" , Yn)
  981.  
  982. print('')
  983. print('')
  984. print( "(X(" + str(i + 1) + ") , Y(" + str(i + 1) + ")) = (" + str(round(Xn, 4)) + " , " + str(round(Yn, 4)) + ")" )
  985.  
  986.  
  987. # =================================================================================================================
  988. # ======================================= CORPO PRINCIPAL DO PROGRAMA ==========================================
  989. # =================================================================================================================
  990.  
  991.  
  992. while True:
  993. print('*******************************************************************************')
  994. print('* MENU *')
  995. print('* *')
  996. print('*ESCOLHA O ASSUNTO: *')
  997. print('* *')
  998. print('*⬛ 1. RAÍZES *')
  999. print('* *')
  1000. print('*⬛ 2. SISTEMA DE EQUAÇÕES LINEARES *')
  1001. print('* *')
  1002. print('*⬛ 3. INTERPOLAÇÃO *')
  1003. print('* *')
  1004. print('*⬛ 4. INTEGRAÇÃO NUMÉRICA *')
  1005. print('* *')
  1006. print('*⬛ 5. EQUAÇÕES DIFERENCIAIS ORDINÁRIAS *')
  1007. print('* *')
  1008. print('*******************************************************************************')
  1009.  
  1010. resposta= input('Digite o número correspondente ao assunto desejado ou s para encerrar:')
  1011.  
  1012. if resposta == '1':
  1013. print('*******************************************************************************')
  1014. print('*ESCOLHA O MÉTODO: *')
  1015. print('* *')
  1016. print('*⬛ 1. BISSECÇÃO *')
  1017. print('* *')
  1018. print('*⬛ 2. NEWTON *')
  1019. print('* *')
  1020. print('*⬛ 3. SECANTES *')
  1021. print('* *')
  1022. print('*******************************************************************************')
  1023.  
  1024. resposta2= input('Digite o método desejado:')
  1025. if resposta2=='1':
  1026. bissecao()
  1027. if resposta2=='2':
  1028. newton()
  1029. if resposta2=='3':
  1030. secantes()
  1031.  
  1032. if resposta == '2':
  1033. print('*******************************************************************************')
  1034. print('*ESCOLHA O MÉTODO: *')
  1035. print('* *')
  1036. print('*⬛ 1. ELIMINAÇÃO DE GAUSS *')
  1037. print('* *')
  1038. print('*⬛ 2. DECOMPOSIÇÃO LU *')
  1039. print('* *')
  1040. print('*⬛ 3. JACOBI RICHARDSON *')
  1041. print('* *')
  1042. print('*⬛ 4. GAUSS SEIDEL *')
  1043. print('* *')
  1044. print('*******************************************************************************')
  1045. resposta2= input('Digite o método desejado:')
  1046. if resposta2 == '1':
  1047. eliminacaogauss()
  1048. if resposta2 == '2':
  1049. decomplu()
  1050. if resposta2 == "3":
  1051. Jacobi()
  1052. if resposta2 == "4":
  1053. GaussSeidel()
  1054.  
  1055.  
  1056. if resposta == '3':
  1057.  
  1058. print('*******************************************************************************')
  1059. print('*ESCOLHA O MÉTODO: *')
  1060. print('* *')
  1061. print('*⬛ 1. LAGRANGE *')
  1062. print('* *')
  1063. print('*⬛ 2. NEWTON *')
  1064. print('* *')
  1065. print('*******************************************************************************')
  1066.  
  1067. resposta3= input('Digite o método desejado:')
  1068.  
  1069. if (resposta3 == "1"):
  1070.  
  1071. interpolLagrange()
  1072.  
  1073. if (resposta3 == "2"):
  1074.  
  1075. interpolNewton()
  1076.  
  1077. if resposta == '4':
  1078.  
  1079. print('*******************************************************************************')
  1080. print('*ESCOLHA O MÉTODO: *')
  1081. print('* *')
  1082. print('*⬛ 1. TRAPÉZIO *')
  1083. print('* *')
  1084. print('*⬛ 2. 1/3 SIMPSON *')
  1085. print('* *')
  1086. print('*⬛ 3. 3/8 DE SIMPSON *')
  1087. print('* *')
  1088. print('*******************************************************************************')
  1089.  
  1090. resposta4= input('Digite o método desejado:')
  1091.  
  1092. if (resposta4 == "1"):
  1093.  
  1094. trapezio()
  1095.  
  1096. if (resposta4 == "2"):
  1097.  
  1098. simpson13()
  1099.  
  1100. if (resposta4 == "3"):
  1101.  
  1102. simpson38()
  1103.  
  1104. if resposta == '5':
  1105.  
  1106. print('*******************************************************************************')
  1107. print('*ESCOLHA O MÉTODO: *')
  1108. print('* *')
  1109. print('*⬛ 1. RUNGE KUTTA 4ª ORDEM *')
  1110. print('* *')
  1111. print('*******************************************************************************')
  1112.  
  1113. resposta5= input('Digite o método desejado:')
  1114.  
  1115. if resposta5 == '1':
  1116.  
  1117. rungeKutta()
  1118.  
  1119. if resposta == 's':
  1120. print('Obrigado por usar nosso programa! Esperamos que tenha gostado da experiência!')
  1121. break
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!