Commits

Anonymous committed a83c0cd

add e ignore

Comments (0)

Files changed (4)

+glob:*.png
+glob:*.zip

harmonica_alternada.py

+# -*- coding: utf-8 -*-
+"""
+Created on Wed Aug 31 22:32:51 2011
+
+@author: Claudio Berrondo*
+Mestradao em Modelagem Matematica da Informacao
+para a disciplina Modelagem Matematica para Aplicacoes
+do professor Antonio C. S. Branco
+
+*obrigado a Debora, pelas ideias iniciais dos loops while, ao Diego pela ajuda nas 
+exatas condicoes de parada para esses loops, ao Andre pela dica da implementacao 
+em Lisp do SICP, ao Gerson, Ariel, Daniel, Pablo e Antoanne.
+"""
+
+"""
+questao 2: A serie geometrica desta questao e uma serie absolutamente convergente. 
+Neste caso, qualquer arranjo dos termos convergira sempre para o mesmo valor para
+o qual a serie original converge. Sendo assim, nao e possivel uma implementacao 
+semelhante.
+"""
+
+from fractions import Fraction
+from matplotlib.pyplot import plot
+
+def serie_harmonica_alternada(inicial, sinal):
+    denominador = inicial
+    while denominador < float('inf'):
+        yield Fraction(sinal*1, denominador)
+        denominador += 2
+        
+def eh_positivo(numero):
+    return numero >= 0
+         
+def eh_negativo(numero):
+    return numero < 0 
+    
+class Converge:
+    def __init__(self, limite, epsilon=0.1):
+        self.limite = limite
+        self.epsilon = epsilon
+        self.positivas = serie_harmonica_alternada(1, 1)
+        self.negativas = serie_harmonica_alternada(2, -1)
+        
+        self.positiva_convergiu = False
+        self.negativa_convergiu = False
+        
+        self.soma_parcial = 0
+        self.soma_acumulada = []
+
+        self.sinal_corrente = 1
+        self.sequencia_alternada_de_parcelas = [0]
+        
+        # convencionou-se que a primeira parcela sera sempre 1/1:
+        self.registrar(self.positivas.next())
+        
+    def manteve_sinal(self, parcela):
+        return eh_positivo(parcela * self.sinal_corrente)
+        
+    @property
+    def total_de_parcelas(self):
+        return len(self.soma_acumulada)
+        
+    def registrar(self, parcela):
+        self.soma_parcial += parcela
+        self.soma_acumulada.append(self.soma_parcial)
+        
+        if self.manteve_sinal(parcela):
+            self.sequencia_alternada_de_parcelas[-1] += 1
+        else:
+            self.sequencia_alternada_de_parcelas.append(1)
+            self.sinal_corrente = parcela
+            
+    def convergiu(self, parcela):
+        if self.parcelas_convergiram:   # ambas parcelas ok!
+            return True
+
+        self.registrar(parcela)
+        
+        if self.soma_convergiu:
+            if eh_positivo(parcela):
+                self.positiva_convergiu = True
+                return True
+                
+            elif eh_negativo(parcela):
+                self.negativa_convergiu = True
+                return True
+
+    @property            
+    def distancia_para_o_limite(self):
+        return abs(self.soma_parcial - self.limite)
+        
+    @property
+    def o_limite_foi_atingido(self):
+        return self.distancia_para_o_limite == 0
+        
+    @property
+    def soma_convergiu(self):
+        return self.distancia_para_o_limite < self.epsilon
+        
+    @property
+    def parcelas_convergiram(self):
+        return self.positiva_convergiu and self.negativa_convergiu
+        
+    @property
+    def soma_e_parcelas_convergirem(self):
+        if self.o_limite_foi_atingido:   # soma == limite
+            return True
+        return self.soma_convergiu and self.parcelas_convergiram
+            
+            
+    def converge(self):
+        while not self.soma_e_parcelas_convergirem:
+            
+            while self.soma_parcial < self.limite:
+                if self.convergiu(self.positivas.next()):
+                    break
+                
+            while self.soma_parcial > self.limite:
+                if self.convergiu(self.negativas.next()):
+                    break
+         
+         
+    def __str__(self):
+        return str((float(self.soma_parcial), self.total_de_parcelas, 
+                self.sequencia_alternada_de_parcelas))
+        
+    def plotar(self):
+        plot([self.limite-self.epsilon] * self.total_de_parcelas)
+        plot([self.limite] * self.total_de_parcelas)
+        plot([self.limite+self.epsilon] * self.total_de_parcelas)
+        plot(self.soma_acumulada)
+        plot(self.soma_acumulada, 'o')
+            
+
+def converge(L, e=0.1):
+    c = Converge(L, e)
+    c.converge()
+    return c

harmonica_alternada_1.py

+# -*- coding: utf-8 -*-
+"""
+Created on Wed Aug 31 22:32:51 2011
+
+@author: Claudio
+"""
+
+from fractions import Fraction
+from matplotlib.pyplot import plot
+
+
+
+def serie_harmonica_alternada(inicial, sinal):
+    denominador = inicial
+    while denominador < float('inf'):
+        yield Fraction(sinal*1, denominador)
+        denominador += 2
+        
+def converge(limite, epsilon=0.1):
+    positivos = serie_harmonica_alternada(1, 1)
+    negativos = serie_harmonica_alternada(2, -1)
+    positiva_convergiu = False
+    negativa_convergiu = False
+    
+    sequencia_alternada_de_parcelas = [1]
+    
+    p1 = positivos.next()
+    soma_parcial = p1
+    soma_ate_aqui = [p1]
+    
+    sinal_corrente = 1
+    def manteve_sinal(parcela):
+        return (parcela * sinal_corrente) > 0
+        
+    def plotar():  
+        plot([limite-epsilon] * len(soma_ate_aqui))
+        plot([limite] * len(soma_ate_aqui))
+        plot([limite+epsilon] * len(soma_ate_aqui))
+        plot(soma_ate_aqui)
+        plot(soma_ate_aqui, 'o')
+        
+    while not ( soma_parcial == limite or
+                abs(soma_parcial - limite) < epsilon
+                    and positiva_convergiu
+                    and negativa_convergiu
+                ):
+                
+        while soma_parcial < limite:
+            p = positivos.next()
+            soma_parcial += p
+            soma_ate_aqui.append(soma_parcial)
+
+            if manteve_sinal(p):
+                sequencia_alternada_de_parcelas[-1] += 1
+            else:
+                sequencia_alternada_de_parcelas.append(1)
+                sinal_corrente = p
+                
+            if abs(soma_parcial - limite) < epsilon:
+                positiva_convergiu = True
+                break
+        
+        while soma_parcial > limite:
+            if positiva_convergiu and negativa_convergiu:
+                break
+
+            p = negativos.next()
+            soma_parcial += p
+            soma_ate_aqui.append(soma_parcial)
+            
+            if manteve_sinal(p):
+                sequencia_alternada_de_parcelas[-1] += 1
+            else:
+                sequencia_alternada_de_parcelas.append(1)
+                sinal_corrente = p
+                
+            if abs(soma_parcial - limite) < epsilon:
+                negativa_convergiu = True
+                break
+
+    plotar()
+    return sequencia_alternada_de_parcelas
+     

harmonica_alternada_2.py

+# -*- coding: utf-8 -*-
+"""
+Created on Wed Aug 31 22:32:51 2011
+
+@author: Claudio *8486
+"""
+
+from fractions import Fraction
+from matplotlib.pyplot import plot
+
+def serie_harmonica_alternada(inicial, sinal):
+    denominador = inicial
+    while denominador < float('inf'):
+        yield Fraction(sinal*1, denominador)
+        denominador += 2
+        
+def esta_proximo(o_alvo, dada_a_tolerancia, da_soma_parcial):
+    if o_alvo == da_soma_parcial: return True
+    return abs(da_soma_parcial - o_alvo) < dada_a_tolerancia
+  
+parciais = []
+def aproxima(o_alvo, da_soma_parcial, com_parcelas):
+    parciais.append(da_soma_parcial)
+    da_soma_parcial += com_parcelas.next()
+    if (abs(da_soma_parcial) - o_alvo) > 0: return da_soma_parcial
+    return aproxima(o_alvo, da_soma_parcial, com_parcelas)
+    
+def converge(o_alvo, dada_a_tolerancia=0.1, da_soma_parcial=0):
+    com_positivos = serie_harmonica_alternada(1, 1)
+    com_negativos = serie_harmonica_alternada(2, -1)
+    
+    da_soma_parcial += aproxima(o_alvo, da_soma_parcial, com_positivos)
+    if esta_proximo(o_alvo, dada_a_tolerancia, da_soma_parcial):
+        return da_soma_parcial
+        
+    da_soma_parcial += aproxima(o_alvo, da_soma_parcial, com_negativos)
+    if esta_proximo(o_alvo, dada_a_tolerancia, da_soma_parcial):
+        return da_soma_parcial
+        
+    return converge(o_alvo, dada_a_tolerancia, da_soma_parcial)
+
+def plotar(o_alvo, parciais=parciais):  
+#    plot([limite-epsilon] * len(parciais))
+    plot([o_alvo] * len(parciais))
+#    plot([limite+epsilon] * len(parciais))
+    plot(parciais)
+    plot(parciais, 'o')