Logarithmen & Exponential.

Der Logarithmus ist die Umkehrung der Exponentialfunktion: log_b(x) = y bedeutet b^y = x. Wenn du wissen willst "welche Potenz von b ergibt x", ist das genau ein Logarithmus. Der reelle Logarithmus ist nur definiert für b > 0, b ≠ 1, x > 0.

Die Bausteine die du in der Klausur können musst:

• Definition: für b > 0, b ≠ 1, x > 0 gilt log_b(x) = y ⇔ b^y = x
• Spezielle Basen: ln(x) = log_e(x) (natürlich), log(x) meist log₁₀ oder log₂ je nach Kontext
• Rechenregeln: log(a · b) = log(a) + log(b), log(a^n) = n · log(a), log(a/b) = log(a) - log(b)
• Basiswechsel: log_b(x) = log(x) / log(b)
• Anwendung: Wachstum / Zerfall (Bevölkerung, Halbwertszeit), Algorithmuslaufzeiten, pH-Wert

In Klausuren wirst du oft gefragt: löse die Gleichung 2^x = 100 (Antwort: x = log₂(100) ≈ 6,64) oder vereinfache log-Ausdrücke mit den Rechenregeln. Bei Wachstumsaufgaben: bekanntes Schema mit y = a · b^t und nach t auflösen via Logarithmus.

Das Problem

Du hast 1.000 €. Bei 5 % Zinsen pro Jahr, wann wird daraus 2.000 €?

Jahr 0:  1000 €
Jahr 1:  1050 € = 1000 · 1,05
Jahr 2:  1102,50 € = 1000 · 1,05²
...
Jahr t:  1000 · 1,05^t = 2000   ← gesucht: t

Die Gleichung 1,05^t = 2 lässt sich NICHT mit einfacher Algebra lösen, du brauchst den Logarithmus:

t = (ln 2)/(ln 1,05) ≈ 14,2 Jahre

Logarithmus = Umkehrung der Exponentialfunktion. Wenn die Variable im Exponenten steht, brauchst du Log zum Auflösen.

Exponentialfunktion

f(x) = a^x mit Basis a > 0, a ≠ 1

Wichtigste Eigenschaften:

a^0 = 1                  (jede Zahl hoch 0 = 1)
a^1 = a
a^x · a^y = a^(x+y)      Potenzgesetz
a^x / a^y = a^(x-y)
(a^x)^y = a^(x·y)

Klassisch klausurrelevante Basen: 2 (Informatik / Bits), e ≈ 2,72 (Naturwissenschaften / Wachstum), 10 (Alltag / Wissenschaft)

Logarithmus

log_a x = y bedeutet a^y = x.

In Worten: "Welche Potenz von a ergibt x?", bei ganzzahligen Werten anschaulich auch: "Wie oft muss ich a mit sich selbst multiplizieren?"

log_2(8) = 3       weil 2^3 = 8
log_2(1024) = 10   weil 2^10 = 1024
log_10(1000) = 3   weil 10^3 = 1000
log_e(e) = 1       weil e^1 = e

Drei wichtige Spezial-Logarithmen

In Java/Python ist Math.log(x) der natürliche Logarithmus (Basis e). Für log10: Math.log10(x). Für log2: Math.log(x) / Math.log(2).

Logarithmus-Regeln

Genau spiegelbildlich zu Potenzgesetzen:

Klausur-Trick: Diese Regeln machen aus Multiplikation Addition. Vor Computern war das die Methode für große Zahlen (Rechenschieber).

Basis-Wechsel

Manchmal hast du log zur einen Basis, brauchst aber eine andere.

log_b x = (log x)/(log b) (neue Basis beliebig)

log_2(100) = ?
       = log_10(100) / log_10(2)
       = 2 / 0.301
       ≈ 6,64

Damit kannst du jeden Logarithmus mit einem Taschenrechner berechnen, der nur ln oder log10 hat.

// Java: log_2 selbst berechnen
double log2x = Math.log(x) / Math.log(2);

import math
log2x = math.log(x, 2)        # Python: zweites Argument ist Basis
log2x = math.log2(x)          # oder direkt log2()

Anwendungen

Zinses-Zins (Verdopplungszeit)

Wann verdoppelt sich Kapital bei Zinssatz p?
1000 · (1 + p/100)^t = 2000
(1 + p/100)^t = 2
t · log(1 + p/100) = log 2
t = log 2 / log(1 + p/100)

Beispiele:

• Bei 5 %: t ≈ 14,2 Jahre
• Bei 10 %: t ≈ 7,3 Jahre
• Bei 20 %: t ≈ 3,8 Jahre

Die 72er-Regel (Faustformel)

t ≈ 72/p

5 %: 72/5 = 14,4 Jahre   (exakt 14,2)
10 %: 72/10 = 7,2 Jahre  (exakt 7,3)

Die 72er-Regel folgt aus ln(1 + r) ≈ r für kleine Dezimalzinsen r = p/100 (Taylorreihe). Damit ist die exakte Verdopplungszeit t = ln(2) / ln(1+r) ≈ ln(2)/r ≈ 69,3 / p · 100 \%, auf 72 aufgerundet, weil 72 viele Teiler hat (2, 3, 4, 6, 8, 9, 12 …) und damit besser kopfrechenbar ist.

Halbwertszeit (radioaktiver Zerfall)

N(t) = N₀ · (1/2)^(t/T)        T = Halbwertszeit

Carbon-14 hat T = 5.730 Jahre. Nach 5.730 Jahren noch 50 %, nach 11.460 Jahren noch 25 %, …

Big-O in der Informatik

log₂(n) Operationen für binäre Suche in Liste der Länge n
log₂(1.000.000) ≈ 20  Operationen für 1 Million Elemente!

Logarithmisches Wachstum ist sehr langsam. Verdoppelung der Eingabe = nur EIN zusätzlicher Schritt.

pH-Wert und Dezibel

pH = -log₁₀(H⁺-Konzentration)        Chemie
dB = 10 · log₁₀(P / P₀)               Akustik

Beide sind logarithmisch, aber mit unterschiedlicher Skalierung:

• pH: +1 pH-Einheit bedeutet zehnfach geringere H⁺-Konzentration (also weniger sauer, nicht "10× mehr"). Das Minus-Vorzeichen in der Definition kehrt die Richtung um.
• Dezibel (Leistung): +10 dB bedeutet zehnfache Leistung. +1 dB allein bedeutet nur Faktor 10^{0,1} ≈ 1,26.

Klausur-Tricks

Trick 1, Potenzgleichungen lösen: Wenn die Variable im Exponenten steht, brauchst du Log.

2^x = 32         →  x = log₂(32) = 5
3^x = 81         →  x = log₃(81) = 4

Trick 2, Logarithmus-Regeln auswendig:

• log(a · b) = log a + log b
• log(a/b) = log a - log b
• log(aⁿ) = n · log a

Damit lassen sich komplizierte Ausdrücke vereinfachen.

Trick 3, Basis-Wechsel-Formel:

log_b x = (log x)/(log b)

Egal welche Basis im Zähler/Nenner, Hauptsache gleiche Basis.

Trick 4, Zwei Spezialwerte:

• log_b 1 = 0 (immer 0 für jede Basis)
• log_b b = 1 (Basis selbst → 1)

Trick 5, Log und Exp sind invers:

• a^(log_a x) = x
• log_a(a^x) = x

Kann man manchmal nutzen um Gleichungen zu vereinfachen.

Trick 6, log negativer Zahlen ist undefiniert: log(-1) existiert nicht in ℝ. Klausur-Falle bei Anwendungen.

Trick 7, Logarithmus von 0: log(0) ist nicht definiert; nur der Grenzwert geht gegen -∞ (lim_(x → 0⁺) log(x) = -∞).

Trick 8, log und ln in Code:

• Java: Math.log ist ln (natürlicher Log)
• Java: Math.log10 ist log10
• Python: math.log(x) ist ln, math.log(x, b) mit Basis

Trick 9, 72er-Regel: Verdopplungszeit ≈ 72/p (für Prozent-Wachstum). Funktioniert für 1 % bis ~20 %.

Trick 10, Wachstum ist asymmetrisch:

• 1,05^(10) ≈ 1,63 (10 Jahre 5 %: +63 %)
• 0,95^(10) ≈ 0,60 (10 Jahre -5 %: nur −40 %!)

10 Jahre Wachstum +5 % und 10 Jahre Verlust -5 % ergeben NICHT 1, sondern 0,98 (knapp unter Start).

Wo brauchst du Log und Exp?

• Finance: Zinsrechnung, Renditen, Inflation
• Bevölkerungswachstum: Wirtschaftsprognosen
• Halbwertszeit: Physik, Chemie, Medizin
• Big-O / Algorithmen: log n in Binary Search, Heap
• pH und Dezibel: logarithmische Skalen
• Erdbeben: Richter-Skala (logarithmisch)
• Statistik: log-likelihood in ML
• Astronomie: Magnitude (Helligkeit)
• Neuronale Netze: log-loss / cross-entropy

Faustregel: Wenn etwas multiplikativ wächst (Zinsen, Bevölkerung, Bakterien) → Exponential. Wenn der Output viele Größenordnungen umfasst (pH 1 bis 14, Erdbeben 1 bis 10) → Logarithmisch.

Log-Exp-Lab

Wechsle zwischen Exponential f(x) = a^x und Logarithmus f(x) = log_a(x), wähle eine Basis und sieh den Plot live. Die Werte-Tabelle zeigt 5 wichtige Funktionswerte.

Probier folgendes:

• Basis 2, Exponential: 2^(10) = 1024 (wichtigste Zahl in der Informatik!)
• Basis 10, Logarithmus: log_(10)(1000) = 3, "wieviel Nullen hat 1000"
• Basis 0,5, Exponential: zeigt Zerfall (Halbwertszeit-Form)
• Beachte den markanten Punkt: jede Exp-Funktion durch (0, 1), jede Log-Funktion durch (1, 0)

Plus: Verdopplungszeit-Rechner unten, gib einen Zinssatz ein und sieh die exakte und die 72er-Regel-Approximation.

Faustregel zum Mitnehmen: Logarithmus ist die Umkehrung der Exponentialfunktion. Wenn die Variable im Exponenten steht, Log brauchen. Die 72er-Regel ist der schnellste Weg zur Verdopplungszeit im Kopf.