5.2 Die Funktionen der Math-Klasse 

Die Klasse java.lang.Math ist eine typische Utility-Klasse, die nur statische Funktionen (beziehungsweise Attribute) hat. Es lassen sich keine Exemplare von Math erzeugen.

5.2.1 Attribute 

Die Math-Klasse besitzt zwei statische Attribute:

class java.lang.  Math  

static final double E Die Eulersche Zahl e = 2,718...

static final double PI Die Kreiszahl pi = 3,14159...

5.2.2 Winkelfunktionen (trigonometrische Funktionen und Arcus–Funktionen) 

Die Math-Klasse stellt einige Winkelfunktionen und ihre Umkehrungen zur Verfügung. Im Gegensatz zur Schulmathematik werden die Winkel für sin(), cos(), tan() im Bogenmaß (2*p entspricht einem Vollkreis) und nicht im Gradmaß (360 Grad entspricht einem Vollkreis) übergeben.

static double sin( double x ) Liefert den Sinus von x.

static double cos( double x ) Liefert den Kosinus von x.

static double tan( double x ) Liefert den Tangens von x.

Die Arcus-Funktionen sind die Umkehrfunktionen zu den trigonometrischen Funktionen. Das Argument ist kein Winkel, sondern zum Beispiel bei asin() der Sinuswert zwischen –1 und 1. Das Ergebnis ist dann ein Winkel im Bogenmaß, etwa zwischen -p/2 und p/2:

static double asin( double x ) Liefert den Arcus-Sinus von x, wobei -p/2 <= x <= p/2.

static double acos( double x ) Liefert den Arcus-Kosinus von x, wobei 0 <= x <= p.

static double atan( double x ) Liefert den Arcus-Tangens von x, wobei -p/2 <= x <= p/2.

static atan2( double x, double y ) Liefert von der Konvertierung von Rechteckkoordinaten in Polarkoordinaten den Winkel theta, also eine Komponente des Polarkoordinaten-Tupels. Die Vorzeichen der Parameter x und y werden berücksichtigt, und der freie Schenkel des Winkels befindet sich im richtigen Quadranten.

Hyperbolicus-Funktionen bietet Java seit Version 5 über sinh(), tanh() und cosh().

Zur Umwandlung eines Winkels von Gradmaß in Bogenmaß und umgekehrt existieren zwei Funktionen:

static double toRadians( double angdeg ) Grad- in Bogenmaß umwandeln

static double toDegrees( double angrad ) Winkel von Bogen- in Gradmaß umwandeln

5.2.3 Runden von Werten 

Bei der Rundung von Werten können in Java diese Methoden verwendet werden: ceil(), floor(), round() und rint().

ceil()

Die Methode dient zum Aufrunden und liefert die nächst höhere Ganzzahl, wenn die Zahl nicht schon eine ganze Zahl ist.

floor()

Die Funktion rundet ab. Die Methode ähnelt der ceil()-Methode. Im Gegensatz zu dieser wird hier aber die nächst niedrigere Ganzzahl zurückgegeben. Die Arbeitsweise lässt sich am besten an einem Beispiel ablesen:

System.out.println( Math.floor(–99.1) );    // –100.0
System.out.println( Math.floor(–99) );      //  –99.0
System.out.println( Math.floor(-.01) );     //   –1.0
System.out.println( Math.floor(0.1) );      //    0.0
System.out.println( Math.floor(99) );       //   99

Ganze Zahlen werden nicht verändert.

round() und rint()

Die Funktion round() rundet auf die nächste Ganzzahl vom Typ long (kaufmännische Rundung). Ganze Zahlen werden nicht aufgerundet. rint() ist vergleichbar mit round(), nur liefert es ein double (wie floor() und ceil() auch). rint() ist im Gegensatz zu round() gerecht, was bedeutet, dass bei 0.5 auf die benachbarte gerade Zahl gerundet wird, das heißt, es wird in 50  % der Fälle auf- und in 50  % der Fälle abgerundet. Wir können round() zur Typumwandlung einsetzen, als Gegenstück zu (long) d, und d ist ein double, welches immer abrundet. Ein Beispiel zu round():

System.out.println( Math.round(1.01) );   //  1
System.out.println( Math.round(–2.1) );   // –2
System.out.println( Math.round(30) );     // 30

public static int round( float a ) {
   return (int) floor(a + 0.5f);
 }

Listing 5.2   Round2Scales.java

class Round2Scales
{
  public static double roundScale2( double d )
  {
    return Math.rint( d * 100 ) / 100.;
  }

  public static void main( String args[] )
  {
    System.out.println( roundScale2(+1.341 ) );    //  1.34
    System.out.println( roundScale2(–1.341 ) );    // –1.34
    System.out.println( roundScale2(+1.345 ) );    //  1.34
    System.out.println( roundScale2(–1.345 ) );    // –1.34
    System.out.println( roundScale2(+1.347 ) );    //  1.35
    System.out.println( roundScale2(–1.347 ) );    // –1.35
  }
}

Arbeiten wir anstatt mit rint() mit round(), wird die Zahl 1.345 nicht auf 1.34, sondern auf 1.35 gerundet.

5.2.4 Wurzel und Exponentialfunktionen 

static double sqrt( double x ) Liefert die Quadratwurzel von x. sqrt steht für square root.

static double exp( double x ) Liefert den Exponentialwert von x zur Basis e (der Eulerschen Zahl e = 2.71828…)1  , also ex  .

static double expm1( double x ) Liefert den Exponentialwert von x zur Basis e minus 1, also ex  – 1. Berechungen nahe Null können mit expm1(x) + 1 präziser ausgedrückt werden als mit exp(x).

static double pow( double x, double y ) Liefert den Wert der Potenz xy  . Für ganzzahige Werte gibt es keine eigene Funktion.

static double cbrt( double a ) Berechnet a3  .

5.2.5 Der Logarithmus 

Der Logarithmus ist die Umkehrfunktion der Exponentialfunktion. Die Exponentialfunktion und der Logarithmus hängen durch folgende Beziehung zusammen: Ist y = a^x  dann ist x = loga(y). Der Logarithmus Math.log() ist der natürliche Logarithmus zur Basis e. In der Mathematik wird dieser mit »ln« angegeben (logarithmus naturalis). Logarithmen mit der Basis 10 heißen dekadische oder Brigg'sche Logarithmen und werden mit »lg« abgekürzt; der Logarithmus zur Basis 2 (binärer Logarithmus, dualer Logarithmus) mit »lb«. In Java gibt es seit Version 5 die statische Funktion log10() für den lg, nicht aber für ln, der weiterhin nachgebildet werden muss. Allgemein gilt folgende Umrechnung: logb(x) = loga(x) / loga(b).

public static double lg( double x )
{
  return Math.log( x ) / Math.log( 2 );
}

static double log( double a ) Berechnet den Logarithmus zur Basis e.

static double log10( double x, double y ) Liefert den Logarithmus zur Basis 10.

static double log1p( double x ) Liefert log(x) + 1.

5.2.6 Rest der ganzzahligen Division 

Neben dem Modulo-Operator, der den Rest der ganzzahligen Division berechnet, gibt es auch eine Funktion in der Math-Klasse.

static double IEEEremainder( double Dividend, double Divisor ) Liefert den Rest der Division von Dividend und Divisor (Modulo-Operator), so wie es der IEEE-754-Standard vorschreibt.

Listing 5.3   IEEEremainder.java

public class IEEEremainder
{
  public static void main( String args[] )
  {
    double a = 44.0;
    double b = 2.2;

    System.out.println(   a % b   );
    System.out.println(   Math.IEEEremainder( a, b )   );
  }
}

Der Unterschied ist deutlich.

2.1999999999999966
-3.552713678800501E-15      // –0.0000000000000035527136788005...

Das erste Ergebnis ist mit der mathematischen Ungenauigkeit fast 2.2, aber etwas kleiner, so dass der Algorithmus nicht noch einmal 2.2 abziehen konnte. Die Methode IEEEremainder() liefert ein Ergebnis nahe Null, was korrekt ist, denn 44.0 lässt sich ohne Rest durch 2.2 teilen.

5.2.7 Absolutwerte und Maximum, Minimum 

Die abs()-Funktionen liefern den Betrag des Arguments (mathematische Betragsfunktion: y = |x|). Sollte ein negativer Wert als Argument übergeben werden, so wird dieser in einen positiven Wert umgewandelt.

static int abs( int x )

static long abs( long x )

static float abs( float x )

static double abs( double x )

Die max()-Funktionen liefern den größeren der übergebenen Werte. Die min()-Funktionen liefern den kleineren von zwei Werten als Rückgabewert.

static int max( int x, int y )

static long max( long x, long y )

static float max( float x, float y )

static double max( double x, double y )

static int min( int x, int y )

static long min( long x, long y )

static float min( float x, float y )

static double min( double x, double y )

5.2.8 Zufallszahlen 

Zufallszahlen zwischen 0 und 1 liefert die Methode Math.random(). Möchten wir Werte in einem anderen Wertebereich, so ist es eine einfache Lösung, die Zufallszahlen von Math.random() durch Multiplikation auf den gewünschten Wertebereich auszudehnen und per Addition geeignet zu verschieben. Eine Zufallszahl zwischen x (inklusiv) und y (exklusiv) liefert Math.random() * (y – x) + x. Um ganzzahlige Zufallszahlen zwischen u und o (einschließlich) zu erhalten, berechnen wir u + Math.floor(Math.random() * (o-u+1)). Eine weitere einfache Lösung ist es, den Modulo-Operator einzusetzen und so den Wertebereich zu beschneiden. Noch besser ist allerdings der direkte Einsatz der Klasse Random und der Funktion nextInt(n), die im übernächsten Kapitel vorgestellt wird.

¹   Die irrationale Zahl e ist nach dem schweizerischen Mathematiker Leonhard Euler (1707–1783) benannt.