Programmieren

Beispiel:  Die Funktion

successor :   

ordnet einer beliebigen natürlichen Zahl n die nächstgrößere natürliche Zahl n+1 zu:

successor(n)  =  n+1

Hierbei ist n das Argument und n+1 der zugehörige Funktions­wert.

Die Funktion

max :   

ordnet einem beliebigen Paar von natürlichen Zahlen (a, b) die größere dieser beiden Zahlen zu.

max(a, b)  =

a     falls a > b b     sonst

Hierbei ist das Paar (a, b) das Argument und das Maximum von a und b der zugehörige Funktions­wert.

Beispiel:  Die Definition der Funktion successor aus dem obigen Beispiel lässt sich in Java wie folgt realisieren:

int successor(int n)
{
    return n+1;
}

Der Name der Funktion ist successor, als Argument erhält die Funktion eine int-Zahl n, und mit der Anweisung return wird der berechnete Funktions­wert zurückgegeben. Der Typ des Rückgabewertes wird ganz am Anfang, vor dem Funktionsnamen angegeben, er ist hier ebenfalls int. Der Berechnungs­teil der Funktion wird zwischen geschweifte Klammern eingeschlossen.

Ein Aufruf der Funktion sieht beispielsweise wie folgt aus:

k=successor(17);

Als Argumentwert wird hier für n der Wert 17 eingesetzt; als Ergebnis des Funktions­aufrufs wird der Wert 18 zurückgegeben und der Variablen k zugewiesen.

Beispiel:  Die Definition der Funktion max lässt sich in Java wie folgt realisieren:

double max(double a, double b)
{
    if (a>b)
        return a;
    else
        return b;
}

Diese Funktions­definition orientiert sich genau an der mathematischen Definition der Maximum­funktion. Es wäre aber auch möglich gewesen, eine andere Berechnungs­vorschrift anzugeben, etwa die folgende.

double max(double a, double b)
{
    return (a+b+Math.abs(a-b))/2;
}

Wenn auch weniger offensichtlich, wird durch diese Berechnung ebenfalls das Maximum von a und b ermittelt. Hierbei ist Math.abs die in Java enthaltene Absolutbetrag­funktion.

Ein möglicher Aufruf der Funktion ist beispielsweise

x=max(z, 0);

Hierbei wird der Wert der Variablen z, sofern dieser positiv ist, und ansonsten der Wert 0 zurückgegeben und der Variablen x zugewiesen.

Beispiel:  Die Funktion exp2(n) ordnet einer nichtnegativen ganzen Zahl n als Funktions­wert die Zweierpotenz 2ⁿ zu. Mit folgender Funktion lässt sich die Berechnung durchführen:

int exp2(int n)
{
    int i=1;
    int f=1;
    while (i<=n)
    {
        f=f*2;
        i=i+1;
    }
    return f;
}

Hierbei sind i und f lokale Variablen, diese haben nur innerhalb der Funktions­definition Gültigkeit.

Beispiel:  In folgendem Programmstück wird eine globale String-Variable trennsymbol deklariert und mit dem Wert ";" belegt. Die nachfolgende Funktion verkette fügt zwei Zeichenreihen unter Einschluss des Trennsymbols zusammen.

String trennsymbol=";";

String verkette(String s, String t)
{
    return s+trennsymbol+t;
}

Ein Aufruf der Funktion, etwa mit s=verkette("alpha", "beta");, liefert als Funktions­wert das Ergebnis "alpha;beta"; dieser wird hier der Variablen s zugewiesen.

Beispiel:  Beim Aufruf der im Folgenden definierten Version der Funktion verkette, etwa mit verkette("alpha", "beta");, wird das Ergebnis "alpha+beta" zurückgegeben.

String trennsymbol=";";

String verkette(String s, String t)
{
    String trennsymbol="+";
    return s+trennsymbol+t;
}

Es werden zwei Variablen deklariert, eine globale Variable trennsymbol und eine lokale Variable mit demselben Namen. Die globale Variable trennsymbol erhält den Wert ";", die lokale Variable trennsymbol erhält den Wert "+". Innerhalb der Funktion hat die lokale Variable trennsymbol Vorrang. Immer, wenn innerhalb der Funktion auf die Variable trennsymbol zugegriffen wird, ist die lokale Variable trennsymbol gemeint, und diese hat den Wert "+".

Beispiel:  Die folgende Funktion berechnet die eulersche Zahl e. Um die Berechnung durchzuführen, wird kein Argument benötigt. Es wird jedoch ein Wert vom Typ double zurückgegeben, die Zahl e = 2,718.

Die Berechnung wird nach der Formel

e  =    _{n = 0, ...,}   1 / n!

durchgeführt. Da nicht unendlich viele Summanden berechnet werden können, wird nur solange gerechnet, wie die Summanden größer als 10^-14 sind, dann wird die Berechnung abgebrochen, da eine ausreichende Genauigkeit erreicht ist.

double e()
{
    int n=1;
    double s=1, f=1;
    while (s>1e-14)
    {
        s=s/n;
        f=f+s;
        n=n+1;
    }
    return f;
}

Die Funktion könnte etwa folgendermaßen aufgerufen werden:

double E = e();

Hier wird die Funktion e() aufgerufen und der Funktions­wert der Variablen E zugewiesen.

Beispiel:  Die folgende Funktion exp berechnet aⁿ für eine double-Zahl a und eine nichtnegative int-Zahl n.

double exp(double a, int n)
{
    int i;
    double p=1;
    for (i=0; i<n; i++)
        p=p*a;
    return p;
}

In dieser Funktions­definition sind a und n die formalen Parameter.

Beispiel:  Beim Aufruf der Funktion exp, etwa durch

double z=exp(2, 10);

erhält der formale Parameter a den Wert 2 und der formale Parmeter n den Wert 10. Der Funktions­aufruf ergibt also hier den Wert 2¹⁰  =  1024.

Beispiel:  In der Funktion zur Berechnung von e gibt eine Ausgabe­anweisung in jeder Iteration die erreichte Annäherung an den schließlich berechneten Funktions­wert aus.

double e()
{
    int n=1;
    double s=1, f=1;
    while (s>1e-14)
    {
        s=s/n;
        f=f+s;
        n=n+1;
        System.out.println(f);
    }
    return f;
}

Beispiel:  Die folgende Funktion weist der globalen Variablen trennsymbol einen neuen Wert zu.

String trennsymbol=";"

void neuesTrennsymbol(String t)
{
    trennsymbol=t;
}

Die Funktion gibt keinen Funktions­wert zurück. Als Seiteneffekt verändert sie jedoch den Wert der globalen Variablen trennsymbol. Nach Aufruf etwa von

neuesTrennsymbol("/");

hat die globale Variable trennsymbol den neuen Wert "/".

Beispiel:  Für n  ₀ lässt sich die n-te Potenz einer Zahl a induktiv wie folgt definieren:

a n  =

1     falls n = 0 a · a n-1     sonst

Diese Definition lässt sich unmittelbar in eine rekursive Funktion umsetzen:

double exp(double a, int n)
{
    if (n==0)
        return 1;
    else
        return a*exp(a, n-1);
}

Aufgabe 1:  Schreiben Sie eine Funktion square(x), die das Quadrat einer Zahl x berechnet.

Aufgabe 2:  Setzen Sie folgende mathematische Funktions­definition in eine Java-Funktion um.

abs(x)  =

-x     falls x < 0 x     sonst

Aufgabe 3:  Setzen Sie folgende induktive Definition der Fakultäts­funktion in eine rekursive Java-Funktion um.

n!  =

1     falls n = 0 n·(n-1)!     sonst