In der Mathematik ist der binäre Logarithmus (loggen n), der Logarithmus zur Basis 2. Es ist die umgekehrte Funktion von n  2. Der binäre Logarithmus von n ist die Macht, zu der die Nummer 2 erhoben werden muss, um den Wert n zu erhalten. Das macht den binären Logarithmus nützlich für irgendetwas, Mächte 2, d. h. Verdoppelung einschließend. Zum Beispiel ist der binäre Logarithmus 1 0, der binäre Logarithmus 2 ist 1, der binäre Logarithmus 4 ist 2, der binäre Logarithmus 8 ist 3, der binäre Logarithmus 16 ist 4, und der binäre Logarithmus 32 ist 5.

Anwendungen

Informationstheorie

Der binäre Logarithmus wird häufig in der Informatik und Informationstheorie verwendet, weil es mit dem binären Ziffer-System nah verbunden wird. Es wird oft ld n, von Latein oder lg n geschrieben, obwohl die ISO Spezifizierung ist, dass es Pfd. (n), lg (n) sein sollte, für den Klotz n vorbestellt werden. Die Zahl von Ziffern (Bit) in der binären Darstellung einer positiven ganzen Zahl n ist der integrale Bestandteil 1 + Pfd. n, d. h.

:

In der Informationstheorie schließt die Definition des Betrags des Selbstinformations- und Informationswärmegewichtes den binären Logarithmus ein; das ist erforderlich, weil sich die Einheit der Information, des Bit, auf die Information bezieht, die sich aus einem Ereignis von einer von zwei ebenso wahrscheinlichen Alternativen ergibt.

Rechenbetonte Kompliziertheit

Der binäre Logarithmus erscheint auch oft in der Analyse von Algorithmen. Wenn eine Nummer n, die größer ist als 1, durch 2 wiederholt geteilt wird, musste die Zahl von Wiederholungen kommen ein Wert höchstens 1 ist wieder der integrale Bestandteil des Pfd. n. Diese Idee wird in der Analyse von mehreren Algorithmen und Datenstrukturen verwendet. Zum Beispiel, in der binären Suche, wird die Größe des Problems, gelöst zu werden, mit jeder Wiederholung halbiert, und deshalb grob ist Pfd. n Wiederholungen erforderlich, um ein Problem der Größe 1 zu erhalten, der leicht in der unveränderlichen Zeit gelöst wird. Ähnlich hat ein vollkommen erwogener binärer Suchbaum, der n Elemente enthält, Höhe-Pfd. n + 1.

Jedoch wird die Laufzeit eines Algorithmus gewöhnlich in der großen O Notation ausgedrückt, unveränderliche Faktoren ignorierend. Seit dem Klotz n = (1/loggst 2) loggen n, wo k jede Zahl sein kann, die größer ist als 1, Algorithmen, die in O laufen (loggen n), wie man auch sagen kann, läuft Zeit in, sagen wir, O (loggen Sie n) Zeit. Die Basis des Logarithmus in Ausdrücken wie O (loggen n), oder O (n loggen n), ist deshalb nicht wichtig.

In anderen Zusammenhängen aber muss die Basis des Logarithmus angegeben werden. Zum Beispiel O (2) ist nicht dasselbe als O (2), weil der erstere O (n) und die Letzteren zu O (n) gleich ist.

Algorithmen mit der Laufzeit n Pfd. n werden manchmal linearithmic genannt. Einige Beispiele von Algorithmen mit der Laufzeit O (Pfd. n) oder O (n Pfd. n) sind:

• durchschnittliche Zeitschnellsortierung
• binäre Suchbäume
• Verflechtungssorte
• Monge ordnen Berechnung

Das Verwenden von Rechenmaschinen

Eine leichte Weise, den Klotz (n) auf Rechenmaschinen zu berechnen, die keine Klotz-Funktion haben, ist, den natürlichen Logarithmus "ln" oder die allgemeinen Logarithmus-"Klotz"-Funktionen zu verwenden, die auf den meisten "wissenschaftlichen Rechenmaschinen" gefunden werden. Die spezifische Änderung von Logarithmus-Grundformeln dafür ist:

:log (n) = ln (n)/ln (2) = Klotz (n) / Klotz (2)

so

:log (n) = Klotz (n) ×1.442695... = Klotz (n)

×3.321928...

und das erzeugt die Wissbegierde, dass Klotz-(n) innerhalb von 0.6 % des Klotzes (n) + Klotz (n) ist. Klotz (n) +log (n) ist wirklich Klotz (n), wo die Basis e = 10  2.00813 59293 46243 95422 87563 25191 0 zu (32 bedeutende Zahlen) ist. Natürlich, log10 = loge = 1.

Algorithmus

Ganze Zahl

Für das Gebiet der ganzen Zahl und die Reihe kann der binäre Logarithmus geschätzt werden zusammentreibend oder unten. Diese zwei Formen der ganzen Zahl binärer Logarithmus sind durch diese Formel verbunden:

:

Die Definition kann durch das Definieren erweitert werden. Diese Funktion ist mit der Zahl von Hauptnullen der binären nicht unterzeichneten 32-Bit-Darstellung von x, nlz (x) verbunden.

:

Die ganze Zahl binärer Logarithmus kann als der Index bei Nullpunkteinstellung des bedeutendsten 1 Bit im Eingang interpretiert werden. In diesem Sinn ist es die Ergänzung des Findens der ersten Satz-Operation, die den Index des am wenigsten bedeutenden 1 Bit findet. Der Artikel findet, dass der erste Satz mehr Information über Algorithmen, Architektur-Unterstützung und Anwendungen für die ganze Zahl binärer Logarithmus enthält.

Reelle Zahl

Für eine allgemeine positive reelle Zahl kann der binäre Logarithmus in zwei Teilen geschätzt werden:

1. Schätzen Sie den Teil der ganzen Zahl,
2. Schätzen Sie den Bruchteil

Computerwissenschaft des integralen Bestandteils ist aufrichtig. Für jeden x> 0, dort besteht eine einzigartige ganze Zahl n solch dass 2  x, oder gleichwertig 1  2x x). Mit anderen Worten:

:

Der Bruchteil des Ergebnisses ist, und kann rekursiv, mit nur die elementare Multiplikation und Abteilung geschätzt werden. Den Bruchteil zu schätzen:

1. Wir fangen mit einer reellen Zahl an. Wenn, dann werden wir getan und der Bruchteil Null ist.
2. Sonst, Quadrat wiederholt, bis das Ergebnis ist. Lassen Sie, die Zahl von erforderlichem squarings zu sein. D. h. mit dem solchem gewählten dass.
3. Die Einnahme des Logarithmus von beiden Seiten und das Tun einer Algebra:

:

\operatorname {Pfd. }\\, z &= 2^m \operatorname {Pfd. }\\, y \\

\operatorname {Pfd. }\\, y &= \frac {\operatorname {Pfd.} z} {2^m} \\

&= \frac {1 + \operatorname {Pfd.} (z/2)} {2^m} \\

&= 2^ {-m} + 2^ {-m }\\operatorname {Pfd.} (z/2)

\end {richten} </Mathematik> {aus}

1. Bemerken Sie, dass das wieder eine reelle Zahl im Zwischenraum ist.
2. Kehren Sie zum Schritt 1 zurück, und schätzen Sie den binären Logarithmus, dieselbe Methode rekursiv zu verwenden.

Das Ergebnis davon wird durch die folgenden Formeln ausgedrückt, in denen die Zahl von squarings ist, der im i-th recursion vom Algorithmus erforderlich ist:

:

\operatorname {Pfd. }\\, x &= n + 2^ {-m_1} \left (1 + 2^ {-m_2} \left (1 + 2^ {-m_3} \left (1 + \cdots \right) \right) \right) \\

&= n + 2^ {-m_1} + 2^ {-m_1-m_2} + 2^ {-m_1-m_2-m_3} + \cdots

\end {richten} </Mathematik> {aus}

Im speziellen Fall, wo, wie man findet, der Bruchteil im Schritt 1 Null ist, ist das eine begrenzte Folge, die an einem Punkt endet. Sonst ist es eine unendliche Reihe, die gemäß dem Verhältnis-Test zusammenläuft, da jeder Begriff ausschließlich weniger ist als der vorherige (seit jedem). Für den praktischen Gebrauch muss diese unendliche Reihe gestutzt sein, um ein ungefähres Ergebnis zu erreichen. Wenn die Reihe nach dem I-Th-Begriff gestutzt ist, dann ist der Fehler im Ergebnis weniger als.

Beispiel-Code

Das folgende Pythonschlange-Programm schätzt den binären Logarithmus mit der rekursiven Methode, die oben entworfen ist, die Schritte entlang dem Weg zeigend:

(Dieser Code scheitert, wenn er den binären Logarithmus jeder Nummer 2^n findet, wo n jede ganze Zahl ist.)

def lg (x):

ip = 0

rem = x

# Teil der Ganzen Zahl

während rem

ip + = 1

rem / = 2

Druck ("lg (%g) = %d + lg (%g)" % (x, ip, rem)) # Klammern hat für die Pythonschlange 3 verlangt

# Bruchteil

res = ip + frac_lg (rem)

geben Sie res zurück

def frac_lg (x, fp=1.0, tol=1e-10):

behaupten Sie 1

rem = x

m = 0

während rem

# => lg (x) = fp * (lg (rem/2) + 1)

# = fp + fp*lg (rem/2)

# Zeit für recursion!

Druck ("lg (x = % g) \t = 2 ** %d * (1 + lg (%g))" % (x,-m, rem/2))

geben Sie fp + frac_lg (rem/2, fp, tol) zurück

wenn __ __ == '__ wichtig __' nennen:

schätzen Sie = 4.5

drucken Sie "X =", schätzen Sie

resultieren Sie = lg (Wert)

Druck ("lg (X) =", Ergebnis) # Klammern hat für die Pythonschlange 3 verlangt

1. Beispielproduktion

1. $-Pythonschlange log2.py

1. X = 4.5

1. lg (4.5) = 2 + lg (1.125)

1. lg (x=1.125) = 2 **-3 * (1 + lg (1.28289))

1. lg (x=1.28289) = 2 **-2 * (1 + lg (1.35435))

1. lg (x=1.35435) = 2 **-2 * (1 + lg (1.68226))

1. lg (x=1.68226) = 2 **-1 * (1 + lg (1.415))

1. lg (x=1.415) = 2 **-1 * (1 + lg (1.00111))

1. lg (x=1.00111) = 2 **-10 * (1 + lg (1.55742))

1. lg (x=1.55742) = 2 **-1 * (1 + lg (1.21278))

1. lg (x=1.21278) = 2 **-2 * (1 + lg (1.08166))

1. lg (x=1.08166) = 2 **-4 * (1 + lg (1.75563))

1. lg (x=1.75563) = 2 **-1 * (1 + lg (1.54113))

1. lg (x=1.54113) = 2 **-1 * (1 + lg (1.18753))

1. lg (x=1.18753) = 2 **-3 * (1 + lg (1.97759))

1. lg (x=1.97759) = 2 **-1 * (1 + lg (1.95543))

1. lg (x=1.95543) = 2 **-1 * (1 + lg (1.91185))

1. lg (x=1.91185) = 2 **-1 * (1 + lg (1.82758))

1. lg (X) = 2.16992500139

</Quelle>

Da Pythonschlange Schwanz recursion nicht optimiert, kann das effizienter mit der Wiederholung durchgeführt werden. Hier ist eine wiederholende Version desselben Algorithmus in Perl:

U-Boot lg {\

mein $x = Verschiebung;

meine $tol = bewegen sich || 1e-13;

mein $res = 0.0;

während ($x

$res + = 1;

$x / = 2;

}\

mein $fp = 1.0;

während ($fp> = $tol) {\

$fp / = 2;

$x * = $x;

wenn ($x> = 2) {\

$x / = 2;

$res + = $fp;

}\

}\

$res

}\

printf "x = %g\nlg (x) = %g\n", 4.5, lg (4.5);

</Quelle>

Siehe auch

• Natürlicher Logarithmus (stützen e)
• Allgemeiner Logarithmus (stützen 10)