Das Schneider CPC Systembuch

Grundlagen

Andere Zahlensysteme

Rechnen im Binärsystem

Rechnen im Dezimalsystem ist eine echte Qual. Wieviel einfacher ist es doch im Zweiersystem. Vor allem an Rechnen im Binärsystem: DivisionDivision und Rechnen im Binärsystem: MultiplikationMultiplikation hat man seine helle Freude. Die einzige Schwierigkeit ist es, vom 'dezimalen Denken' wegzukommen.

Da sowohl das Binär- als auch das Dezimalsystem beides Andere Zahlensysteme: Polyadische Zahlensystemepolyadische Zahlensysteme sind, ergeben sich in den Rechenregeln KEINE UNTERSCHIEDE! Man muss sich nur daran gewöhnen, dass ein Übertrag bereits nach '1' und nicht erst nach '9' auftritt.

Addition

In der folgenden Grafik werden die beiden Dezimalzahlen 395 und 194 addiert. In der dritten Zeile wird dabei jeweils der Übertrag festgehalten:

    dezimal:    395  -->   395  -->    395  -->    395  -->    395
              + 194      + 194       + 194       + 194       + 194
                  0         00         100        0100        0100
              -----      -----       -----       -----       -----
               ????       ???9        ??89        ?589        0589

Im Binärsystem geht man exakt genauso vor. Man muss nur das kleine '1+1' des Binärsystems beherrschen:

0+0+0 = 00     0+0+1 = 01
0+1+0 = 01     0+1+1 = 10
1+0+0 = 01     1+0+1 = 10
1+1+0 = 10     1+1+1 = 11

Als Beispiel werden die beiden Zahlen 11000111 und 10101010 addiert. Auch hier werden in der dritten Zeile jeweils der Übertrag festgehalten:

    binär:    11000111 -->  11000111 -->  11000111 -->  11000111 -->  11000111
            + 10101010    + 10101010    + 10101010    + 10101010    + 10101010
                     0            00           100          1100         11100
            ----------    ----------    ----------    ----------      --------
             ?????????             1            01           001          0001


         -->  11000111 -->  11000111 -->  11000111 -->  11000111 -->  11000111
            + 10101010    + 10101010    + 10101010    + 10101010    + 10101010
                011100       0011100      00011100     100011100    0100011100
            ----------    ----------    ----------    ----------    ----------
                 10001        110001       1110001      01110001     101110001

Es dauert zwar etwas länger, weil in binärer Schreibweise alle Zahlen zu einer gewissen Länge neigen, nichtsdestotrotz ist es einfacher. Was zunächst einmal fehlt, ist nur die Übung.

Subtraktion

Auch bei der Rechnen im Binärsystem: SubtraktionSubtraktion herrscht völlige Analogie: Im dezimalen Beispiel werden 177 von 815 abgezogen. Der Übertrag wird in der dritten Zeile vermerkt. Um den Analogie-Schluss zu erleichtern, sei an dieser Stelle der Gedankengang beim Übertrag bei der Rechnen im Binärsystem: SubtraktionSubtraktion an diesem Beispiel noch einmal explizit erläutert:

Soll 7 von 5 abgezogen werden, so reicht 5 nicht aus. Es wird deshalb eine 1 von der nächst-höheren Stelle 'geborgt', die zusammen mit der 5 bereits 15 ergibt. Dannn lässt sich 7 abziehen. Das Resultat auf dieser Stelle ist 8 (8+7=15).

Die Bearbeitung des Übertrags kann auf der nächsten Stelle zwei 'logischen' Wegen erfolgen: Entweder man zieht den Übertrag gleich von der 1 ab, erhält so 0 und zieht dann davon die 7 ab oder man addiert erst den Übertrag und die 7 zu 8 und zieht diese 8 dann von der 1 ab.

    dezimal:   815  -->   815  -->    815  -->    815
             - 177      - 177       - 177       - 177
             -   0         10         110        0110
             -----      -----       -----       -----
               ???        ??8         ?38         638


    binär:    10011 -->  10011 -->  10011 -->  10011 -->  10011 -->  10011
            - 01110    - 01110    - 01110    - 01110    - 01110    - 01110
                  0         00        000       1000      11000     011000
            -------    -------    -------    -------    -------    -------
              ?????      ????1      ???01      ??101      ?0101      00101
                          (Erklärung der Anschlussbelegung: A, B, CA)        (B)        (C)        (D)        (LOW KERNEL JUMPBLOCK: 000E:  LOW PCBC INSTRUCTION
LOW KERNEL JUMPBLOCK: 001E: LOW PCHL INSTRUCTION
E
)
  1. Zuerst wird 0 von 1 abgezogen. Das ergibt 1 und kein Übertrag.
  2. Dann wird 1 von 1 abgezogen. Das ergibt 0 und wieder kein Übertrag.
  3. Danach wird 1 von 0 subtrahiert. 0 reicht nicht aus, es entsteht ein
    Übertrag wenn eine 1 von der nächst-höheren Stelle geborgt wird. Zusammen
    macht das (10)2 + (0)2 -(1)2 = (1)2 oder dezimal: 2-1-0 = 1.
  4. Dann müssen der Übertrag und 1 von 0 abgezogen werden. 0 reicht nicht, es
    wird also wieder 'geborgt'. 2-1-1 = 0 oder binär: (10)2-(1)2-(1)2 = (0)2.
  5. Der Übertrag und 0 müssen von 1 abgezogen werden. Das ergibt 0 und keinen
    weiteren Übertrag.

Ist eine der Zahlen bei Rechnen im Binärsystem: AdditionAddition oder Rechnen im Binärsystem: SubtraktionSubtraktion negativ, so kann man einfach die Die Fließkomma-Routinen: OperationenOperation wechseln: Die Rechnen im Binärsystem: AdditionAddition einer negativen Zahl entspricht ja der Rechnen im Binärsystem: SubtraktionSubtraktion des Betrages:

Operationen: BD5B / 349A / 349A:  FLO SUBa + -LOW KERNEL JUMPBLOCK: 000B:  LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
b
= Operationen: BD5B / 349A / 349A: FLO SUBa - LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
b

Mit dieser Methode kann man es immer deichseln, dass nur zwei positive Zahlen betrachtet werden müssen. Auch wenn bei der Rechnen im Binärsystem: SubtraktionSubtraktion eine negative Zahl herauszukommen droht, muss man aufpassen: Dann würde obige Methode bis zum Sankt-Nimmerleinstag einen Übertrag liefern:

    (11)2 - (1000)2 = (?)2

      0011 -->  0011 -->  0011 -->  0011 -->  0011 -->  0011 -->  0011 --- - -> etc.
    - 1000    - 1000    - 1000    - 1000    - 1000    - 1000    - 1000
         0        00       000      0000     10000    110000   1110000
    ------    ------    ------    ------    ------    ------    ------
      ????         1        11       011      1011     11011    111011

Sinnvollerweise vertauscht man dann die beiden Zahlen und merkt sich, dass das Ergebnis negativ ist: (a-b) = -(b-a)

    (11)2 - (1000)2 = (?)2

      1000  -->   1000  -->   1000  -->   1000  -->   1000
    - 0011      - 0011      - 0011      - 0011      - 0011
         0          10         110        1110       01110
    ------      ------      ------      ------      ------
      ????           1          01         101        0101   --->  (-0101)2
                                                                   ========
Multiplikation

Das kleine Einmaleins des Binärsystems ist ausgesprochen simpel. Es gibt nämlich nur 4 verschiedene Fälle. Würde man wie beim dezimalen kleinen Einmaleins auch noch die Real: NullNull ausklammern, so bestände das binäre Einmaleins nur aus einer einzigen Rechnen im Binärsystem: MultiplikationMultiplikation, nämlich 1*1 = 1:

0*0 = 0
0*1 = 0
1*0 = 0
1*1 = 1

Das 'große' Einmaleins ist nicht minder einfach:

ijklmn * 0 = 000000
ijklmn * 1 = ijklmn

Das soll heißen: Wird eine Zahl mit 0 multipliziert, ergibt das 0. Wird sie mit 1 multipliziert, ergibt es wieder die selbe Zahl. Und mehr Ziffern kennt das Binärsystem nicht!

Darauf kann man bereits das schriftliche Multiplikationsverfahren wie im Dezimalsystem aufbauen! Als dezimales Beispiel werden 25 und 17 multipliziert:

 25 * 17
--------
     25o
     175
--------
     425

Als binäres Beispiel werden 1100 und 1011 multipliziert:

1100 * 1011
-----------
    1100ooo
     0000oo
      1100o
       1100
-----------
   10000100

Die Rechnen im Binärsystem: AdditionAddition der 4 Zeilen kann notfalls in drei getrennten Rechnen im Binärsystem: AdditionAdditionen mit jeweils nur zwei Summanden wie oben gezeigt durchgeführt werden.

Wie dieses Beispiel zeigt, braucht man im Binärsystem gar nicht mehr multiplizieren zu können, da das große Einmaleins nur noch aus 'Abschreiben' oder 'alles Real: NullNull' besteht.

Die Rechnen im Binärsystem: MultiplikationMultiplikation von reellen Zahlen erfordert die selbe Vorsicht wie im Dezimalsystem, um hinterher das Komma an die richtige Stelle zu setzen:

110,1 * 10,01  --> 1101 * 1001 und 3 Nachkommastellen
                   -----------
                       1101ooo
                        0000oo
                         0000o
                          1101
                   -----------
                       1110101 ---> 1110,101
                                    ========
Division

Die Rechnen im Binärsystem: DivisionDivision ist im Binärsystem ebenfalls erheblich einfacher. Als Beispiel wird 81635 durch 362 geteilt.

Bei dem gängigen, schriftlichen Divisionsverfahren verschiebt man den Divisor zuerst so weit nach links, bis er größer als der Divident wird:

 81635 : 362 =              (81635 = Divident)
362000                      (  362 = Divisor )

Nun beginnt folgendes Spiel: Wie oft passt der Divisor in seiner verschobenen Form in den Dividenten? Speziell bei größeren Dividenten (wie 362) geht man da meist nach der Methode 'Schätzen und probieren' vor. Der so ermittelte Wert liefert die nächste (bzw. erste) Ziffer. Das Produkt dieser Ziffer und des verschobenen Dividenten wird vom Divisor abgezogen, der Rest bildet den 'neuen' Divisor und der Divident rutscht wieder eine Stelle nach rechts:

 81635 : 362 =    0225,511...
-00ooo = 362ooo*0-+||| |||
 -----             ||| |||
 81635             ||| |||
-724oo = 362oo*2---+|| |||
 -----              || |||
  9235              || |||
 -724o = 362o*2-----+| |||
  ----               | |||
  1995               | |||
 -1810 = 362*5-------+ |||
  ----                 |||
   185                 |||
  -181,0 = 36,2*5------+||
   ---                  ||
     4,0                ||
    -3,62 = 3,62*1------+|
     ----                |
     0,38                |
    -0,362 = 0,362*1-----+
     -----
     0,018....

Ganz analog die binäre Rechnen im Binärsystem: DivisionDivision. Nur: Hier entfällt das Schätzen, weil man sofort entscheiden kann, ob der Divisor in den Dividenten passt oder nicht. Entsprechend ergibt sich die Ziffer 1 oder 0. Andere Möglichkeiten gibt es nicht! Als Beispiel wird 11010010010 durch 110101 geteilt:

 11010010010 : 110101 = 011111,101 ...
-000000ooooo -----------+||||| |||
 -----------             ||||| |||
 11010010010             ||||| |||
- 110101oooo ------------+|||| |||
 -----------              |||| |||
  1101000010              |||| |||
-  110101ooo -------------+||| |||
  ----------               ||| |||
   110011010               ||| |||
-   110101oo --------------+|| |||
   ---------                || |||
    11000110                || |||
-    110101o ---------------+| |||
    --------                 | |||
     1011100                 | |||
-     110101 ----------------+ |||
     -------                   |||
      100111,0                 |||
-      11010,1 ----------------+||
      --------                  ||
       01100,10                 ||
-       0000,00 ----------------+|
       --------                  |
        1100,100                 |
-        110,101 ----------------+
        --------
           ...

Die Rechnen im Binärsystem: DivisionDivision reeller Zahlen erfordert die selben Zusatzschritte wie im Dezimalsystem. Der Bruch (Die Rechnen im Binärsystem: DivisionDivision stellt ja das Auswerten eines Bruches dar, wobei der Divident der Zähler und der Divisor der Nenner ist) wird so lange mit der Zahlenbasis erweitert (also das Komma in beiden Zahlen so lange nach rechts geschoben) bis beide Zahlen keine Nachkommastellen mehr haben:

0,101 : 11,1 = 00101 : 11100 = 0,00101
              -00000 ----------+ |||||
               -----             |||||
                0101,0           |||||
              - 0000,0 ----------+||||
                ------            ||||
                 101,00           ||||
              -  000,00 ----------+|||
                 ------            |||
                 101,000           |||
              -   11,100 ----------+||
                 -------            ||
                  01,1000           ||
              -    0,0000 ----------+|
                  -------            |
                   1,10000           |
              -    0,11100 ----------+
                   -------
                     ...

Valid HTML   Valid CSS