Exponential-Funktion

Berechnung mit Reihen-Entwicklung

Logarithmus und Exponential sind wichtige Funktionen, u.a. weil sich damit viele aufwändige Rechnungen um eine Stufe vereinfachen. Wenn diese Funktionen nicht zur Verfügung stehen, dann kann man sie mit Reihen-Entwicklungen selbst programmieren. Unabhängig davon sind die Beispiele für die Ausbildung gut brauchbar, weil man die Ergebnisse jederzeit durch Vergleich mit den Standard-Funktionen kontrollieren kann.
Algorithmen Ausgewählte IT-Rezepte, Reihen-Entwicklung (Iteration)
Exp Die Exponential-Funktion und ihre Anwendung in der Informatik
Exponential Reihen-Entwicklung der Exp-Funktion mit Live-Beispiel
Euler'sche Zahl Reihen-Entwicklung des Sonderfalls exp(1) mit Live-Beispiel
Hilfs-Funktionen Potenz-Funktion, Fakultät - nur mit den 4 Grundrechnungs-Arten
Verwandte Themen Logarithmus-Funktion

Exponential

Euler'sche Zahl  e

Diese konstante Zahl spielt in der Mathematik eine ähnlich wichtige Rolle wie die → Kreiszahl Pi. Sie ist u.a. definiert als jene Zahl, deren → natürlicher Logarithmus =1 ist:
ln(e) = 1
Die Euler'sche Zahl e ist die Basis des → natürlichen Logarithmus:
e = 2.718281828459045235360287471352662497757247
Man kann sie mit Hilfe der fast immer verfügbaren Exponential-Funktion berechnen:
e = exp(1)

♣ Unterscheiden sie die (einzelne) Konstante e von der konstanten Folge der Euler-Zahlen !
Euler-Zahl in Programmen:
• Javascript Konstante:
Math.E=2.718281828459045

• PHP Konstante:
M_E=2.7182818284590452354

In jedem anderen Fall berechnet man e entweder mit Hilfe einer ↓ Reihen-Entwicklung oder mit   e=exp(1)

Exponential

(Abkürzung immer EXP) Diese Funktion ist die Umkehrung des natürlichen Logarithmus:
exp(ln(x)) = x
Oder anders: Wenn y=ln(x) dann exp(y)=x 
Eigentlich braucht man dafür keine eigene Funktion, da man jedes Exponential als Potenzierung der ↑ Euler'schen Zahl e anschreiben kann:
exp(y) = ey = 2.71828y = e^y = = 2.71828^y
Vielen Programmiersprachen bieten eine Potenz-Funktion an Stelle eines Operators, z.B.
exp(y) = pow(e,y) = pow(2.71828,y)
Allerdings ist auch die Potenz-Funktion oder ein Potenzierungs-Operator nicht immer verfügbar ↓ Hilfs-Funktion my_pow()
Exponential in Programmen:
• Kalkulation (LibreOffice, OpenOffice, MS-Excel, ...):    =EXP(A1) 
• Basic (LibreOffice-Basic, Visual Basic, VBA): Exp(x) 
• C / C++: Bibliothek #include<math.h> 
Funktion double exp(double x);
C++ bietet zusätzlich überladene Varianten für die Typen float, long double, complex, ...
Preprocessor-Makro (als 'system-spezifisch' angegeben):
M_E = 2.7182818284590452354
• Javascript: Funktion  Math.exp(x); 
• Perl Funktion: exp(x); 
• PHP Funktionen: exp(x); 
 expm(x)=exp(x)-1; ... Berechnet exp(x)-1 auch für sehr kleine x rasch und genau.

Anwendung

Eine klassische Anwendung des Logarithmus ist die Vereinfachung schwieriger Rechnungen. In der Informatik spielen diese Methoden auf Prozessor-Ebene eine wichtige Rolle:
Dort gibt es keine mathematischen Funktionen, in sehr einfachen Prozessoren auch keine Multiplikation oder Division.

Multiplikation x*y
Die Multiplikation wird auf eine Addition der Logarithmen zurückgeführt. Man berechnet die Logarithmen der Argumente x und y, addiert diese und potenziert die Summe:
x * y = exp(ln(x) + ln(y))
Beispiel:
123 * 456 = exp(4.812 + 6.122) = exp(10.935) = 56088
Das erscheint heute als Umweg, war jedoch lange Zeit hindurch die Grundlage vieler praktischer und zeitsparender Methoden und Geräte, z.B. des Rechenschiebers. Wenn einmal für längere Zeit der Strom ausfallen sollte, wird man sich daran erinnern...
Division x/y
Funktioniert ähnlich wie die Multiplikation. Sie wird auf eine Subtraktion der Logarithmen zurückgeführt:
x / y = exp(ln(x) - ln(y))
Beispiel:
987 / 654 = exp(6.895 - 6.483) = exp(0.412) = 1.509

Potenzierung x^y
Die Potenzierung wird auf eine Multiplikation zurückgeführt:
x ^ y = exp(ln(x) * y)
Beispiel:
2 ^ 10 = exp(0.693 * 10) exp(6.931) = 1024

Wurzeln x^(1/x)
Das Wurzelziehen wird auf eine Division zurückgeführt:
x ^ (1/y) = exp(ln(x) / y)
Beispiel: 3. Wurzel aus 100
100^(1/3) = exp(4.605 / 3) = exp(1.535) = 4.642
LibreOffice - Kosten- und lizenzfreie Office-Programme (inkl. Kalkulation) für alle gängigen Betriebssysteme und Sprachen, kompatibel mit MS-Excel.
Java - Programmiersprache von Sun / Oracle, kostenfrei für alle gängigen Systeme. Home
● Javascript - Programmiersprache, in jedem gängigen Browser-Programm integriert.
Perl - Programmiersprache, in jeder Linux_Distribution kostenfrei enthalten, für Windows kostenfrei bei ActiveState
PHP - Programmiersprache, kosten- und lizenzfrei für alle gängigen Systeme. Home: php.net
● VisualBasic - Programmierrsprache von Microsoft oder als OpenSource-Version, in jedes gängige Kalkulations-Programm (LibreOffice, OpenOffice, MS-Excel) integriert. 		Wikipedia: Logarithmus, Exponential, Euler'sche Zahl, Taylor-Reihe, Reihe, Potenzreihe,
Formelsammlung: Reihenentwicklungen

Exponential-Funktion als Potenzreihe
Die Exponential-Funktion kann man nach dieser Formel berechnen:
Quelle: Wikipedia
Die Berechnung der komplizierten Funktion wird in viele Elemente einer Reihe zerlegt, deren Elemente man einfach berechnen kann. Die ersten Elemente dieser Reihe:
exp(x) = x^0/0! + x^1/1! + x^2/2! + ...
Die → Fakultät-Funktion n! wächst sehr rasch. Schon mit dem 170. Element der Reihe erreicht man die → darstellbare Grenze:
170! = 7.26E+306
Kontrolle: Der → natürliche Logarithmus des Exponentials muss wieder den Wert des Arguments x ergeben:
x = ln(exp(x)) = ln(ex)

Die Berechnung der Euler'schen Zahl e=ln(1) kann zwar ebenfalls mit dieser Funktion erfolgen, wird jedoch gesondert im ↓ nächsten Kapitel vorgestellt.

Kalkulations-Programm

Der Algorithmus ist so einfach, dass ihn selbst wenig geübte AnwenderInnen von Kalkulations-Programmen erstellen können.
Voraussetzung: Man kann eine gegebene Formel in Anweisungen umsetzen - Für eine Programmiersprache oder wie hier für ein Kalkulations-Programm.

♣ Das Beispiel rechts zeigt nur die ersten 3 Elemente der Reihe. Füllen sie die Zellen A7:C7 bis zum Element 14 nach unten aus: Der Algorithmus erreicht dann in jedem Fall seinen Grenzwert = das Exponential der Zahl x aus Zelle B1  		Programmierung in einem Kalkulations-Programm:
   ABC
1Zahl x2 
2 exp(x)=EXP(B1)
3 my_exp(x)=my_exp(B1)
4   
5NrElementSumme
60=$B$1^A6/FAKULTÄT(A6)=B6
7=A6+1=$B$1^A7/FAKULTÄT(A7)=B7+C6
8=A7+1=$B$1^A8/FAKULTÄT(A8)=B8+C7
...
16=A15+1=$B$1^A16/FAKULTÄT(A16)=B16+C15

• Die Werte in den Zellen C6...C16 sind die Ergebnisse der Methode nach dem 'Nullten', 1. ... 14. Element.
• Mit jeder zusätzlichen Zeile verbessert sich das Ergebnis.
• Wenn die Grenze der Genauigkeit (des Kalkulations-Programms, nicht des Algorithmus) erreicht ist, dann ändert sich der berechnete Wert nicht mehr.

Programmierung mit Basic (LibreOffice-Basic, Visual Basic VBA)


Argumente:
Die Funktion my_exp() akzeptiert 2 Argumente:
x ... Zahl, deren Exponential zu berechnen ist
nmax ... Maximale Anzahl der zu berechnenden Elemente. Wenn nmax nicht angegeben wird, dann rechnet das Programm bis zur maximalen Genauigkeit ≈ auf 15 Dezimalstellen.

Anfangswerte:
doloop ... Schalter, steuert entweder die weitere Berechnung oder den Abbruch
sum ... Ergebnis der Methode.
n ... Zähler für die Elemente (Schritte)

Schleife
In jedem Schleifen-Durchlauf wird 1 Element der Reihe berechnet.

Abbruch:
Das jeweils vorige Ergebnis sumv wird mit dem aktuellen Ergebnis sum verglichen: Wenn keine Änderung erfolgt ist, oder wenn der Zähler den Maximalwert erreicht hat, dann wird doloop=False gesetzt und damit die Schleife abgebrochen.

Hilfs-Funktionen:
Eine Reihen-Entwicklung ist dann sinnvoll, wenn man dafür keine anderen Funktionen benötigt. Daher werden an Stelle des Potenz-Operators (b^n) und der Fakultät-Funktion die ↓ Hilfs-Funktionen my_pow() und my_fakt() verwendet.
Reihen-Entwicklung der Exponential-Funktion als Basic-Funktion:
Function my_exp( _
x As Double, _
Optional nmax As Integer = -1) _
As Double
Dim doloop As Boolean
Dim n As Integer
Dim element, sum, sumv As Double
If nmax < 0 Then nmax = 170
' If IsMissing(nmax) Then nmax = 170
doloop = True
sum = 0
n = 0
While (doloop)
sumv = sum
' element = x ^ n / my_fakt(n)
element = my_pow(x, n) / my_fakt(n)
sum = sum + element
n = n + 1
If (sum=sumv Or n>=nmax) Then doloop = False
Wend
my_exp = sum
End Function

Programmierung mit Javascript

Die Funktion ist im Quelltext dieser Webseite enthalten und rechnet Live, wenn sie den Button klicken:


Elemente


Live-Ergebnis:
Argument   x = ?
my_exp(x)    = ?
exp_theor(x) = ?
Genauigkeit ≈ ? Dezimalstellen
Anzahl der Iterationen = ?
Rechenzeit = ? µs
Reihen-Entwicklung der Exponential-Funktion als Javascript-(JS)-Funktion.
function my_exp(x,nmax) {
if(nmax<0) {nmax=170;}
var doloop=true;
var sum=0; var sumv=0;
var element=0;
var n=0;
while(doloop) {
sumv = sum;
element = my_pow(x, n) / my_fakt(n);
sum += element;
n++;
if(sum==sumv || n>=nmax) {doloop=false;}
}
return sum;
}

Programmierung mit C/C++

Die Funktion ist in C/C++ ebenso wie in allen anderen modernen Programmiersprachen sehr ähnlich aufgebaut.

Die Deklaration beschreibt die Funktion sowie die Typen ihrer Argumente und ihres Ergebnisses vor der Verwendung.

Die beiden Funktionen my_pow() und my_fakt() werden im Kapitel ↓ Hilfs-Funktionen vorgestellt.

Die Funktion verwendet lediglich die 4 Grundrechnungs-Arten und liefert normalerweise das gleiche Ergebnis wie die Standard-Funktion:
#include <math.h>
double x,y1,y2;
x = 1.23456;
y1 = exp(x);
y2 = my_exp(x);
Reihen-Entwicklung der Exponential-Funktion als C/C++ Funktion:
Deklaration:
double my_exp(double);
Funktion:
double my_exp(double x) {
int doloop,n,nmax;
double sum,sumv;
doloop=1;
n=0;
nmax=170;
sum=0.0;
while(doloop) {
sumv=sum;
sum+=my_pow(x,n) / my_fakt(n);
n++;
if(sum==sumv || n>=nmax) {doloop=0;}
}
return sum;
}
Anwendung in C/C++:
y = my_exp(x);
Die Bibliothek <math.h> bietet die beiden Funktionen frexp() und ldexp() zum Rechnen mit der Basis 2. Das Beispiel zeigt die Zerlegung und Zusammensetzung einer Gleitkomma-Zahl (x):
x = m * 2^be
ähnlich wie die 'Wissenschaftliche' Formatierung, jedoch mit der Basis 2 an Stelle von 10

Funktion frexp() zerlegt das 1. Argument (hier x) in eine → Mantisse m und einen ganzzahligen → Exponenten be, welcher im 2. Argument als Pointer übergeben wird.

Funktion ldexp() setzt eine Gleitkomma-Zahl (hier y) aus der binären Mantisse m und dem binären Exponenten be zusammen.

Gleitkomma-Zahlen werden intern in Form von binären Mantissen und Exponenten verwaltet. 		Binäre Mantissen & Exponenten in C/C++:
#include <stdio.h>
#include <math.h>

int main() {
int be;
double m,x,y;
x = 3.14159265358979;
m = frexp(x,&be);
printf("%f = %f * 2^%d\n",x,m,be);
y = ldexp(m,be);
printf("%f * 2^%d = %f\n",m,be,y);
return 0;
}

Euler'sche Zahl als Potenzfunktion


Quelle: Wikipedia
 Die Euler'sche Zahl
e = ln(1) = 2,71828182845905
hat in vielen Bereichen der Mathematik eine große Bedeutung. Sie ist in modernen Programmiersprachen als Konstante verfügbar, z.B.
• Javascript: Math.E
• PHP: M_E
Die Basic-Funktion my_euler() (rechts) zeigt, wie man die Formel in ein Programm umsetzen kann.

• Die Funktion braucht kein Argument und berechnet in diesem Falle e bis zur Grenze der Genauigkeit ≈ auf ca. 15 Dezimalstellen genau.

• Man kann mit dem optionalen Argument nmax den Abbruch der Berechnung vor-verlegen. In diesem Fall werden nur so viele Elemente der Reihe berechnet wie angegeben. Das verkürzt die Rechenzeit auf Kosten der Genauigkeit.
Experimentieren sie mit der Live-Berechnung im Kapitel zur ↑ Berechnung des Logarithmus (oben).

• Zur Berechnung wird an Stelle der Fakultät-Funktion die ↓ Hilfs-Funktion my_fakt() verwendet. 		Reihen-Entwicklung der Euler'schen Zahl als Basic-Funktion (vereinfacht):
Function my_euler( _
Optional nmax As Integer = -1) _
As Double
Dim doloop As Boolean
Dim n As Integer
Dim sum, sumv, element As Double
If nmax < 0 Then nmax = 1000
' If IsMissing(nmax) Then nmax = 1000
sum = 0
n = 0
doloop = True
While (doloop)
sumv = sum
element = 1 / my_fakt(n)
sum = sum + element
n = n + 1
If (sum=sumv Or n>=nmax) Then doloop = False
Wend
my_euler = sum
End Function
Die → Javascript-Funktion my_euler() (rechts) ist im Quelltext dieser Webseite enthalten und rechnet Live:

♣ Die Live-Berechnung der Funktion my_euler() ist in die ↑ Berechnung der Logarithmus-Funktion (Kapitel oben) integriert: Geben sie x=1 ein und klicken sie den Button 'Logarithmus'.

♣ Tipp: Begrenzen sie die Anzahl der berechneten Elemente und beobachten sie die Wirkung auf Genauigkeit und Rechenzeit. 		Reihen-Entwicklung der Euler'schen Zahl als Javascript-(JS)-Funktion.
function my_euler(nmax) {
if(nmax<0) {nmax=1000;}
var sum = 0; var sumv=0;
var n = 0; var element=0;
var doloop = true;
while(doloop) {
sumv = sum;
element = 1 / my_fakt(n);
sum += element;
n++;
if(sum==sumv || n>=nmax) {doloop=false;}
}
return sum;
}
Das → C/C++ Programm verwendet die Funktion my_euler() zur Berechnung der Euler'schen Zahl.

Die maximale Genauigkeit von 17 Dezimal-Stellen wird bereits nach 19 Iterations-Schritten erreicht.

Die → Funktion printf() ist so formuliert, dass mehr Stellen angezeigt werden, als die maximale → Genauigkeit bietet. Nicht berechenbare Ziffern werden als nachfolgende Nullen angezeigt. 		Reihen-Entwicklung der Euler'schen Zahl als C/C++-Programm.
#include <stdio.h>

double my_euler(void);
double my_fakt(int);

int main() {
double e;
e = my_euler();
printf("e=%22.20f\n",e);
return 0;
}

double my_euler(void) {
int doloop,n;
double sum,vsum;
n = 0;
sum = 0.0;
doloop = 1;
while(doloop) {
vsum = sum;
sum += 1 / my_fakt(n);
n++;
if(vsum==sum || n>1000) {doloop=0;}
}
return sum;
}

double my_fakt(int n) {
if (n==0 || n==1) {return 1.0;}
else{return my_fakt(n-1) * (double)n;}
}
Das rechts gezeigte → Perl Programm verwendet die Funktion my_euler() zur Berechnung der Euler'schen Zahl. Die erste Zeile (Shebang) bezeichnet den Pfad zum Perl Interpreter Programm (hier typisch für Linux).

Eine interessante Alternative ist die Berechnung der Euler'schen Zahl mit Ziffern-Strings. Das → Perl-Modul Math::Big bietet die Möglichkeit, Rechnungen mit beliebiger Genauigkeit auszuführen, z.B. auch die Berechnung der Euler'schen Zahl:
#!/usr/bin/perl

use Math::Big qw/euler/;
my($d,$e);
$d = 100; # Digits
$e = euler(1,$d);
print "e = $e\n";
Das Programm berechnet die ersten 100 Stellen. Wer etwas länger wartet, kann auch die ersten $d=1000 oder $d=10000 Stellen berechnen... 		Reihen-Entwicklung der Euler'schen Zahl als Perl-Programm.
#!/usr/bin/perl

my($e);
$e = my_euler();
print "e=$e\n";

sub my_euler {
my($doloop,$n,$vsum,$sum);
$n=0; $sum=0; $doloop=1;
while($doloop) {
$vsum = $sum;
$sum += 1.0 / my_fakt($n);
$n++;
if($vsum==$sum || $n>100) {$doloop=0;}
}
return $sum;
}

sub my_fakt {
my($n)=@_;
my($f,$i);
$f = 1;
for($i=2;$i<=$n;$i++) {$f*=$i;}
return $f;
}
Die → PHP-Funktion my_euler() berechnet die Euler'sche Zahl nach dem gleichen Algorithmus.

Die beliebig genaue Berechnung mit Ziffern-Strings ist nicht möglich, da die beiden → PHP-Module BC-Math und GMP derzeit nur mit ganzen Zahlen rechnen. 		Reihen-Entwicklung der Euler'schen Zahl als PHP-Funktion.
function my_euler() {
$n=0; $sum=0;
$doloop = true;
while($doloop) {
$vsum = $sum;
$sum += 1 / my_fakt($n);
$n++;
if($vsum==$sum || $n>1000) {$doloop=0;}
}
return $sum;
}
function my_fakt($n) {
if($n==0 || $n==1) {return 1;}
else{return my_fakt($n-1)*$n;}
}

Hilfs-Funktionen
Die meisten Programmiersprachen bieten mindestens einige grundlegende mathematische Funktionen. Sie sind entweder in der Grundausrüstung enthalten oder werden als Modul (Bibliothek...) bei Bedarf eingebunden. Wenn jedoch die benötigten Funktionen fehlen, oder - wie bei einfachen MikroProzessoren - überhaupt keine mathematischen Funktionen verfügbar sind, dann muss man eigene Funktionen programmieren, welche ausschließlich die 4 Grundrechnungs-Arten (Addition, Subtraktion, Multiplikation, Division) verwenden.

Potenz-Funktion

Diese Funktion ist je nach Programmiersprache als Funktion (meist unter Namen wie pow() ) oder Operator (oft als ^ oder ** ) verfügbar.

♣ Bei Verwendung großer Zahlenwerte (= langer Iterations-Reihen) kann man an die Grenze des Variablen-Typs kommen, das ist für den Typ Double ca 1.8E+308

Das Beispiel zeigt, wie man die Potenz-Funktion selbst programmieren kann.

Anwendung:
x_hoch_y = my_pow(x,y)
 Basic Hilfs-Funktion my_pow()
Private Function my_pow( _
ByVal number As Double, _
ByVal exponent As Integer) _
As Double
Dim i As Integer
Dim p As Double
p = 1
For i = 1 To exponent
p = p * number
Next
my_pow = p
End Function
Javascript Hilfs-Funktion my_pow()
function my_pow(b,ie) {
var p=1;
for(var i=1;i<=ie;i++) {p*=b;}
return p;
}
Anwendung in Javascript:
x_hoch_y = my_pow(x,y);
 C/C++ Hilfs-Funktion my_pow()
Deklaration:
double my_pow(double,int);
Funktion:
double my_pow(double b,int ie) {
int i;
double p=1;
for(i=0;i<ie;i++) {p*=b;}
return p;
}
Anwendung in C/C++:
x_hoch_y = my_pow(x,y);

Fakultät-Funktion

Das Beispiel zeigt, wie man die → Fakultät-Funktion (engl. factorial) ausschließlich unter Verwendung der 4 Grundrechnungs-Arten programmieren kann:
x_fakt = 1 * 2 * 3 * ... * x

♣ Die Fakultät-Funktion wächst besonders rasch: Sie ist nur verwendbar bis maximal
170! = 7.26E+306
 Basic Hilfs-Funktion my_fakt()
Private Function my_fakt( _
ByVal number As Integer) _
As Double
Dim i As Integer
Dim f As Double
f = 1
For i = 1 To number
f = f * i
Next
my_fakt = f
End Function

Anwendung:
x_fakultaet = my_fakt(x)
Javascript Hilfs-Funktion my_fakt()
function my_fakt(n) {
var f=1;
for(var i=1;i<=n;i++) {f*=i;}
return f;
}
Anwendung in Javascript:
n_fakultaet = my_fakt(n);
 C / C++ Hilfs-Funktion my_fakt()
Deklaration:
double my_fakt(int);
Funktion:
double my_fakt(int n) {
int i;
double f=1;
for(i=1;i<=n;i++) {f*=(double)i;}
return f;
}
Anwendung in C / C++:
n_fakultaet = my_fakt(n);

Quadratwurzel-Funktion

Diese Funktion wird von den meisten Programmiersprachen als sqr() oder sqrt() angeboten.
Die Berechnung mit Hilfe einer Reihen-Entwicklung wird auf der Seite → Quadratwurzel demonstriert.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Algorithmen   >   Reihen-Entwicklung   >   Exponential