Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger

 << zurück
Java ist auch eine Insel von Christian Ullenboom
Programmieren für die Java 2-Plattform in der Version 5
Java ist auch eine Insel

Java ist auch eine Insel
5., akt. und erw. Auflage
1454 S., mit CD, 49,90 Euro
Galileo Computing
ISBN 3-89842-747-1
gp Kapitel 5 Mathematisches
  gp 5.1 Arithmetik in Java
    gp 5.1.1 Java-Sondertypen im Beispiel
  gp 5.2 Die Funktionen der Math-Klasse
    gp 5.2.1 Attribute
    gp 5.2.2 Winkelfunktionen – trigonometrische Funktionen und Arcus–Funktionen
    gp 5.2.3 Runden von Werten
    gp 5.2.4 Wurzel und Exponentialfunktionen
    gp 5.2.5 Der Logarithmus
    gp 5.2.6 Rest der ganzzahligen Division
    gp 5.2.7 Absolutwerte und Maximum/Minimum
    gp 5.2.8 Zufallszahlen
    gp 5.2.9 Der nächste Bitte
  gp 5.3 Mathe bitte strikt
    gp 5.3.1 Strikt Fließkomma mit strictfp
    gp 5.3.2 Die Klassen Math und StrictMath
  gp 5.4 Die Random-Klasse
  gp 5.5 Große Zahlen
    gp 5.5.1 Die Klasse BigInteger
    gp 5.5.2 Funktionen von BigInteger
    gp 5.5.3 Ganz lange Fakultäten
    gp 5.5.4 Große Fließkommazahlen mit BigDecimal
    gp 5.5.5 Komfortabel die Rechengenauigkeit setzen mit MathContext
  gp 5.6 Rechnen mit Einheiten: Java Units Specification
  gp 5.7 Weitere Klassen für mathematische Probleme


Galileo Computing

5.2 Die Funktionen der Math-Klassdowntop

Die Klasse java.lang.Math ist eine typische Utility-Klasse, die nur statische Funktionen (beziehungsweise Attribute) hat. Mit einem privaten Konstruktor lassen sich eben keine Exemplare von Math erzeugen …


Galileo Computing

5.2.1 Attribute  downtop

Die Math-Klasse besitzt zwei statische Attribute:


class java.lang.  Math  

gp  static final double E Die Eulersche Zahl e = 2,718...
gp  static final double PI Die Kreiszahl pi = 3,14159...

Galileo Computing

5.2.2 Winkelfunktionen – trigonometrische Funktionen und Arcus–Funktionen  downtop

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.

gp  static double sin( double x ) Liefert den Sinus von x.
gp  static double cos( double x ) Liefert den Kosinus von x.
gp  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:

gp  static double asin( double x ) Liefert den Arcus-Sinus von x, wobei -p/2 <= x <= p/2.
gp  static double acos( double x ) Liefert den Arcus-Kosinus von x, wobei 0 <= x <= p.
gp  static double atan( double x ) Liefert den Arcus-Tangens von x, wobei -p/2 <= x <= p/2.
gp  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:

gp  static double toRadians( double angdeg ) Gradmaß in Bogenmaß umwandeln
gp  static double toDegrees( double angrad ) Winkel von Bogenmaß in Gradmaß umwandeln

Galileo Computing

5.2.3 Runden von Wertedowntop

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.


Beispiel   ceil(1.1) ergibt den Wert 2. ceil(–1.1) liefert den Wert –1.

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

Beispiel   Die round()-Funktion ist in Java ausprogrammiert. Auf dem Parameter wird 0.5 addiert und der floor()-Methode übergeben.
public static long round( double a ) {
   return (int) floor( a + 0.5f );
 }


Beispiel   Die rint()-Funktion lässt sich auch einsetzen, wenn Zahlen auf zwei Nachkommastellen gerundet werden sollen. Ist d vom Typ double, so ergibt der Ausdruck Math.rint(d*100.0)/100.0 die gerundete Zahl.

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


Galileo Computing

5.2.4 Wurzel und Exponentialfunktionen  downtop

gp  static double sqrt( double x ) Liefert die Quadratwurzel von x. sqrt steht für square root.
gp  static double exp( double x ) Liefert den Exponentialwert von x zur Basis e (der Eulerschen Zahl e = 2.71828…), also ex.
gp  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).
gp  static double pow( double x, double y ) Liefert den Wert der Potenz xy. Für ganzzahlige Werte gibt es keine eigene Funktion.
gp  static double cbrt( double a ) Berechnet die dritte Wurzel aus a.

Galileo Computing

5.2.5 Der Logarithmus  downtop

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


Beispiel   Eine eigene statische Funktion soll den Logarithmus zur Basis 2 berechnen.
public static double lb( double x )
{
  return Math.log( x ) / Math.log( 2.0 );
}
Da Math.log(2) konstant ist, sollte dieser Wert aus Performanz-Gründen in einer Konstanten gehalten werden.

gp  static double log( double a ) Berechnet den Logarithmus zur Basis e.
gp  static double log10( double x, double y ) Liefert den Logarithmus zur Basis 10.
gp  static double log1p( double x ) Liefert log(x) + 1.

Galileo Computing

5.2.6 Rest der ganzzahligen Division  downtop

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

gp  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.2   IEEEremainder.java

public class IEEEremainder
{
  public static void main( String[] args )
  {
    double a = 44.0;
    double b = 2.2;
    System.out.println( a / b );                      // 20.0
    System.out.println(   a % b   );                      // 2.1999999999999966
    System.out.println(   Math.IEEEremainder( ab )   ); // –3.552713678800501E-15
  }
}

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 (–0,0000000000000035527136788005), was besser ist, denn 44,0 lässt sich ohne Rest durch 2,2 teilen, also wäre der Rest eigentlich 0.

Eine Methode, die mitunter bessere Ergebnisse liefert (in unserem Fall wirklich 0,0) ist die folgende:

public static double remainder( double a, double b )
{
  return Math.signum(a) * 
(Math.abs(a)Math.abs(b) * Math.floor(Math.abs(a)/Math.abs(b)));
}

Galileo Computing

5.2.7 Absolutwerte und Maximum/Minimudowntop

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.

gp  static int abs( int x )
gp  static long abs( long x )
gp  static float abs( float x )
gp  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.

gp  static int max( int x, int y )
gp  static long max( long x, long y )
gp  static float max( float x, float y )
gp  static double max( double x, double y )
gp  static int min( int x, int y )
gp  static long min( long x, long y )
gp  static float min( float x, float y )
gp  static double min( double x, double y )

Galileo Computing

5.2.8 Zufallszahlen  downtop

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.


Galileo Computing

5.2.9 Der nächste Bitte  toptop

Nicht in der Klasse Math, sondern bei ChoiceFormat, finden sich die statischen finalen Methoden previousDouble(double d) und nextDouble(double d), die die vorangehende bzw. nächste mögliche Fließkommazahl als double zurückgeben.

double d = 12.34;
System.out.println( ChoiceFormat.previousDouble(d) );     // 12.339999999999998
System.out.println( ChoiceFormat.nextDouble(d) );         // 12.340000000000002



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

 << zurück




Copyright © Galileo Press GmbH 2005
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de