def metodo(a, b, e, k, kmax, sf, r, pDec):
    # Calculos de Variaveis
    s = ""
    fa = f(a, sf, pDec)
    fb = f(b, sf, pDec)
    xk = mm.mpf((a * abs(fb) + b * abs(fa)) / (abs(fa) + abs(fb)))
    fxk = f(xk, sf, pDec)
    ek = mm.mpf(cE(sf, a, b, xk, pDec))

    # Registrar Resultados
    r[k].append(a)
    r[k].append(xk)
    r[k].append(b)
    r[k].append(ek)
    r[k].append(fa)
    r[k].append(fxk)
    r[k].append(fb)

    # Definir Próximo Intervalo de Análise
    if ((fa * fxk) < 0):
        b = xk
    else:
        a = xk

    # Recursividade
    if ((ek > e) and (k < kmax)):
        k += 1
        r.append([])
        s = metodo(a, b, e, k, kmax, sf, r, pDec)
    else:
        s = ("Método da Posição Falsa:\nNúmero de Iterações\t=\t" +
             str(k + 1) + "\nRaiz da Função f(ẋ)\t=\t" + str(xk) +
             "\nValor f(ẋ)\t\t=\t" + str(fxk) + "\nErro\t\t\t=\t" + str(ek))

    return s
Example #2
0
def metodo(xkAtual, xkProx, e, k, kmax, sf, spf, r, pDec):
    # Calculos de Variaveis
    s = ""
    xkAnterior = xkAtual
    xkAtual = xkProx
    fxkA = f(xkAtual, sf, pDec)
    xkProx = f(xkAtual, spf, pDec)
    ek = mm.mpf(cE(sf, xkAtual, xkAnterior, xkAtual, pDec, k))

    # Registrar Resultados
    r[k].append(xkAtual)
    r[k].append(fxkA)
    r[k].append(ek)

    if ((ek > e) and (k <= kmax)):
        k += 1
        r.append([])
        s = metodo(xkAtual, xkProx, e, k, kmax, sf, spf, r, pDec)
    else:
        fxkP = f(xkProx, sf, pDec)
        s = ("Método do Ponto Fixo\nIterações\t=\t" + str(k) +
             "\nRaiz da Função f(ẋ)\t\t=\t" + str(xkAtual) +
             "\nValor f(ẋ)\t=\t" + str(fxkA) + "\nErro\t=\t" + str(ek))

    return s
Example #3
0
def metodo(xkAnterior, xkAtual, xkProx, e, k, kmax, sf, r, pDec):
    # Definição Precisão
    mm.mp.dps = pDec

    # Calculos de Variaveis
    s = ""
    fxkA = f(xkAtual, sf, pDec)
    fxkP = f(xkProx, sf, pDec)
    xkProxProx = ((xkAtual * fxkP) - (xkProx * fxkA)) / (fxkP - fxkA)
    ek = mm.mpf(cE(sf, xkAtual, xkAnterior, xkAtual, pDec, k))

    # Registrar Resultados
    r[k].append(xkAtual)
    r[k].append(fxkA)
    r[k].append(ek)

    # Recursividade
    if ((ek > e) and (k <= kmax)):
        k += 1
        r.append([])
        s = metodo(xkAtual, xkProx, xkProxProx, e, k, kmax, sf, r, pDec)
    else:
        s = ("Método da Secante\nNúmero de Iterações\t=\t" + str(k) +
             "\nRaiz da Função f(ẋ)\t=\t" + str(xkAtual) +
             "\nValor f(ẋ)\t\t=\t" + str(fxkA) + "\nErro\t\t\t=\t" + str(ek))

    return s
def metodo(xkAnterior,xkAtual,xkProx,e,k,sf,r,pDec):
	# Definir Precisão
	mm.mp.dps = pDec
	
	# Calculos de Variaveis
	s = ""
	fxkA = f(xkAtual,sf,pDec)
	fxkP = f(xkProx,sf,pDec)
	xkProxProx = ( (xkAtual*fxkP) - (xkProx*fxkA) ) / ( fxkP - fxkA )
	ek = mm.mpf(cE(sf,xkAtual,xkAnterior,xkAtual,pDec,k))

	# Registrar Resultados
	r[k].append(xkAtual)
	r[k].append(fxkA)
	r[k].append(ek)
	
	# Recursividade
	if(ek>e):
		k+=1
		r.append([])
		s = metodo(xkAtual,xkProx,xkProxProx,e,k,sf,r,pDec)
	else:
		s = ("Secante\nInterações\t=\t"+str(k+1)+"\nRaiz\t\t=\t"+str(xkAtual)+"\nFunção da Raiz\t=\t"+str(fxkA)+"\ne de parada\t=\t"+str(ek))
		print(s)
		s = xkAtual

	return s
Example #5
0
def metodo(xkAtual, xkProx, e, k, kmax, sf, sdf, r, pDec):
    # Calculos de Variaveis
    s = ""
    xkAnterior = xkAtual
    xkAtual = xkProx
    fxkA = f(xkAtual, sf, pDec)
    dfxkA = f(xkAtual, sdf, pDec)
    xkProx = xkAtual - (fxkA / dfxkA)
    ek = mm.mpf(cE(sf, xkAtual, xkAnterior, xkAtual, pDec, k))

    # Registrar Resultados
    r[k].append(xkAtual)
    r[k].append(fxkA)
    r[k].append(ek)

    # Recursividade
    if ((ek > e) and (k <= kmax)):
        k += 1
        r.append([])
        s = metodo(xkAtual, xkProx, e, k, kmax, sf, sdf, r, pDec)
    else:
        s = ("Método de Newton-Raphson\nNúmero de Iterações\t=\t" + str(k) +
             "\nRaiz da Função f(ẋ)\t=\t" + str(xkAtual) +
             "\nValor f(ẋ)\t\t=\t" + str(fxkA) + "\nErro\t\t\t=\t" + str(ek))

    return s
def ddFuncTS(d):
	chave = True
	for x in np.arange(d.a,d.b,d.e):
		try:
			if(f(x,d.sddf)*f(x-d.e,d.sddf)<0):
				chave = False
				break
		except:
			chave = False
			break
	return chave
def xRaizesInter(d):
	raizes = 0
	r = ""
	for x in np.arange(d.a,d.b,d.e):
		try:
			if(f(x,d.sf)*f(x-d.e,d.sf)<0):
				raizes += 1
		except:
			r += "Possíveis raízes no Intervalo\t-\tIntervalo Inválido\n"
			return r
	r += "Possíveis raízes no Intervalo\t-\t%i\n"%(raizes)
	return r
def FuncTS(d):
	raizes = 0
	chave = True
	for x in np.arange(d.a,d.b,d.e):
		try:
			if(f(x,d.sf)*f(x-d.e,d.sf)<0):
				raizes += 1
		except:
			chave = False
			break
	if(raizes!=1):
		chave = False
	return chave
	def cExtrapolarX(self, raiz):
		prec = int(raiz.raiz.e_precisão.get())
		mm.mp.dps = prec
		xs = self.e_extrapolarX.get()
		x = mm.mpf(xs)
		txt = self.txtResp + "\n\nExtrapolação em "+xs+"(x) = " + str(f(x,self.sf,prec))
		self.texto.config(text=txt)
 def cInterpolarX(self):
     xs = self.e_extrapolarX.get()
     self.raiz.lerDados()
     mm.mp.dps = self.raiz.prec
     x = mm.mpf(xs)
     txt = self.txtResp + "\nInterpolar em %s(x) = " % (xs) + str(
         f(x, self.sf, self.raiz.prec)) + "\n"
     self.texto.config(text=txt)
Example #11
0
def Simpson13(dIN):
    # Definir Dados
    # Precisão
    pDec = dIN.pDec
    mm.mp.dps = pDec
    # Tratamento das String de Função
    sf = tSf(dIN.sf)
    sdf = tSf(dIN.sdf)
    # Dados de Análise
    a = mm.mpf(dIN.a)
    b = mm.mpf(dIN.b)
    m = int(dIN.m)
    if (dIN.c == ""):
        c = mm.mpf((b + a) / 2)
    else:
        c = mm.mpf(dIN.c)
    h = mm.mpf((b - a) / m)

    # Cálculo da Integral
    I = mm.mpf('0')
    for i in range(m):
        xi = mm.mpf(a + (i * h))
        if (i == 0 or i == m):
            I += mm.mpf(f((xi), sf, pDec))
        elif (i % 2 == 1):
            I += mm.mpf(4 * f((xi), sf, pDec))
        else:
            I += mm.mpf(2 * f((xi), sf, pDec))
    I = mm.mpf((h / 3) * I)

    E = mm.mpf('0')
    # Calculo do Erro
    if (dIN.vc == 1):
        E = mm.mpf((mm.power(h, 5) / 90) * f(c, sdf, pDec))

    # Gerar e Retornar Resposta
    resp = ""
    if (dIN.vc == 1):
        resp += ("1/3 de Simpson\n\nI = " + str(I) + " ± " + str(E))
        resp += ("\n\nI+E = " + str(mm.mpf(I + E)))
        resp += ("\nI-E = " + str(mm.mpf(I - E)))
    else:
        resp += ("1/3 de Simpson\n\nI = " + str(I))
    return resp
Example #12
0
def calcularE(sf,a,b,xk,pDec=16,k=1):
	mm.mp.dps = pDec
	mm.mp.trap_complex = True
	
	erro = mm.mpf('0.0')
	fxk = mm.mpf(abs(f(xk,sf,pDec)))
	if(k!=0):
		difab = mm.mpf(abs(a-b))
		if(difab<fxk):
			erro = difab
		else:
			erro = fxk
	else:
		erro = fxk

	return erro
def continuidade(d):
	r = ""
	# Continuidade Função f(x)
	chave = True
	for x in np.arange(d.a,d.b,d.e):
		try:
			f(x,d.sf)
		except:
			chave = False
	r += "Continuidade em f(x)\t\t-\t"
	if(chave):
		r += "Válida\n"
	else:
		r += "Inválida\n"

	# Continuidade da Derivada Primeira da Função f(x)
	chave = True
	for x in np.arange(d.a,d.b,d.e):
		try:
			f(x,d.sdf)
		except:
			chave = False
	r += "Continuidade em f'(x)\t\t-\t"
	if(chave):
		r += "Válida\n"
	else:
		r += "Inválida\n"

	# Continuidade da Derivada Segunda da Função f(x)
	chave = True
	for x in np.arange(d.a,d.b,d.e):
		try:
			f(x,d.sddf)
		except:
			chave = False
	r += "Continuidade em f''(x)\t\t-\t"
	if(chave):
		r += "Válida\n"
	else:
		r += "Inválida\n"

	return r