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...

Konstanten aus JavaScript

JavaScript definiert noch einige weitere Konstanten, die in Java zurzeit nicht zur Verfügung stehen und die Programmierer selbst definieren müssen. Das sind LN2 (natürlicher Logarithmus von 2 mit dem ungefähren Wert 0,693), LN10 (natürlicher Logarithmus von 10, ca. 2,302), LOG2E (Logarithmus von 2, ca. 1,442), LOG10E (Logarithmus von 10, ca. 0,434), SQRT1_2 (Quadratwurzel aus 0,5, ca. 0,707) und SQRT2 (Quadratwurzel aus 2, ca. 1,414).

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. Der Parameter 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 nicht an. In C(++) bietet die Math-Bibliothek 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 Der Logarithmus

Der Logarithmus ist die Umkehrfunktion der Exponentialfunktion. Die Exponentialfunktion und der Logarithmus hängen durch folgende Beziehung zusammen: Ist y = ax dann ist x = loga(y). Der Logarithmus Math.log() ist der natürliche Logarithmus zur Basis e (der Eulerschen Zahl e = 2.71828...)¹. 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 keine statische Methode für lg oder ln, sodass diese Basen nachgebildet werden müssen. Dazu gilt folgende Umrechnung: logb(x) = loga(x) / loga(b).

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

5.2.5 Exponentialfunktionen

static double exp( double x ) Liefert den Exponentialwert von x zur Basis e, also ex.

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

static double pow( double x, double y ) Liefert den Wert der Potenz xy.

5.2.6 Division

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, sodass 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 Parameters (mathematische Betragsfunktion: y = |x|). Sollte ein negativer Wert als Parameter übergeben werden, so wird dieser in einen positiven Wert umgewandelt. Dabei ist das Ergebnis von demselben Typ wie der Parameter.

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. Das Ergebnis ist von demselben Typ wie die Parameter.

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. 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.