Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- neuerlehrplan:gk:zahlenformate [2026/03/02 19:49] – angelegt lutz
+++ neuerlehrplan:gk:zahlenformate [2026/03/02 20:01] (aktuell) – [Ganze Zahlen - Zweierkomplement] lutz
@@ Zeile 5: / Zeile 5: @@
 ===== Ganze Zahlen - Zweierkomplement =====
-Exkurs - Schriftliche Addition von Dualzahlen:
+**Exkurs - Schriftliche Addition von Dualzahlen:**
 Das schriftliche Addieren von Dualzahlen unterscheidet sich nicht wesentlich von der Durchführung des Verfahrens bei Dezimalzahlen. Der Unterschied besteht lediglich darin, dass sich bereits bei 2 ein Übertrag ergibt:
@@ Zeile 41: / Zeile 41: @@
 (Es gibt auch noch größere Wertebereiche für ganze Zahlen)
+<WRAP center round info 60%>
+**8-Bit-Darstellung einer (maximal 7-Stelligen) ganzen Zahl:**
+- Eine positive Zahl wird durch führende Nullen auf 8 Bit ausgefüllt. Die führende Null kennzeichnet das Vorzeichen +
+- Bei einer negativen Zahl werden alle 8 Bits der entsprechenden positiven Zahl negiert (Einerkomplement). Anschließend wird 1 addiert (Zweierkomplement).
+</WRAP>
+**Beispiel 3**
+Gegeben ist die Zahl $80=(1001000)_2 $. Um die  Zahl  und ihre entgegengesetzte Zahl bei einer Wortbreite von 8 Bit zu bilden, führen wird die folgenden drei Schritte durch:
+. Ergänzen der Zahl durch führende Nullen auf 8 Stellen (Darstellung von 80 bei 8-Bit Wortbreite): $$0100 1000$$
+. Das Einerkomplement bildet man, indem man alle Stellen der Zahl umkehrt, d.h. aus einer 0 wird eine 1 und aus einer 1 wird eine 0: $$\begin{array}{lr}
+\text{Zahl:  } & 01001000\\
+\text{Einerkomplement:  }&10110111\\
+\end{array}$$
+. Zum Einerkomplement addiert man nun noch die Zahl 1 um das Zweierkomplement zu erhalten (Darstellung von -80 bei 8-Bit Wortbreite): $$
+\begin{array}{rlr}
+\text{Einerkomplement: }&&10110111\\
+&+&1\\
+\text{Zweierkomplement: } &&\underline {\underline {10111000}}
+\end{array}
+$$
+Wenn man nun zur Ausgangszahl das Zweierkomplement (80 + (-80) = 0) addiert, ergibt sich $2^8=256$, also die erste Zweierpotenz, die für die Wortbreite von 8 Bit zu groß ist.
+$$
+\begin{array}{lr}
+&1001000\\
++&10111000\\
+\hline
+&\underline {\underline {100000000}}
+\end{array}
+$$
+Das erste Bit wird abgeschnitten und die 0 bleibt als korrektes Ergebnis übrig.
+<WRAP center round info 60%>
+Die Subtraktion ganzer Zahlen im Computer lässt sich durch Addition der negativen Zahl (des Zweierkomplements) realisieren.
+</WRAP>
+===== Rationale Zahlen =====
+==== Binäre Gleitkommazahlen ====
+Der heutige Standard für die Darstellung von Kommazahlen sind **binäre Gleitkommazahlen** nach der Norm **IEEE 754**. Bei einer Wortbreite von 64 ist die Zahl dann wie folgt aufgebaut:
+- **1 Bit**: Vorzeichen (0-positiv, 1-negativ)
+- **11 Bit**: Exponent der Zweierpotenz (1023 entspricht dem Exponent 0 um auch negative Exponenten darstellen zu können)
+- **52 Bit**: Mantisse -> dezimale Dualzahl, die immer mit 1. beginnt und den Wert der Zahl ohne Potenz repräsentiert
+**Beispiel 3**
+Betrachten wir zum Beispiel den Dezimalbruch 5,5. Um die Zahl als binäre Gleitkommazahl darzustellen, wandeln wir sie zunächst in einen "Binärbruch" um:
+$5.5 = 4 + 1 + \dfrac{1}{2} =(101.1)_2$
+Dann spalten wir die Zweierpotenz ab, so dass vor dem Komma (Dezimalpunkt) eine 1 steht:
+$(101.1)_2 = (1.011)_2 \cdot 2^2$
+Somit ergibt sich:
+- Vorzeichen: 0
+- Exponent: $1023 + 2 = 1025 = (10000000001)_2$ (,da 1023 dem Exponent 0 entspricht)
+- Mantisse .011 (die 1 wird als gesetzt angenommen)
+Damit ergibt sich im Computerspeicher für die Zahl 5,5 das folgende Bitmuster:
+<code>
+10000000001 0110000000000000000000000000000000000000000000000000
+</code>
+,5 lässt dich als binäre Gleitkommazahl recht gut darstellen, da $0,5 = \dfrac{1}{2}$ gleich eine Zweierpotenz mit negativen Exponenten ist. Andere Zahlen wie z.B. 0,2 lassen sich nicht exakt darstellen und es kommt zu kleinen Abweichungen. Andererseits ist der Zugriff auf binäre Gleitkommazahlen durch den Prozessor sehr schnell.
+Binäre 64 Bit-Gleitkommazahlen kommen in Python beim Datentyp float und bei C/C++/Java beim Datentyp double zum Einsatz.
+==== Dezimale Gleitkommazahlen ====
+Diese kommen zum Einsatz, wenn man exakte Dezimalzahlen benötigt werden. In Python werden sie durch den Datentyp decimal.Decimal, in Java durch den Datentyp BigDecimal repräsentiert.  Statt Binärmultiplikatoren arbeitet man mit **Zehnerpotenzen**:
+$\pm d.dddd \cdot 10^e$
+Im Unterschied zu binären Gleitkommazahlen ist dieser Datentyp langsamer und braucht mehr Speicher.
+==== Festkommazahlen ====
+Bei Festkommazahlen wird eine feste Anzahl als Stellen als Vorkommastellen und eine feste Anzahl an Stellen als Nachkommastellen. Das Komma steht immer an derselben Stelle. Bei einer 16 Bit - Festkommazahl repräsentieren die ersten 8 Bit die Zahl vor dem Komma und die hinteren 8 Bit die Stellen nach dem Komma.
+Um die Zahl 36,75 als Festkommazahl darzustellen, zerlegt man sie zunächst in Zweierpotenzen:
+$36.75 = 32 + 4 + \dfrac{1}{2} + \dfrac{1}{4}$
+Der ganzzahlige Anteil wird dann durch die ersten 8 Bit dargestellt, der gebrochene Anteil durch die zweiten 8 Bit. Damit ergibt sich das folgende Bitmuster im Speicher:
+<code>
+00100100 11000000
+</code>
+Festkommazahlen sind sehr schnell und exakt und haben wenig Speicherbedarf. Sie sind aber sehr unflexibel und haben einen begrenzten Wertebereich.