abs, sqrt, pow, max/min, round/floor/ceil, log, sin, random — die wichtigsten Funktionen der Standard-Mathematik. Mit Math-Lab und Java/Python parallel. Praktisch + klausurrelevant.
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.
Die wichtigsten Funktionen für die Klausur:
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.
Du brauchst:
Alles, was über +/-/*/% hinausgeht, kommt aus der Math-Bibliothek. Du musst es nicht selbst implementieren.
| Funktion | Was es tut | Beispiel |
|---|---|---|
| abs(x) | Betrag (Vorzeichen weg) | abs(-7) = 7 |
| sqrt(x) | Quadratwurzel | sqrt(144) = 12 |
| pow(x, y) | x hoch y | pow(2, 10) = 1024 |
| max(x, y) | Größere von beiden | max(3, 7) = 7 |
| min(x, y) | Kleinere von beiden | min(3, 7) = 3 |
| round(x) | Runden | round(3.5) = 4 |
| floor(x) | Abrunden | floor(3.9) = 3 |
| ceil(x) | Aufrunden | ceil(3.1) = 4 |
| log(x) | natürlicher Log (Basis e) | log(e) = 1 |
| log10(x) | Log Basis 10 | log10(1000) = 3 |
| sin/cos/tan(x) | Trigonometrie (Radiant!) | sin(0) = 0 |
| random() | Zufallszahl in [0, 1) | random() = z.B. 0,742 |
| PI | Kreiszahl π | 3,14159… |
| E | Eulersche Zahl e | 2,71828… |
// 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
// 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,powsind Built-ins — keinmath.Prefix nötig.sqrt,floor,ceil,log,sinsind im math-Modul.
Drei verschiedene Konzepte:
| Funktion | Bedeutung | Beispiel |
|---|---|---|
| round(x) | Zur nächsten ganzen Zahl | round(3.5) = 4 |
| floor(x) | Zur nächst-kleineren ganzen Zahl | floor(3.9) = 3 |
| ceil(x) | Zur nächst-größeren ganzen Zahl | ceil(3.1) = 4 |
| (int) x (Cast) | Truncation Richtung 0 | (int) 3.9 = 3 |
Math.round(-3.5) // -3 (Java rundet bei .5 auf Richtung +∞)
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)
Klausur-Falle:
floor(-3.5) = -4, aber(int) -3.5 = -3. Bei negativen Zahlen sind Floor und Truncation ungleich!
round(0.5) # 0 (NICHT 1!)
round(1.5) # 2
round(2.5) # 2 (NICHT 3!)
round(3.5) # 4
Python's
roundrundet bei .5 zur nächsten geraden Zahl ("Banker's Rounding"). Vermeidet Bias bei vielen Rundungen. Java macht das anders: rundet immer auf bei .5.
// 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).
// 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.
// 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)
Wichtig:
Math.sin,Math.cos,Math.tanerwarten Radiant, nicht Grad!
| Grad | Radiant |
|---|---|
| 0° | 0 |
| 90° | π/2 |
| 180° | π |
| 360° | 2π |
// 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)
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
Trick 1 — Vier Rundungs-Verhalten unterscheiden:
round zur nächsten Zahlfloor immer abrunden (Richtung minus unendlich)ceil immer aufrunden(int) Cast Truncation (Richtung 0)Trick 2 — sqrt von negativen Zahlen:
Math.sqrt(-1) = NaN (Not a Number)math.sqrt(-1) wirft ValueErrorVorher prüfen oder Math.abs benutzen.
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:
Trick 7 — log ohne Basis-Argument ist ln:
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
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.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur — und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Die Math-Bibliothek liefert Standard-Funktionen für Berechnungen die nicht in den Sprachkern eingebaut sind: Wurzel, Potenz, Trigonometrie, , Min/Max, Runden. In Java die statische -, in Python das -Modul.
if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?
for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?
Methoden, Parameter, Rückgabewerte. Code, der wiederverwendbar wird.
MathmathDie wichtigsten Funktionen für die Klausur:
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.
Du brauchst:
2^(10) → 1024Alles, was über +/-/*/% hinausgeht, kommt aus der Math-Bibliothek. Du musst es nicht selbst implementieren.
| Funktion | Was es tut | Beispiel |
|---|---|---|
| abs(x) | Betrag (Vorzeichen weg) | abs(-7) = 7 |
| sqrt(x) | Quadratwurzel | sqrt(144) = 12 |
| pow(x, y) | x hoch y | pow(2, 10) = 1024 |
| max(x, y) | Größere von beiden | max(3, 7) = 7 |
| min(x, y) | Kleinere von beiden | min(3, 7) = 3 |
| round(x) | Runden | round(3.5) = 4 |
| floor(x) | Abrunden | floor(3.9) = 3 |
| ceil(x) | Aufrunden | ceil(3.1) = 4 |
| log(x) | natürlicher Log (Basis e) | log(e) = 1 |
| log10(x) | Log Basis 10 | log10(1000) = 3 |
| sin/cos/tan(x) | Trigonometrie (Radiant!) | sin(0) = 0 |
| random() | Zufallszahl in [0, 1) | random() = z.B. 0,742 |
| PI | Kreiszahl π | 3,14159… |
| E | Eulersche Zahl e | 2,71828… |
// 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
// 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,powsind Built-ins — keinmath.Prefix nötig.sqrt,floor,ceil,log,sinsind im math-Modul.
Drei verschiedene Konzepte:
| Funktion | Bedeutung | Beispiel |
|---|---|---|
| round(x) | Zur nächsten ganzen Zahl | round(3.5) = 4 |
| floor(x) | Zur nächst-kleineren ganzen Zahl | floor(3.9) = 3 |
| ceil(x) | Zur nächst-größeren ganzen Zahl | ceil(3.1) = 4 |
| (int) x (Cast) | Truncation Richtung 0 | (int) 3.9 = 3 |
Math.round(-3.5) // -3 (Java rundet bei .5 auf Richtung +∞)
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)
Klausur-Falle:
floor(-3.5) = -4, aber(int) -3.5 = -3. Bei negativen Zahlen sind Floor und Truncation ungleich!
round(0.5) # 0 (NICHT 1!)
round(1.5) # 2
round(2.5) # 2 (NICHT 3!)
round(3.5) # 4
Python's
roundrundet bei .5 zur nächsten geraden Zahl ("Banker's Rounding"). Vermeidet Bias bei vielen Rundungen. Java macht das anders: rundet immer auf bei .5.
// 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).
// 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.
// 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)
Wichtig:
Math.sin,Math.cos,Math.tanerwarten Radiant, nicht Grad!
| Grad | Radiant |
|---|---|
| 0° | 0 |
| 90° | π/2 |
| 180° | π |
| 360° | 2π |
// 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)
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
Trick 1 — Vier Rundungs-Verhalten unterscheiden:
round zur nächsten Zahlfloor immer abrunden (Richtung minus unendlich)ceil immer aufrunden(int) Cast Truncation (Richtung 0)Trick 2 — sqrt von negativen Zahlen:
Math.sqrt(-1) = NaN (Not a Number)math.sqrt(-1) wirft ValueErrorVorher prüfen oder Math.abs benutzen.
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:
Trick 7 — log ohne Basis-Argument ist ln:
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
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.
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:
2^(10))Interaktive Visualisierung
Allgemeines Mathe-Lab mit Termumformungen und Rechenwegen.
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.
Klausurfragen mit Lösungen (8)
Antwort: 1024.0
Erklärung: Math.pow gibt IMMER double zurück — auch bei int-Argumenten. 2^10 = 1024.0. Für int: (int) Math.pow(2, 10).
Antwort: -4
Erklärung: floor rundet IMMER ab (Richtung minus unendlich). floor(-3.5) = -4. Achtung: (int) -3.5 wäre -3 (Truncation Richtung 0). Bei negativen Zahlen unterschiedlich.
Typ: Zahlen-Eingabe
Antwort: 2
Erklärung: Python's round nutzt Banker's Rounding: bei .5 zur nächsten GERADEN Zahl. round(0.5)=0, round(2.5)=2, round(3.5)=4. Java's Math.round dagegen rundet bei .5 immer auf: Math.round(2.5)=3.
Antwort: (int) (Math.random() * 6) + 1
Erklärung: Math.random() gibt 0.0 ≤ r < 1.0. Mal 6: 0 ≤ r < 6 (double). (int) Cast: 0, 1, 2, 3, 4, 5. Plus 1: 1-6. KLAMMERN sind wichtig — Antwort B macht (int)Math.random() = 0, dann *6+1 = immer 1.
Antwort: Radiant
Erklärung: Trigonometrische Funktionen erwarten IMMER Radiant — sowohl in Java als auch Python. Math.sin(90) ist sin(90 RADIANT), nicht sin(90°). Für Grad: Math.toRadians(grad) zuerst umrechnen.
Antwort: Sie sind Built-ins, kein 'import math' nötig
Erklärung: abs, max, min, round, pow sind Python BUILT-INS — direkt verfügbar ohne Import. Im math-Modul sind dagegen sqrt, floor, ceil, log, sin, cos, tan, pi, e. Häufige Verwirrung.
Antwort: Liefert NaN (Not a Number)
Erklärung: Math.sqrt von negativen Zahlen → NaN, kein Crash. Mit isNaN() prüfen oder vorher Math.abs benutzen. (Python wirft dagegen ValueError.) NaN ist ein spezieller Float-Wert: NaN != NaN ist sogar true!
Antwort: Math.log(x) / Math.log(2)
Erklärung: Logarithmus-Basis-Wechsel: log_b(x) = log(x) / log(b). Math.log(x) / Math.log(2) gibt log₂(x). Wichtig in Algorithmen-Klausur (Big-O hat oft log₂). Java hat auch Math.log10, aber kein direktes log2.
Funktionen, die sich selbst aufrufen. Mit Call-Stack-Visualisierung am Beispiel Fakultät.