Пример #1
0
def obter_alpha(funcao, derivada, erro_fornecido = 0.0, limite = 20, x_inicial = 0.0):
  """ Quasi newton utilizando derivada fixa em x0 """
  
  xm = x_inicial
  der = derivada(xm)
  
  if(der is 0.0):
    print 'Derivada em Xo igual a zero, escolha outro Xo'
    return None, None
  
  for i in range(limite):
    xa = xm

    xm = xm - (funcao(xm) / der)
    erro = funcoes.calcular_erro(xa, xm)
    
    print 'Iteracao ', (i + 1) , ' = ', xm
      
    if(erro < erro_fornecido):
      return xm, erro
      
    
    
  print 'Precisao nao obtida'
  print ''
  return xm, erro
Пример #2
0
def obter_alpha(funcao, derivada, derivada_seg, 
                erro_fornecido = 0.0, limite = 20, x_inicial = 0.0):
  """ Quasi newton utilizando Kinkeid"""
  
  xm = x_inicial
  erro = 100.0
  
  for i in range(limite):
    xa = xm
    fxm = funcao(xm)
    
    divisor = math.pow(derivada(xm), 2) - derivada_seg(xm) * fxm 
    
    if(divisor > 0.0):
      xm = xm -  (fxm / math.sqrt(divisor))
      erro = funcoes.calcular_erro(xa, xm)
    
      print 'Iteracao ', (i + 1) , ' = ', xm
        
      if(erro < erro_fornecido):
        return xm, erro
      
    else:
      print 'Ocorreu divisao por zero, ou raiz quadrada', 
      ' de um numero negativo escolha outro Xo'
      return xm, erro
      
  print 'Precisao nao obtida'
  print ''
  return xm, erro
Пример #3
0
def obter_alpha(funcao, erro_fornecido = 0.0, limite = 20, x_inicial = 0.0):
  """ Quasi newton utilizando Steffensen"""
  
  xm = x_inicial
  erro = 100.0
  
  for i in range(limite):
    xa = xm
    fxm = funcao(xm)
    divisor =  (funcao(xm + fxm)) - fxm 
    
    if(divisor == 0.0):
      print 'Divisor eh zero, iteracoes param por aqui'
      return xm, erro
      
    xm = xm -  (math.pow(fxm, 2) / divisor)
    erro = funcoes.calcular_erro(xa, xm)
    
    print 'Iteracao ', (i + 1) , ' = ', xm
        
    if(erro < erro_fornecido):
      return xm, erro
      
  print 'Precisao nao obtida'
  print ''
  return xm, erro
Пример #4
0
def obter_alpha(funcao, derivada, erro_fornecido = 0.0, limite = 20, x_inicial = 0.0):
  xm = x_inicial
  for i in range(limite):
    xa = xm
    der = derivada(xm)
    
    if(der != 0.0):
      xm = xm - (funcao(xm) / der)
      erro = funcoes.calcular_erro(xa, xm)
    
      print 'Iteracao ', (i + 1) , ' = ', xm
      
      if(erro < erro_fornecido):
        return xm, erro
      
    else:
      print u'Ocorreu uma derivada de valor zero, parando iteracoes'
      return xm, erro
    
  print 'Precisao nao obtida'
  print ''
  return xm, erro
Пример #5
0
def obter_alpha(intervalo, funcao, erro_passado = 0.0, limite = 20):

  a = intervalo[0]
  b = intervalo[1]
  fa = funcao(a)
  fb = funcao(b)
  erro = erro_passado * 10.0
  contador = 0
  xm = 0.0
  
  if( (fa * fb) < 0 ):
    
    while(contador < limite):
      contador += 1
      xm = (a + b) / 2.0 
      fm = funcao(xm)
      
      if(fm == 0):
        return xm, 0.0
      
      if( (fm * fa) < 0.0):
        b = xm
      else:
        a = xm
        
      erro = funcoes.calcular_erro(a, b)
 
      if(erro < erro_passado):
        return xm, erro
      
      print 'Iteracao ', contador, ' alpha = ', xm
      
    return xm, erro
      
  else:
    print 'Funcao nao eh continua' 
      
      
Пример #6
0
def obter_alpha(funcao, erro_fornecido = 0.0, limite = 20, x_um = 0.1, x_dois = 0.0):
  """ Quasi newton utilizando metodo da secante """
  
  x_novo = x_um
  x_antigo = x_dois
  
  for i in range(limite):
    f_novo = funcao(x_novo)
    
    x_tmp = x_novo
    x_novo = x_novo - ( (f_novo * (x_novo - x_antigo)) / (f_novo - funcao(x_antigo)) )
    x_antigo = x_tmp
    
    erro = funcoes.calcular_erro(x_antigo, x_novo)
    
    print 'Iteracao ', (i + 1) , ' = ', x_novo
      
    if(erro < erro_fornecido):
      return x_novo, erro

    
  print 'Precisao nao obtida'
  print ''
  return x_novo, erro