Math-Bibliothek.

Die Math-Bibliothek liefert Standard-Funktionen für Berechnungen, die nicht in den Sprachkern eingebaut sind: Wurzel, Potenz, Trigonometrie, Logarithmus, Min/Max, Runden. In Java die statische Math-Klasse, in Python das math-Modul. Du lernst hier, welche Funktionen in Java und Python wichtig sind, welche Rückgabetypen sie haben (z. B. Math.pow liefert immer double), wie Rundung bei positiven und negativen Zahlen unterschiedlich funktioniert, warum trigonometrische Funktionen Radiant erwarten (nicht Grad), wie Zufallsbereiche richtig konstruiert werden, warum 0.1 + 0.2 == 0.3 false ist (Floating-Point) und welche Java-vs-Python-Unterschiede in Klausuren oft geprüft werden.

Die wichtigsten Funktionen für die Klausur:

• Math.sqrt(x): Quadratwurzel
• Math.pow(base, exp): Potenz, z. B. Math.pow(2, 10) = 1024.0 (Rückgabe in Java immer double)
• Math.abs(x): Betrag, liefert normalerweise einen nicht-negativen Wert. Ausnahme: bei Integer.MIN_VALUE und Long.MIN_VALUE in Java bleibt der Wert negativ wegen Zwei-Komplement-Overflow (der positive Gegenwert passt nicht in den int/long-Wertebereich).
• Math.min(a, b) / Math.max(a, b): kleinerer / größerer Wert
• Math.round(x) / Math.floor(x) / Math.ceil(x): Runden, Abrunden, Aufrunden
• Math.PI / Math.E: die Konstanten Pi und e
• Math.random(): Zufallszahl im Bereich [0, 1), also 0 inklusive, 1 exklusiv

In Klausuren oft gefragt: schreibe Code der mit Math-Funktionen [Aufgabe] löst. Achte auf den Rückgabetyp: Math.sqrt und Math.pow geben double zurück, auch wenn das Ergebnis ganzzahlig wäre. Du musst dann zu int casten falls gefordert.

Das Problem

Du brauchst:

• die Quadratwurzel von 144 → 12
• den Betrag von -7 → 7
• 2^(10) → 1024
• den kleineren von zwei Werten
• die nächst-ganze Zahl zu 3,7
• eine Zufallszahl

Alles, was über +/-/*/% hinausgeht, kommt aus der Math-Bibliothek. Du musst es nicht selbst implementieren.

Die wichtigsten Funktionen

Java vs. Python

// Java, alle Funktionen sind statische Methoden in java.lang.Math
double a = Math.abs(-7);            // 7.0
double b = Math.sqrt(144);          // 12.0
double c = Math.pow(2, 10);         // 1024.0
int d = Math.max(3, 7);             // 7
double pi = Math.PI;                // 3.141592653589793

// Edge Case Math.abs:
int weird = Math.abs(Integer.MIN_VALUE);  // = Integer.MIN_VALUE (negativ!)
                                          // Overflow: |-2^31| passt nicht in int

// Math ist immer importiert (java.lang), kein import nötig

import math      # erst importieren
import random    # für random Funktionen separates Modul

a = abs(-7)              # 7         abs ist BUILT-IN, kein math. nötig!
b = math.sqrt(144)       # 12.0
c = 2 ** 10              # 1024      Operator ** statt pow()
d = max(3, 7)            # 7         max/min BUILT-IN
pi = math.pi             # 3.14159...
r = random.random()      # 0.742...  Zufallszahl

Klausur-Trick Python: abs, max, min, round, pow sind Built-ins, kein math. Prefix nötig. sqrt, floor, ceil, log, sin sind im math-Modul.

Runden: round, floor, ceil

Drei verschiedene Konzepte:

Bei negativen Zahlen wird's interessant

Math.round(-3.5)    // -3   bei .5: Java rundet Richtung +∞, also floor(x + 0.5)
Math.round(3.5)     //  4

Math.floor(-3.5)    // -4   (Richtung minus unendlich)
Math.floor(3.5)     //  3

Math.ceil(-3.5)     // -3   (Richtung plus unendlich)
Math.ceil(3.5)      //  4

(int) -3.5          // -3   (Truncation Richtung 0)

Java Math.round ist also nicht "rundet immer auf", bei negativen Halbwerten wie -3.5 gibt es -3, nicht -4. Konsistent ist die Formel floor(x + 0.5).

Klausur-Falle: floor(-3.5) = -4, aber (int) -3.5 = -3. Bei negativen Zahlen sind Floor und Truncation ungleich!

Banker's Rounding in Python

round(0.5)     # 0  (NICHT 1!)
round(1.5)     # 2
round(2.5)     # 2  (NICHT 3!)
round(3.5)     # 4

Python's round rundet bei .5 zur nächsten geraden Zahl ("Banker's Rounding"). Vermeidet Bias bei vielen Rundungen. Java Math.round verhält sich bei .5 wie floor(x + 0.5), also 3.5 → 4, aber -3.5 → -3.

pow vs ** vs *

// Java
double a = Math.pow(2, 10);      // 1024.0  (immer double Rückgabe)
int b = 2 * 2 * 2;               // schnell für kleine Potenzen

# Python
a = 2 ** 10                      # 1024  (Operator)
b = pow(2, 10)                   # 1024  (Built-in)
c = math.pow(2, 10)              # 1024.0  (immer float)
d = pow(2, 10, 7)                # 2  (modulares Pow: 2^10 mod 7)

Tipp Python: pow(x, y, mod) ist der modulare Pow, wichtig in Kryptografie (z.B. RSA).

Zufallszahlen

// Java, Math.random()
double r1 = Math.random();           // 0.0 ≤ r < 1.0

// Zahl zwischen 0 und 99 (inklusive)
int r2 = (int) (Math.random() * 100);

// Zahl zwischen 1 und 6 (Würfel)
int dice = (int) (Math.random() * 6) + 1;

import random

random.random()              # 0.0 ≤ r < 1.0
random.randint(1, 6)         # 1, 2, 3, 4, 5 oder 6 (BEIDE Grenzen inklusive)
random.uniform(1, 10)        # float zwischen 1.0 und 10.0
random.choice([1, 2, 3])     # eines davon zufällig

Reproduzierbar: random.seed(42) (Python) bzw. new Random(42) (Java) gibt jedes Mal die selbe Folge, wichtig für Tests.

Würfel-Pattern (Klausur-Klassiker)

// Java, Wurf 1-6
int dice = (int) (Math.random() * 6) + 1;
//                  └── 0 bis 5.999... ──┘ + 1 = 1 bis 6

# Python einfacher
dice = random.randint(1, 6)

Trigonometrie: Radiant vs. Grad

Wichtig: Math.sin, Math.cos, Math.tan erwarten Radiant, nicht Grad!

// Falsch: erwartet Grad? NEIN
double bad = Math.sin(90);          // 0.8939... (90 Radiant!)

// Richtig: Grad → Radiant
double right = Math.sin(Math.toRadians(90));  // 1.0

import math
math.sin(math.radians(90))   # 1.0 (Grad zuerst umrechnen!)
math.sin(math.pi / 2)        # 1.0 (direkt in Radiant)

Konstanten

double pi = Math.PI;        // 3.141592653589793
double e = Math.E;          // 2.718281828459045

import math
math.pi    # 3.141592653589793
math.e     # 2.718281828459045
math.inf   # Infinity
math.nan   # Not a Number

Klausur-Tricks

Trick 1, Vier Rundungs-Verhalten unterscheiden:

• round zur nächsten Zahl
• floor immer abrunden (Richtung minus unendlich)
• ceil immer aufrunden
• (int) Cast Truncation (Richtung 0)

Trick 2, sqrt von negativen Zahlen:

• Java: Math.sqrt(-1) = NaN (Not a Number)
• Python: math.sqrt(-1) wirft ValueError

Vorher prüfen; Math.abs nur verwenden, wenn fachlich wirklich die Wurzel aus dem Betrag gemeint ist (sonst verschleiert es einen Eingabefehler).

Trick 3, pow gibt double zurück (Java):

int a = Math.pow(2, 10);            // FEHLER (double → int braucht Cast)
int b = (int) Math.pow(2, 10);      // OK: 1024

Trick 4, Random-Bereich umrechnen:

Math.random() * (max - min) + min   // double in [min, max)
(int) (Math.random() * n)           // int in [0, n-1]
(int) (Math.random() * (max-min+1)) + min   // int in [min, max]

Trick 5, Trigonometrie immer in Radiant: Math.sin(90) ist NICHT sin(90°). Erst Math.toRadians.

Trick 6, Banker's Rounding nur in Python:

• Python: round(0.5) = 0, round(2.5) = 2 (zur geraden Zahl)
• Java: Math.round(0.5) = 1, Math.round(2.5) = 3 (immer aufrunden)

Trick 7, log ohne Basis-Argument ist ln:

• log(x) ist natürlicher Logarithmus (Basis e)
• log10(x) ist Logarithmus zur Basis 10
• Bel. Basis: log(x) / log(basis)

double log2_8 = Math.log(8) / Math.log(2);   // 3

Trick 8, Math.abs hat ein Problem:

Math.abs(Integer.MIN_VALUE)    // BUG: liefert Integer.MIN_VALUE!

Weil int-Overflow: -2147483648 hat keine positive Entsprechung im int-Bereich.

Trick 9, Math.PI und Math.E sind double: kein int möglich, da irrational.

Trick 10, Python f-string mit Math:

print(f"π = {math.pi:.4f}")    # π = 3.1416

Wo brauchst du Math?

• Geometrie: Pythagoras, Kreisflächen, Rotationen
• Statistik: Mittelwerte, Standardabweichung (sqrt drin)
• Spiele: Distanz-Berechnung, Würfel, Zufalls-Spawn
• Animation: sin/cos für sanfte Bewegungen, Schwingungen
• Finance: Zinses-Zins (pow), Logarithmen für Wachstumsraten
• Physik-Simulation: jedes Bewegungs-Modell
• Cryptography: pow mit Modulo, Random-Generierung

Faustregel: Wenn du in einer Klausur eine mathematische Operation siehst, prüfe ob die Math-Bibliothek die schon hat. Selbst implementieren ist meistens unnötig und fehleranfällig.

Math-Lab

13 Funktionen aus der Standard-Math-Bibliothek. Wähle eine und setze die Argumente, sieh sofort den Java-Aufruf und den Python-Aufruf parallel, plus das Ergebnis.

Probier folgendes:

• pow(2, 10) = 1024 (Klausur-Klassiker, 2^(10))
• sqrt(144) = 12; sqrt(-1): Java Math.sqrt(-1) = NaN, Python math.sqrt(-1) wirft ValueError
• floor(-1.5) = -2 (Richtung minus unendlich)
• ceil(3.1) = 4
• round(2.5), Java: 3, Python: 2 (Banker's Rounding!)
• random(), Klick "Neu generieren" für neue Werte
• sin(0) = 0, sin(π/2) = 1 (Argument in Radiant!)

Faustregel zum Mitnehmen: Math.pow gibt double zurück, sin/cos/tan erwarten Radiant, floor und Cast unterscheiden sich bei negativen Zahlen. Klausur-Klassiker auswendig kennen.

---

Code-Stepper: Klausur-Klassiker durchspielen

Drei interaktive Demos zu den häufigsten Klausur-Stolperern: Math.round Halfway-Regel (Java rundet bei .5 anders als Banker's Rounding), floor() vs (int)-Cast bei negativen Zahlen, und Floating-Point-Vergleich mit 0.1 + 0.2 == 0.3 (false, weil IEEE-754). Klicke auf Step oder Auto.

1. Math.round bei .5: Java nutzt floor(x + 0.5)

2. floor() vs (int)-Cast bei negativen Zahlen

Math.floor(x) rundet IMMER zur nächsten kleineren ganzen Zahl (Richtung -Unendlich). (int) x schneidet zur 0 hin ab (Truncation). Bei positiven Zahlen identisch, bei negativen unterschiedlich.

3. Floating-Point-Vergleich: warum 0.1 + 0.2 == 0.3 false ist

Double-Werte können viele Dezimalzahlen (wie 0.1) nicht exakt darstellen. Das führt zu winzigen Rundungsfehlern, die bei ==-Vergleich sichtbar werden. In Klausuren oft als Bug-Frage: warum schlägt diese if-Bedingung fehl?