Zahlensysteme: Ein kurzer Überblick

[Muddy Waters]

Gerade im Bezug auf D2NT erlebe ich es hier immer wieder, dass eigentlich recht simple Anweisungen wie etwa

NTConfig_CheckSelfSafe = 0x01|0x02|0x10;

von vielen schwer oder gar nicht nachvollzogen werden können.
Da die Hintergründe eigentlich wirklich nicht sonderlich schwierig sind, vermute ich deshalb, dass es einfach an Grundwissen im Bereich der Zahlensysteme fehlt.

Diese kleine Einführung soll darum dazu dienen, einen Überblick über die verschiedenen Zahlensysteme zu erlangen, die Idee dahinter zu verstehen und ein paar neue Begrifflichkeiten kennenzulernen.

Wer schonmal eine Lehrveranstaltung im Bereich der Informatik Grundlagen besucht hat, sollte das alles bereits wissen und braucht eigentlich nicht mehr weiterzulesen, darf es aber natürlich dennoch gerne tun.

Für andere, die noch nie davon gehört haben, gibt es dafür sicherlich das ein oder andere Aha-Erlebnis. Wobei mein Ziel eher darin besteht, einen groben Überblick zu schaffen, als wirklich tiefgehendes Verständnis zu vermitteln.

Ein paar elementare mathematische Grundlagen wie Potenzrechnung oder einfache logische Verknüpfungen werde ich dabei stillschweigend voraussetzen.

Zahlensysteme

Ein Zahlensysteme legt im Grunde nur fest, wie eine Zahl inhaltlich zu interpretieren ist.
Kenne ich das Zahlensystem einer gegebenen Zahl, so kann den Inhalt bzw. Informationsgehalt aus ihr gewinnen und in jedes beliebige andere Zahlensystem überführen.

Das klingt alles recht kryptisch, also machen wir uns erstmal klar, wie wir eigentlich unsere "normalen" Zahlen interpretieren - und in den meisten Fällen machen wir das ganz automatisch, ohne uns je Gedanken darüber zu machen.

Dezimalzahlen

"Normale" Zahlen sind im übrigen Dezimalzahlen. Wer das Vergnügen hatte, Latein zu lernen, sieht sofort, dass im Namen die Zahl 10 enthalten ist.
Und tatsächlich ist die 10 die Basis bei Dezimalzahlen.

Wie interpretieren wir aber nun beispielsweise 1001,42?

Genau das verdeutlicht die folgende Tabelle:

10^3	10^2	10^1	10^0	10^-1	10^-2
1	0	0	1	4	2

Es wird also immer die Ziffer mit der entsprechenden Zehnerpotenz multipliziert und aufsummiert:

1*10^3 + 0*10^2 + 0*10^1 + 1*10^0 + 4*10^-1 + 2*10^-2 = 1000 + 1 + 0,4 + 0,02 = 1001,42

Jede Ziffer kann ausserdem soviele Werte annehmen, wie die Basis vorgibt. Ist die Basis wie in diesem Fall 10, so umfasst der Ziffernwertebereich auch 10 Werte, nämlich 0 bis 9.

Dual-/Binärzahlen

So ein System mit 10 als Basis ist ja schön und gut, problematisch wird es aber dann, wenn man versucht das ganze in Elektronik umzusetzen, wie sie heutzutage überall zum Einsatz kommt.
Denn in der Digitalelektronik gibt es nur zwei Zustände: High bzw. 1 und Low bzw. 0, was einem Transistor in Sättigung bzw. einem gesperrten Transistor entspricht.

Aus diesem Grund verwendet man hier das Binärsystem, ein Zahlensystem mit der Basis 2, bei dem jede Ziffer nur die beiden Werte 0 oder 1 haben kann - die berümten Einsen und Nullen also.
Eine Ziffer einer Binärzahl bezeichnet man auch als Bit.

Auch hier wieder ein Beispiel:
Gegeben sei die Zahl 42 (Dezimal), daraus bauen wir nun eine Binärzahl.
Ich wähle zur Umrechnung mal eine aus meiner Sicht etwas unkonventionelle Methode, die ich aber anschaulich finde.
Programmieren würde man das definitiv anders, allein die Auswahl des Anfangswertes ist viel zu willkürlich, um es in ein Programm zu verpacken.

Wir starten einfach mal willkürlich bei 128 (2^7):

[COLOR=Blue]42[/COLOR] / 128 = [COLOR=Red]0[/COLOR] Rest [COLOR=Blue]42[/COLOR]

Weiter geht es mit 64 (2^6):

[COLOR=Blue]42[/COLOR] / 64 = [COLOR=Red]0[/COLOR] Rest [COLOR=Blue]42[/COLOR]

Weiter geht es mit 32 (2^5):

[COLOR=Blue]42[/COLOR] / 32 = [COLOR=Red]1[/COLOR] Rest [COLOR=Lime]10[/COLOR]

Weiter geht es mit 16 (2^4):

[COLOR=Lime]10[/COLOR] / 16 = [COLOR=Red]0[/COLOR] Rest [COLOR=Lime]10[/COLOR]

Weiter geht es mit 8 (2^3):

[COLOR=Lime]10[/COLOR] / 8 = [COLOR=Red]1[/COLOR] Rest [COLOR=DarkOrange]2[/COLOR]

Weiter geht es mit 4 (2^2):

[COLOR=DarkOrange]2[/COLOR] / 4 = [COLOR=Red]0[/COLOR] Rest [COLOR=DarkOrange]2[/COLOR]

Weiter geht es mit 2 (2^1):

[COLOR=DarkOrange]2[/COLOR] / 2 = [COLOR=Red]1[/COLOR] Rest 0

Weiter geht es mit 1 (2^0):

0 / 1 = [COLOR=Red]0[/COLOR] Rest 0

Das Ergebnis kann man jetzt in eine Tabelle verpacken, wie schon bei den Dezimalzahlen:

2^7	2^6	2^5	2^4		2^3	2^2	2^1	2^0
0	0	1	0		1	0	1	0

Warum ich hier bewusst immer 4-er Blocks bilde werdet ihr später sehen, grundsätzlich sieht man aber, dass man die Zahl 42 in 5 Bits speichern könnte.

Das Ergebnis lässt sich überprüfen, indem man diese Binärzahl nun wieder in eine Dezimalzahl umformt, was auch hier wieder durch Ausmultiplizieren und Aufsummieren geschieht:

0*2^7 + 0*2^6 + 1*2^5 + 0*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 32 + 8 + 2 = 42

Wie man sieht ist das Ergebnis die ursprüngliche Dezimalzahl, die Umrechnung war also offensichtlich richtig.

Man kann aber auch die üblichen Rechenoperationen direkt mit Binärzahlen durchführen. Ich werde das hier aber zunächst mal auslassen, wenn es doch gewünscht wird, bitte Bescheid sagen.
Grundsätzlich läuft dies sehr ähnlich wie beim schriftlichen Rechnen zu Fuß, mit dem Unterschied, dass sich diese Methoden direkt in Hardware überführen lassen.

Hexadezimalzahlen

Die kleine Basis bei Binärzahlen hat zur Folge, dass bei der Darstellung von sehr großen Zahlen Binärzahlen mit extrem vielen Ziffern entstehen.

Als Beispiel:

Dezimal: 1,000,000,000
Binär: 0011 1011 1001 1010 1100 1010 0000 0000

Abhilfe schafft hier das Hexadezimalsystem, ein Zahlensystem mit der Basis 16, mitdem sich jeweils 4 Binärziffern bzw. Bits in eine Hexadezimalziffer überführen lassen.

Einigen wird hierbei vielleicht direkt ein Problem auffallen: Eine Basis von 16 bedeutet auch, dass jede Ziffer 16 Zustände haben muss.
Die Zahlen von 0 bis 9 reichen also nicht mehr aus. Man greift daher einfach auf die ersten Buchstaben des Alphabets zurück.

Die folgende Tabelle zeigt die Dezimalzahlen von 0 bis 15 in Binär und Hexadezimaldarstellung:

Dezimal	Binär	Hexadezimal
0	0000	0
1	0001	1
2	0010	2
3	0011	3
4	0100	4
5	0101	5
6	0110	6
7	0111	7
8	1000	8
9	1001	9
10	1010	A
11	1011	B
12	1100	C
13	1101	D
14	1110	E
15	1111	F

Jetzt wird auch klar, warum ich die vorherigen Binärzahlen immer blockweise aufgeführt habe.

Die Umrechnung einer Binärzahl in eine Hexadezimalzahl geschieht dadurch, dass man jeweils den Dezimalwert jedes 4-er Binärblocks ausrechnet und dafür die passende Ziffer aus dem Hexadzimalsystem schreibt.

Auf die Anfangs genannte Zahl übertragen heisst das:

Binär:	0011	1011	1001	1010	1100	1010	0000	0000
Hexadezimal:	3	B	9	A	C	A	0	0

Auch hier kann man nun wieder wie gehabt eine Umrechnung ins Dezimalsystem durch Ausmultiplizieren und Aufsummieren durchführen:

3*16^7 + 11*16^6 + 9*16^5 + 10*16^4 + 12*16^3 + 10*16^2 + 0*16^1 + 0*16^0 = 805,306,368 + 184,549,376 + 9,437,184 + 655,360 + 49,152 + 2,560 = 1,000,000,000

Übrigens kann man mit zwei Hexadezimalziffern ein Byte darstellen, was 16^2 (256) Bitkombinationsmöglichkeiten bzw. den Dezimalzahlen von 0 bis 255 entspricht.
Mit dem Vorwissen, dass immer 4 Bits einer Hexadezimalziffer entsprechen, entspricht ein Byte somit (in der Regel) 8 Bits.

D2NT und das leidige Thema NTConfig_CheckSelfSafe

Auf dieses Thema wollte ich unbedingt noch eingehen, da es eigentlich den "Praxisbezug" schlechthin darstellt.
Immer wieder tauchen Fragen dazu auf, Leute scheinen ahnungslos und kommen mit den bitweise Operatoren wenig bis gar nicht zurecht.

Dabei ist die Idee, die möglichen negativen Zustände auf dem Charakter (sprich Flüche) über Bitkombinationen zu definieren, aus programmiertechnischer Sicht eigentlich recht intelligent, weil man damit sehr viele verschiedene Informationen in einer einfachen Variable unterbringen kann, indem man die einzelnen Bits dieser Zahl interpretiert.
Dummerweise fehlt der Masse der Nutzer aber einfach etwas das Grundwissen, um das auch hinreichend zu verstehen. Das ändern wir nun.

Zunächst zitiere ich mal die standard Config:

// Check self safe in field (NOT in town). Set to 0 if you won't
// 0x01 : Potion, 0x02 : Poison, 0x04 : Amplify Damage, 0x08 : Weaken, 0x10 : Iron Maiden, 0x20 : Decrepify, 0x40 : Lower Resist
NTConfig_CheckSelfSafe = 0;

Der Vorsatz 0x sagt uns, dass die nachfolgenden Ziffern als Hexadezimalzahl zu interpretieren sind.
Da die Unterschiede in den eigentlichen Bitmustern liegen, wandeln wir zunächst mal die gegebenen Hexadezimalzahlen in Binärzahlen um:

// 0x01 : Potion
Dez.: 1
Bin.: 0000 0001

// 0x02 : Poison
Dez.: 2
Bin.: 0000 0010

// 0x04 : Amplify Damage
Dez.: 4
Bin.: 0000 0100

// 0x08 : Weaken
Dez.: 8
Bin.: 0000 1000

// 0x10 : Iron Maiden
Dez.: 16
Bin.: 0001 0000

// 0x20 : Decrepify
Dez.: 32
Bin.: 0010 0000

// 0x40 : Lower Resist
Dez.: 64
Bin.: 0100 0000

Wie man hier direkt sieht, sind die Vorgabewerte mit bedacht gewählt.
So wird beispielsweise der Zustand Amplify Damage dadurch gekennzeichnet, dass Bit 2 (von rechts) gesetzt ist.
Somit steht jedes einzelne Bit für einen bestimmten, willkürlich definierten Zustand.

Die Funktion, die mit diesen Werten später arbeitet macht dann nichts anderes, als das in der Config definierte Bitmuster zu überprüfen und alle Zustände zu kontrollieren, deren Bit dort gesetzt ist.

Aber wie initialisiert man NTConfig_CheckSelfSafe nun richtig?

Neben den üblichen Rechenoperatoren ("+", "-", "*", "/") bietet JavaScript auch solche Operatoren, die speziell auf Binärzahlen zugeschnitten sind.
Einer dieser Operatoren ist das bitweise ODER und sieht wie folgt aus: |

Aus einer Operation folgt überlicherweise ein Ergebnis, so auch hier.
Nehmen wir als Beispiel an, wir wollten dass sich der Char bei Amplify Damage und Lower Resist heilen geht.

Dazu schreiben wir in der Config:

NTConfig_CheckSelfSafe = 0x04|0x40;

Der Operator vergleicht nun alle Bits der beiden Zahlen und speichert das Ergebnis in einem weiteren Bit. Da die eigentliche Operation ODER heisst, muss das Bit der ersten oder der zweiten Zahl gesetzt sein, damit auch das Ergebnis Bit gesetzt ist.

Für das obige Beispiel heisst das:

HEX        BIN
0x04    0000 0100
0x40    0100 0000
-----------------
0x44    0100 0100

Da hier niemals zwei gleiche Bits gesetzt sein können, entspricht die bitweise ODER-Verknüpfung in diesem Fall der Addition beider Werte.

Da man nun das Ergebnis obiger Operation hat, kann die Variable direkt mit dem Ergebnis der Operation initialisieren, ohne diese tatsächlich aufzuführen:

NTConfig_CheckSelfSafe = 0x44;

Ich hoffe damit ist die Sache nun klarer.

Ansonsten soll es das erstmal gewesen sein, Meinungen, Verbesserungsvorschläge und Erweiterungswünsche höre ich mir natürlich gerne an.

Lg
Muddy

[†deЯbe†]

Echt netter "Guide", und alles schön verständlich. Auch für diejenigen die noch nie was mit Informatikgrundlagen zu tun hatten, ein kurzes Schnuppern in diesen Rechensystem.
mfg.

[Muddy Waters]

Originally Posted by †deЯbe†

Echt netter "Guide", und alles schön verständlich. Auch für diejenigen die noch nie was mit Informatikgrundlagen zu tun hatten, ein kurzes Schnuppern in diesen Rechensystem.
mfg.

Danke fürs Feedback.

Freut mich besonders, dass du sagst, es sei verständlich.
Ich habe nämlich immer etwas Probleme einzuschätzen, ob der "Schwierigkeitsgrad" in Ordnung ist oder ob manche Dinge einfach genauer erklärt werden müssen oder mehr Beispiele erfordern.

Lg
Muddy

[lanara]

Sehr schön erklärt und übersichtlich gestaltet. Schonmal darüber nachgedacht Lehrer zu werden?

[Muddy Waters]

Originally Posted by lanara

Sehr schön erklärt und übersichtlich gestaltet. Schonmal darüber nachgedacht Lehrer zu werden?

Bin ja schon angehender Ingeneur und mit meinem Studiengang ganz zufrieden. Abgesehen davon müsste ich dann nervtötende Schüler ertragen, dieses Problem habe hier nicht.

Naja, jedenfalls in der Regel, manchmal tummeln sich hier schließlich auch so völlig beratungsresistente Kandidaten.

Lg
Muddy

[RezChams]

Sehr schön Eben durch gelesen, wusste nichmal das es so wichtig ist :P
Naja
Kal_el? Sticky, oder warten wir bis Muddy der Mod ist ^^

[Muddy Waters]

Originally Posted by Daarmy

Sehr schön Eben durch gelesen, wusste nichmal das es so wichtig ist :P
Naja
Kal_el? Sticky, oder warten wir bis Muddy der Mod ist ^^

Auch dann setze ich aber nicht automatisch jedes x-beliebige Thema von mir als sticky.

Je mehr stickies gesetzt sind, desto geringer ist die Bedeutung dieser.
Ich würde vermutlich eher ein übersichtliches Thema erstellen, wo man dann Erklärungen und Links zu allen interessanten Dingen in der Programming Sektion findet.

Es muss auch unbedingt nochmal eine anständige Guideline geschrieben werden, in der klar gemacht wird, wann ein Thema hier gut aufgehoben ist oder wann es besser in der allgemeinen D2 Sektion aufgehoben ist.

Aber das kommt.

Lg
Muddy

Lg
Muddy

[Monkeypunch]

sehr gut und sehr ordentlich geschrieben