Neperin luvun (e) likiarvon laskeminen

Mureakuha

Sisällysluettelo 1 Teoria 2 C++ 3 Python 4 R

Teoria

Neperin luku saadaan päättymättömän sarjan avulla seuraavasti:

Mutta käytännössä tietokone ei tunne termiä ääretön, joten seuraava määritelmä on realistisempi:

C++

Seuraavassa C++-ohjelma, joka laskee Neperin luvun likiarvon:

#include <iostream>
using namespace std;
 
class Neper
{
public:
	Neper(int n = 10);
	double hae_e();
 
private:
	int kertoma( int n );
 
	double e;
};
 
Neper::Neper(int n)
{
	e = 0;
	for( int j = 0; j < n; j++ )
		e += 1 / double( kertoma(j) );
} 
 
double Neper::hae_e()
{
	return e;
}
 
int Neper::kertoma( int n )
{
	// n! = n * (n - 1) * ... * 2 * 1
        // Suurin int-tyypillä esitettävä kertoma on 12! (~5 x 10^8)
        assert (n <= 12);
	
	if( n == 0 )	// joukolla, jossa on nolla alkiota, on vain yksi järjestys
		return 1;
 
	int kertoma = 1;
 
	for( int i = 1; i < (n+1); i++ )
		kertoma *= i;
		
	return kertoma;
}
 
int main( int argc, char *argv[] )
{
	Neper neper;
	
	cout << "Neperin luvun (e) likiarvo on " 
		<<  neper.hae_e() << endl;
		
	return 0;
}

Luonnollisesti oikeasti käytettynä kertomaa ei kannata laskea aina uudestaan koska seuraavassa iteraatiossa kertoma on edellinen kerrottuna seuraavalla luvulla.

Python

Vastaava Pythonilla:

def kertomat(n):
    """Palauta kertomat luvuista 0..n"""
    k, kert = 0, 1
    while k <= n:
        yield kert
        k += 1
        kert *= k
 
def neper(n=20):
    return sum(1/float(x) for x in kertomat(n))
 
print neper()  # 2.71828182846 
 

R

Vastaava R:llä:

# Funktio neper R(/S)-kielellä (ks. http://www.r-project.org/).
# Funktion argumentiksi annetaan summien lukumäärä.
# Käyttö: neper(14)
 
neper <- function(k){
	summa=0
	for (i in 0:k)
	{
		summa=summa+(1/factorial(i))
	}
	return(summa)
}
 
# > neper(9)
# [1] 2.718282