serie - suma en python

Programa de Python para calcular series armónicas

Question

¿Alguien sabe cómo escribir un programa en Python que calculará la adición de la serie armónica? es decir, 1 + 1/2 +1/3 +1/4 ...

Answer 1

¿Deberes?

Es una serie divergente, por lo que es imposible sumar todos los términos.

No conozco Python, pero sé cómo escribirlo en Java.

public class Harmonic
{
    private static final int DEFAULT_NUM_TERMS = 10;

    public static void main(String[] args)
    {
        int numTerms = ((args.length > 0) ? Integer.parseInt(args[0]) : DEFAULT_NUM_TERMS);

        System.out.println("sum of " + numTerms + " terms=" + sum(numTerms));
     }

     public static double sum(int numTerms)
     {
         double sum = 0.0;

         if (numTerms > 0)
         {
             for (int k = 1; k <= numTerms; ++k)
             {
                 sum += 1.0/k;
             }
         }

         return sum;
     }
 }

Answer 2

Esto debería hacer el truco.

def calc_harmonic(n):
    return sum(1.0/d for d in range(2,n+1))

Answer 3

La serie armónica diverge, es decir, su suma es infinito.

editar: a menos que desee sumas parciales, pero no fue muy claro al respecto.

Answer 4

Qué tal esto:

partialsum = 0
for i in xrange(1,1000000):
    partialsum += 1.0 / i
print partialsum

donde 1000000 es el límite superior.

Answer 5

Solo una nota al pie en las otras respuestas que usaron el punto flotante; comenzar con el divisor más grande e iterar hacia abajo (hacia los recíprocos con el valor más grande) pospondrá el error acumulado de redondeo tanto como sea posible.

Answer 6

Se puede calcular una versión de la función H rápida, precisa, uniforme y de valores complejos utilizando la función digamma, tal como se explica aquí . La constante Euler-Mascheroni (gamma) y la función digamma están disponibles en las bibliotecas numpy y scipy, respectivamente.

from numpy import euler_gamma
from scipy.special import digamma

def digamma_H(s):
    """ If s is complex the result becomes complex. """
    return digamma(s + 1) + euler_gamma

from fractions import Fraction

def Kiv_H(n):
    return sum(Fraction(1, d) for d in xrange(1, n + 1))

def J_F_Sebastian_H(n):
    return euler_gamma + log(n) + 0.5/n - 1./(12*n**2) + 1./(120*n**4)

Aquí hay una comparación de los tres métodos de velocidad y precisión (con Kiv_H para referencia):

Kiv_H(x) J_F_Sebastian_H(x) digamma_H(x) x seconds bits seconds bits seconds bits 1 5.06e-05 exact 2.47e-06 8.8 1.16e-05 exact 10 4.45e-04 exact 3.25e-06 29.5 1.17e-05 52.6 100 7.64e-03 exact 3.65e-06 50.4 1.17e-05 exact 1000 7.62e-01 exact 5.92e-06 52.9 1.19e-05 exact

Answer 7

Usando el simple bucle for

def harmonicNumber(n):
x=0
for i in range (0,n):
    x=x+ 1/(i+1)
return x

Answer 8

Agrego otra solución, esta vez usando recursión, para encontrar el n-ésimo número armónico.

Detalles generales de implementación

Prototipo de función: harmonic_recursive(n)

Parámetros de función: n - el n-ésimo número armónico

Caso base: si n es igual a 1 devuelve 1.

Paso recurrente: si no es el caso base, llame a harmonic_recursive para el término n-1 y añada ese resultado con 1/n . De esta forma, agregamos cada vez el término i-ésimo de la serie Harmonic con la suma de todos los términos anteriores hasta ese punto.

Pseudocódigo

(Esta solución también se puede implementar fácilmente en otros idiomas).

harmonic_recursive(n):
    if n == 1:
        return 1
    else:
        return 1/n + harmonic_recursive(n-1)

Código de Python

def harmonic_recursive(n):
    if n == 1:
        return 1
    else:
        return 1.0/n + harmonic_recursive(n-1)

Answer 9

La respuesta de @Kiv es correcta pero es lenta para n grande si no necesita una precisión infinita. Es mejor usar una fórmula asintótica en este caso:

#!/usr/bin/env python
from math import log

def H(n):
    """Returns an approximate value of n-th harmonic number.

       http://en.wikipedia.org/wiki/Harmonic_number
    """
    # Euler-Mascheroni constant
    gamma = 0.57721566490153286060651209008240243104215933593992
    return gamma + log(n) + 0.5/n - 1./(12*n**2) + 1./(120*n**4)

La respuesta de @ Kiv para Python 2.6:

from fractions import Fraction

harmonic_number = lambda n: sum(Fraction(1, d) for d in xrange(1, n+1))

Ejemplo:

>>> N = 100
>>> h_exact = harmonic_number(N)
>>> h = H(N)
>>> rel_err = (abs(h - h_exact) / h_exact)
>>> print n, "%r" % h, "%.2g" % rel_err
100 5.1873775176396242 6.8e-16

En N = 100 error relativo es menor que 1e-15 .

Answer 10

La solución de @recursive es correcta para una aproximación de coma flotante. Si lo prefiere, puede obtener la respuesta exacta en Python 3.0 usando el módulo de fracciones:

>>> from fractions import Fraction
>>> def calc_harmonic(n):
...   return sum(Fraction(1, d) for d in range(1, n + 1))
...
>>> calc_harmonic(20) # sum of the first 20 terms
Fraction(55835135, 15519504)

Tenga en cuenta que la cantidad de dígitos crece rápidamente, por lo que requerirá mucha memoria para n grande. También podrías usar un generador para mirar la serie de sumas parciales si quisieras ser realmente elegante.