Programmierung auf Bit-Level

Bool-Funktionen für Kalkulation und Basic

Ein Standard Kalkulations-Programm zusammen mit einigen 'Benutzer-definierten Basic-Funktionen bietet eine ausgezeichnete Gelegenheit, um BitLevel-Funktionen zu demonstrieren und damit zu experimentieren. Die Beispiele dieser Seite können dazu evtl. einen Beitrag leisten. Alle Funktionern sind in der Praxis getestet, die Anwendung erfolgt jedoch auf eigenes Risiko.
BitLevel Operationen auf Bit-Ebene
Live-Demo
Bitmuster, Operatoren NOT, AND, OR
Shift-Operatoren
LSL, LSR, ASL, ASR, ROL, ROR, SWAP
Vorzeichen
Negative Zahlen, 2er-Komplement
Programmierung Operatoren, Priorität, Speicher-Breite, Anwendung in Programmiersprachen
Auf dieser Seite:
Kalkulation Benutzer-definierte Basic-Funktionen
Basic LibreOffice-Basic, Visual Basic (VBA): Hilfs-Funktionen
Binär-Strings
Simulation aller BitLevel-Funktionen mit Strings
BitLevel-Rechnung
Arithmetische Berechnung
Verwandte Themen Interne Darstellung: Gleitkomma-Zahlen, Zeichencodes, Umwandlung Strings ↔ (Binär)-Zahlen, Programmiersprache Basic (VBA)

Kalkulations-Programme

Ein Standard Kalkulations-Programm (z.B. LibreOffice (technisch führend, kostenfrei), MS-Excel, ...) ist auf fast jedem PC installiert. Man kann es mit Unterstützung einiger ↓ Basic-Funktionen gut für einfache BitLevel-Experimente verwenden.
Das erfordert keine besonderen Resourcen und bietet in kurzer Zeit anschauliche Ergebnisse. 		In den Beispielen werden die Bitmuster entweder durch ganze Zahlen oder durch Strings (Texte) aus "0" und "1" Ziffern dargestellt, und zwar durchwegs mit 8 Bit (1 Byte).
Das Kalkulations-Programm wird hier in kleinen Teilen vorgestellt. Das ist aus Platz-Gründen notwendig und zum Aufbau in kleinen Schritten durchaus sinnvoll.

Standard-Funktionen

Die wenigen von den Kalkulations-Programmen zu diesem Thema angebotenen Funktionen arbeiten - wenn überhaupt vorhanden - unbefriedigend. Darüber hinaus sind ihre Details auch von den verschiedenen Programmen und Versionen abhängig.

Funktion Dec2Bin() erzeugt aus einer ganzen Zahl einen Binär-String mit der dazu benötigten Länge. Man kann die Anzahl der Binär-Ziffern wählen, jedoch nur zwischen dem benötigten Minimum und 10.
Funktion DEZINBIN() erzeugt aus einer ganzen Zahl einen Binär-String mit der dazu benötigten Länge. Man kann die Anzahl der Binär-Ziffern wählen, jedoch nur >= dem benötigten Minimum.

Die Funktionen Bin2dec() und BININDEZ() erzeugen aus einem Binär-String eine ganze Zahl, allerdings nur aus maximal 10 Ziffern, und mit BININDEZ() ungefragt nach dem → 2er-Komplement.

• Die hier vorgestellten Funktionen bieten mehr Flexibilität und alle Standard Bool-Funktionen zur bitweisen Verknüpfung.
Es gibt 2 grundsätzlich verschiedene Ansätze für BitLevel-Darstellung und -Rechnung:

Binär-Strings

Alle Funktionen dieser Variante arbeiten mit Binär-Strings, d.h. mit Text, der nur aus den Ziffern "0" und "1" besteht. Damit kann man alle BitLevel-Funktionen gut demonstrieren, jedoch nicht rechnen: Man kann jeden Binär-String jedoch wieder in eine ganze Zahl umwandeln, z.B. mit der hier vorgestellten Basic-Funktion bin_to_int()

■ Die Namen aller mit Binär-Strings arbeitenden Funktionen dieser Seite beginnen mit 'bin_'

Arithmetische Rechnung

Die BitLevel-Funktionen werden durch arithmetische Berechnung ersetzt. Damit kann man bei Bedarf besser rechnen, das Ergebnis ist jedoch immer eine ganze Zahl. Man kann sie zur Anzeige in einen Binär-String umwandeln.
■ Die Namen aller derartigen Funktionen beginnen mit 'bool_'

● In den Kalkulations-Beispielen wird jede Funktion in beiden Variantenn vorgestellt:
• Bool-Funktionen verwenden zur Ein- und Ausgabe ganze Zahlen. Die Ergebnisse werden in Binär-Strings umgewandelt.
• Binär-Funktionen verwenden zur Ein- und Ausgabe Binär-Strings. Die Ergebnisse werden in ganze Zahlen umgewandelt.

Zahlen und Bit-Muster

Für alle folgenden Experimente werden in den Zellen B1:C2 die Vorgaben erzeugt. Sie können den Zufalls-Generator B1:B2 natürlich durch beliebige andere ganze Zahlen ersetzen.

Die Funktion bin8_from_int() und alle weiteren 'Benutzer-definierten' Funktionen werden im Kapitel ↓ Basic vorgestellt. 		Dieses Kalkulations-Programm erzeugt 2 zufällige 8-Bit Muster:
 ABC
1a==GANZZAHL(ZUFALLSZAHL()*256) =bin8_from_int(B1)
2b==GANZZAHL(ZUFALLSZAHL()*256) =bin8_from_int(B2)
• Die Zahlenwerte in B1:B2 dienen als Vorgabe für alle (arithmetisch rechnenden) bool-Funktionen.
• Die Binär-Strings in C1:C2 dienen als Vorgabe für alle mit Strings arbeitenden bin-Funktionen.

NOT-Funktion

Diese Bool-Funktion invertiert alle Bits. Sie braucht nur 1 Argument und wird hier mit der Variablen a demonstriert.
• Die arithmetische Funktion bool8_not() verwendet als Argument die Variable a als ganze Zahl, die String-Funktion bin8_not() verwendet die gleiche Variable als Binär-String. 		Bit-Umkehrung mit NOT-Funktion: Oben (in Zeile 4) die Vorgabe (Argument), unten (in Zeile 6) das Ergebnis.
 AB
4=B1=C1
5NOT
6=bool8_not(A4)=bin8_not(B4)

AND-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist nur dann =1, wenn alle (beide) entsprechenden Eingangs-Bits =1 sind.
Oben (in den Zeilen 8,9) die beiden Argumente, unten (in Zeile 11) das Ergebnis. 		AND-Funktion: Anwendung u.a. zum gezielten Löschen von Bits
 AB
8=B1=C1
9=B2=C2
10AND
11=bool8_and(A8;A9)=bin8_and(B8;B9)

OR-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist immer dann =1, wenn mindestens eines der (beiden) entsprechenden Eingangs-Bits =1 ist. 		OR-Funktion: Anwendung u.a. zum gezielten Setzen von Bits
 DE
8=B1=C1
9=B2=C1
10OR
11=bool8_or(D8;D9)=bin8_or(E8;E9)

XOR-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist immer dann =1, wenn die beiden entsprechenden Eingangs-Bits ungleich sind. 		XOR-Funktion: Anwendung u.a. zum Vergleich von Bitmustern
 GH
8=B1=C1
9=B2=C2
10XOT
11=bool8_xor(G8;G9)=bin8_xor(H8;H9)

NAND-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist nur dann =0, wenn alle (beide) entsprechenden Eingangs-Bits =1 sind. Die Funktion hat in der Elektronik wesentlich mehr Bedeutung als in der Informatik. 		NAND-Funktion:
 AB
13=B1=C1
14=B2=C2
15NAND
16=bool8_nand(A13;A14)=bin8_nand(B13;B14)

NOR-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist immer dann =0, wenn mindestens eines der (beiden) entsprechenden Eingangs-Bits =1 ist. Die Funktion hat in der Elektronik wesentlich mehr Bedeutung als in der Informatik. 		NOR-Funktion:
 DE
13=B1=C1
14=B2=C2
15NOR
16=bool8_nor(D13;D14)=bin8_nor(E13;E14)

NXOR-Funktion

Diese Bool-Funktion braucht (mindestens) 2 Argumente (hier a, b). Ein Ergebnis-Bit ist immer dann =1, wenn die beiden entsprechenden Eingangs-Bits gleich sind. 		NXOR-Funktion: Anwendung u.a. zum Vergleich von Bitmustern
 GH
13=B1=C1
14=B2=C2
15NXOR
16=bool8_nxor(G13;G14)=bin8_nxor(H13;H14)

SHIFT-Funktionen

In Spalte A ist ein Zähler 0...8 programmiert. Damit wird das Bitmuster der Variablen a um 0...8 Bits verschoben.
Sie können die Zellen A20:C20 nach unten ausfüllen. 		Logische = arithmetische Shift-Left Funktion:
 ACD
18CountLSL = ASL
190=bool8_lsl($B$1;$A19)=bin8_lsl($C$1;$A19)
20=A19+1=bool8_lsl($B$1;$A20)=bin8_lsl($C$1;$A20)
21=A20+1=bool8_lsl($B$1;$A21)=bin8_lsl($C$1;$A21)
...
27=A26+1=bool8_lsl($B$1;$A27)=bin8_lsl($C$1;$A27)
Nach dem gleichen Muster kann man auch alle anderen Shift-Funktionen demonstrieren, z.B. so wie rechts angedeutet: Füllen sie für LSR die Zellen F19:G19 nach unten aus.
Erzeugen sie in A30:A38 eine neuen Zähler und füllen sie F30:G30 nach unten aus.
Im Bereich C29:D38 ist noch Platz für die Funktion ASL frei, die jedoch genau gleich arbeitet wie LSL. 		Logischer Shift nach rechts (LSR):
 FG
18LSR
19=bool8_lsr($B$1;$A19)=bin8_lsr($C$1;$A19)
...

Arithmetischer Shift nach rechts (ASR):
 AFG
29CountASR
300=bool8_asr($B$1;$A30)=bin8_asr($C$1;$A30)
...

ROTATE-Funktionen

In Spalte A ist ein Zähler 0...7 programmiert. Damit wird das Bitmuster aus Zelle C1 um 0...8 Bits verschoben. Jedes 'heraus'-rotierte Bit wird am anderen Ende wieder 'herein' rotiert.
Sie können die Zellen D20:E20 nach unten ausfüllen. 		Rotation nach links (ROL):
 ACD
40CountROL
410 =bool8_rol($B$1;$A41)=bin8_rol($C$1;$A41)
42=A41+1 =bool8_rol($B$1;$A42)=bin8_rol($C$1;$A20)
43=A42+1 =bool8_rol($B$1;$A43)=bin8_rol($C$1;$A21)
...
49=A48+1 =bool8_rol($B$1;$A49)=bin8_rol($C$1;$A27)
Nach dem gleichen Muster kann man auch die ROR-Funktion demonstrieren, z.B. so wie rechts angedeutet: Füllen sie die Zellen F19:G19 nach unten aus. Rotation nach rechts (ROR):
 FG
40ROR
41=bool8_ror($B$1;$A41)=bin8_ror($C$1;$A41)
...

Basic (LibreOffice-Basic, Visual Basic, VBA):   Binär-Strings

Basic bietet in der Grund-Version keine BitLevel Operatoren.
Hier werden in 2 Kapiteln einige Funktionen vorgestellt, die Experimente mit BitLevel Operationen erlauben:
► Darstellung mit Variablen des Typs String (Dieses Kapitel)
► Arithmetische Berechnung mit ganzen Zahlen (nächstes ↓ Kapitel)
Binär-Strings eignen sich gut zur Demonstration mit ↑ Kalkulations-Programmen.
Man kann die vorgestellten Basic-Funktionen mit jedem Standard Kalkulations-Programm (LibreOffice-Calc, MS-Excel, ...) verwenden.

Umwandlung Zahl -> String

Diese Funktion dient zur Umwandlung einer ganzen Zahl 0..255 in einen Binär-String (Text aus 8 Ziffern "0" und "1"). Nur diese beiden Umwandlungs-Funktionen verwenden Zahlen als Argumente. Alle anderen bin-Funktionen verwenden nur Strings als Argumente.
Function bin8_from_int(int_0_255 As Integer) As String
Dim i, idiv, irest, j As Integer
Dim bin As String
irest = Abs(int_0_255)
While (irest >= 256)
irest = irest - 256
Wend bin = ""
For i = 7 To 0 Step -1
idiv = 2 ^ i
j = irest \ idiv
bin = bin & CStr(j)
irest = irest - j * idiv
Next
bin8_from_int = bin
End Function

Die numerischen Eingabe-Daten int_0_255 werden auf 8 Bit abgeschnitten. Danach werden die Binär-Ziffern in einer For-Schleife einzeln berechnet:
Der Stellenwert des jeweiligen Bits wird in der Variablen idiv berechnet.
Jede Ziffer wird durch ganzzahlige Division (Operator \ ) in der Variablen j berechnet und in der String-Variablen bin gesammelt.
Danach wird der verbleibende Rest neu berechnet.

• Die Namen dieser und aller folgenden 8-Bit Funktion des Kapitels beginnen mit bin8
Sie sind daher auch in einer langen Funktionen-Liste leicht zu finden. 		Diese Variante der Funktion erzeugt aus einer ganzen Zahl <= (2^30)-1 einen Binär-String beliebiger Länge:
Function bin_from_int(intg As Long, _
Optional bits As Integer = 0) As String
Dim i, imax As Integer
Dim idiv, irest, j As Long
Dim bin As String
If IsMissing(bits) Then bits = 0
irest = Abs(intg)
imax = bin_digits(irest)
If (bits <= 0) Then bits = imax
If (imax > 30) Then imax = 30
If (irest > 0) Then
bin = ""
For i = imax To 0 Step -1
idiv = 2 ^ i
j = irest \ idiv
bin = bin & CStr(j)
irest = irest - j * idiv
Next
Else
bin = "0"
End If
Select Case (Len(bin))
Case Is < bits
bin = String(bits - Len(bin), "0") & bin
Case Is > bits
bin = Right(bin, bits)
End Select
bin_from_int = bin
End Function
Diese Funktion erzeugt mit 1 Argument einen Binär-String der benötigten Länge, maximal 30 Bit.
Mit dem optionalen 2. Argument kann man die Bit-Anzahl wählen: Zusätzliche 0-Bits werden links ergänzt, überzählige abgeschnitten.

Anzahl der Binär-Stellen

Die Funktion bin_digits() berechnet, wieviele Bits (=Binär-Ziffern) zur binären Darstellung einer ganzen Zahl erforderlich sind.

Sie wird u.a. von der Basic-Funktion bin_from_int() verwendet und muss daher ihr Argument ByVal erhalten. 		Berechnung der Binär-Stellen mit Basic:
Function bin_digits(ByVal intg As Long) As Integer
Dim i As Integer
Dim x As Double
x = Abs(CDbl(intg))
If (x > 0) Then
x = Log(x) / Log(2)
i = Int(x) + 1
Else
i = 1
End If
bin_digits = i
End Function

Umwandlung String -> Zahl

Diese Funktion berechnet aus einem Binär-String mit <=31 Ziffern eine positive ganze Zahl:

Diese beiden Funktionen markieren Anfang und Ende von typischen Bitlevel-Operationen:
Mit int_to_bin8() kann man ganze Zahlen 0..255 in Bitmuster-Strings umwandeln, danach mit den Bool-Funktionen dieses Kapitels modifizieren, und zuletzt den Binär-String mit Funktion bin_to_int() wieder in eine ganze Zahl umwandeln. 		Berechnung einer Zahl aus einem Binär-String mit Basic:
Function bin_to_int(bin As String) As Long
Dim i As Integer
Dim intg As Long
Dim rest As String
rest = bin
intg = 0
i = 0
While (Len(rest) > 0)
intg = intg + CInt(Right(rest, 1)) * (2 ^ i)
rest = Left(rest, Len(rest) - 1)
i = i + 1
Wend
bin_to_int = intg
End Function

NOT-Funktion (8 Bit)

Function bin8_not(bin8 As String) As String
Dim i As Integer
Dim bin, c As String
bin = ""
For i = 1 To 8
c = Mid(bin8, i, 1)
If (c = "1") Then
bin = bin & "0"
Else
bin = bin & "1"
End If
Next
bin8_not = bin
End Function
Die For-Schleife isoliert je 1 Bit des erhaltenen String-Arguments bin8 in der Variablen c

Im Algorithmus (rot) wird das Bit verarbeitet. Das Ergebnis wird Zeichen-weise im Ausgangs-String bin gesammelt und zuletzt zurückgegeben.

AND-Funktion (8 Bit)

Function bin8_and(a_bin8 As String, _
b_bin8 As String) As String
Dim i As Integer
Dim bin, ca, cb As String
bin = ""
For i = 1 To 8
ca = Mid(a_bin8, i, 1)
cb = Mid(b_bin8, i, 1)
If (ca = "1" And cb = "1") Then
bin = bin & "1"
Else
bin = bin & "0"
End If
Next
bin8_and = bin
End Function
Die For-Schleife isoliert je je 1 Bit der beiden String-Argumente a_bin8, b_bin8 in den Variablen ca, cb
Danach werden die beiden Bits mit dem AND-Algorithmus verknüpft und an den Ergevbnis-String bin angefügt.
Alle weiteren bin-Funktionen sind gleich aufgebaut: Es wird lediglich der Algorithmus (rot) zur Verknüpfung der beiden Bits ca, cb ausgetauscht.

OR-Funktion (8 Bit)

Function bin8_or(a_bin8 As String, _
b_bin8 As String) As String
Dim i As Integer
Dim bin, ca, cb As String
bin = ""
For i = 1 To 8
ca = Mid(a_bin8, i, 1)
cb = Mid(b_bin8, i, 1)
If (ca = "1" Or cb = "1") Then
bin = bin & "1"
Else
bin = bin & "0"
End If
Next
bin8_or = bin
End Function
Diese Funktion ist gleich aufgebaut wie bin_8_and()
Lediglich der Algorithmus (rot) arbeitet anders, d.h. nach der OR-Verknüpfung.

XOR-Funktion (8 Bit)

Function bin8_xor(a_bin8 As String, _
b_bin8 As String) As String
Dim i As Integer
Dim bin, ca, cb As String
bin = ""
For i = 1 To 8
ca = Mid(a_bin8, i, 1)
cb = Mid(b_bin8, i, 1)
If ((ca = cb) Then
bin = bin & "0"
Else
bin = bin & "1"
End If
Next
bin8_xor = bin
End Function
Diese Funktion ist gleich aufgebaut wie bin_8_and()
Lediglich der Algorithmus (rot) arbeitet anders, d.h. nach der XOR-Verknüpfung.

NAND-Funktion (8 Bit)

Function bin8_nand(a_bin8 As String, _
b_bin8 As String) As String
Dim bin As String
bin = bin8_and(a_bin8, b_bin8)
bin = bin8_not(bin)
bin8_nand = bin
End Function
Die Funktion verwendet die beiden oben vorgestellten Funktionen zur AND- und zur NOT-Verknüpfung.

NOR-Funktion (8 Bit)

Function bin8_nor(a_bin8 As String, _
b_bin8 As String) As String
Dim bin As String
bin = bin8_or(a_bin8, b_bin8)
bin = bin8_not(bin)
bin8_nor = bin
End Function
Die Funktion verwendet die beiden oben vorgestellten Funktionen zur OR- und zur NOT-Verknüpfung.
Analog kann man aus XOR- und NOT- eine NXOR-Funktion zusammenstellen.

Logischer Shift (8 Bit)

Die beiden vorgestellten Funktionen verschieben das Bitmuster des 1. Arguments nach links bzw. nach rechts.

• Das optionale 2. Argument bezeichnet die Anzahl der Shifts, d.h. der Bit-Positiionen. Ohne weitere Angaben wird um je 1 Bit verschoben. Die Syntax für optionale Argumente berücksichtigt sowohl LibreOffice-Basic (Funktion IsMissing() ) als auch MS-Basic (VBA).

• Ein Shift um 0 Stellen liefert den unveränderten Binär-String.
• Shifts um >8 Stellen sind sinnlos, weil das Ergebnis in diesem Fall ausschließlich aus 0-Ziffern besteht.

Die Algorithmen für 'Arithmetischen Shift' (nächster ↓ Absatz) sind nahe verwandt. 		Logische Shift-Funktionen mit Basic:
Function bin8_lsl(bin8 As String, _
Optional bits As Integer = 1) As String
Dim i As Integer
Dim bin As String
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
bin = bin8
For i = 1 To bits
bin = Right(bin & "0", 8)
Next
bin8_lsl = bin
End Function

Function bin8_lsr(bin8 As String, _
Optional bits As Integer = 1) As String
Dim i As Integer
Dim bin As String
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
bin = bin8
For i = 1 To bits
bin = Left("0" & bin, 8)
Next
bin8_lsr = bin
End Function

Arithmetischer Shift (8 Bit)

● Der Arithmetische Shift nach links (ASL) ist identisch mit dem logischen Shift nach links (voriger ↑ Absatz).

● Der arithmetische Shift nach rechts (ASR) behandelt das höchstwertige Bit anders als der logische Shift:
In diesem Fall wird nur in der For-Schleife nicht ein "0"-Bit angefügt sondern das höchstwertige Bit verdoppelt.

Das hat eine Bedeutung für negative ganze Zahlen:
♦ Details zum Thema 2er-Komplement. 		Arithmetische Shift-Funktionen mit Basic:
Function bin8_asl(bin8 As String, _
Optional bits As Integer = 1) As String
If IsMissing(bits) Then bits = 1
bin8_asl = bin8_lsl(bin8, bits)
End Function

Function bin8_asr(bin8 As String, _>
Optional bits As Integer = 1) As String
Dim i As Integer
Dim bin As String
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
bin = bin8
For i = 1 To bits
bin = Left(Left(bin, 1) & bin, 8)
Next
bin8_asr = bin
End Function

Rotation (8 Bit)

Die beiden vorgestellten Funktionen rotieren das Bitmuster des 1. Arguments nach links (ROL) bzw. nach rechts (ROR).
Function bin8_rol(bin8 As String, _
Optional bits As Integer = 1) As String
Dim i As Integer
Dim bin As String
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
bits = bots Mod 8
bin = bin8
For i = 1 To bits
bin = Right(bin & Left(bin, 1), 8)
Next
bin8_rol = bin
End Function
Jedes 'heraus' rotierte Bit wird am anderen Ende des Strings wieder angefügt.
Das optionale 2. Argument bezeichnet die Anzahl der Positionen (Standard =1).
Function bin8_ror(bin8 As String, _
Optional bits As Integer = 1) As String
Dim i As Integer
Dim bin As String
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
bits = bits Mod 8
bin = bin8
For i = 1 To bits
bin = Left(Right(bin, 1) & bin, 8)
Next
bin8_ror = bin
End Function
Nach Rotation um 8 Positionen ist der Binär-String wieder identisch.

Swap (8 Bit)

Diese Funktion vertauscht die beiden Nibbles des 8-Bit Arguments:
Function bin8_swap(bin8 As String) As String
bin8_swap = Right(bin8, 4) & Left(bin8, 4)
End Function

♦ Details zur Verwendung von Basic-Modulen

Basic (LibreOffice-Basic, Visual Basic, VBA):   Binär-Arithmetik

Die hier vorgestellten Funktionen eignen sich zum Rechnen mit BitLevel Funktionen.
• Die Argumente und Ergebnisse sind jeweils positive ganze Zahlen im Bereich 0...255
• Die Namen aller Funktionen dieses Kapitels beginnen mit dem Prefix bool8
Man kann die vorgestellten Basic-Funktionen mit jedem Standard Kalkulations-Programm (LibreOffice-Calc, MS-Excel, ...) verwenden.
• Zur Anzeige der Bitmuster dienen z.B. die Funktionen bin_from-int(), bin8_from_int() des ↑ vorigen Kapitels.

♣ Alternative: Die ↑ String-Funktionen führen die gleichen Arbeiten mit Binär-Strings aus.

Arithmetische Grundlage

Wenn keine BitLevel-Operatoren zur Verfügung stehen, dann kann man z.B. diese arithmetischen Funktionen verwenden, um Zahlenwerte zu isolieren, die bestimmten Bits entsprechen. 		Verschiebung um 1 Bit nach rechts mit 'ganzzahliger Division' (mit \ Backslash-Operator !).
i = i \ 2
Verschiebung um 1 Bit nach Links:
i = i * 2

NOT-Funktion (8 Bit)

Function bool8_not(int_0_255 As Integer) As Long
Dim i As Integer
Dim idiv, ir, irest, j As Long
irest = int_0_255
ir = 0
For i = 7 To 0 Step -1
idiv = 2 ^ i
j = irest \ idiv
If j = 0 Then ir = ir + idiv
irest = irest - j * idiv
Next
bool8_not = ir
End Function
Die For-Schleife durchläuft alle 8 Bit-Positionen einer ganzen Zahl des Bereichs 0..255
In der Variablen idiv wird der Stellenwert jedes Bits berechnet.
Der (verbliebene) Zahlenwert irest wird durch den Stellenwert ganzzahlig dividiert. In der Variablen ir wird - je nach dem Ergebnis der Division - das Ergebnis aufgebaut.

AND-Funktion (8 Bit)

Function bool8_and(a_0_255 As Integer, _
b_0_255 As Integer) As Long
Dim i As Integer
Dim arest, brest, idiv, ir, ja, jb As Long
arest = a_0_255
brest = b_0_255
ir = 0
For i = 7 To 0 Step -1
idiv = 2 ^ i
ja = arest \ idiv
jb = brest \ idiv
If (ja = 1 And jb = 1) Then ir = ir + idiv
arest = arest - ja * idiv
brest = brest - jb * idiv
Next
bool8_and = ir
End Function
Die ganzzahlige Division durch den Stellenwert idiv wird auf die Reste beider Eingangs-Daten ja, jb angewendet. Das Ergebnis wird je nach Algorithmus (rot) in der Variablen ir aufgebaut.
Alle weiteren bool-Funktionen sind gleich aufgebaut: Es wird lediglich der Algorithmus (rot) zur Verknüpfung ausgetauscht: Wenn man die Algorithmus-Zeile gegen diese austauscht, dann erhält man die NAND-Funktion:
If (ja = 0 Or jb = 0) Then ir = ir + idiv

OR-Funktion (8 Bit)

Function bool8_or(a_0_255 As Integer, _
b_0_255 As Integer) As Long
Dim i As Integer
Dim arest, brest, idiv, ir, ja, jb As Long
arest = a_0_255
brest = b_0_255
ir = 0
For i = 7 To 0 Step -1
idiv = 2 ^ i
ja = arest \ idiv
jb = brest \ idiv
If (ja = 1 Or jb = 1) Then ir = ir + idiv
arest = arest - ja * idiv
brest = brest - jb * idiv
Next
bool8_or = ir
End Function
Wenn man die Algorithmus-Zeile gegen diese austauscht, dann erhält man die NOR-Funktion:
If (ja = 0 And jb = 0) Then ir = ir + idiv

XOR-Funktion (8 Bit)

Function bool8_xor(a_0_255 As Integer, _
b_0_255 As Integer) As Long
Dim i As Integer
Dim arest, brest, idiv, ir, ja, jb As Long
arest = a_0_255
brest = b_0_255
ir = 0
For i = 7 To 0 Step -1
idiv = 2 ^ i
ja = arest \ idiv
jb = brest \ idiv
If (ja <> jb) Then ir = ir + idiv
arest = arest - ja * idiv
brest = brest - jb * idiv
Next
bool8_xor = ir
End Function
Wenn man die Algorithmus-Zeile gegen diese austauscht, dann erhält man die NXOR-Funktion:
If (ja = jb) Then ir = ir + idiv

Logischer Shift nach links (LSL, 8 Bit)

Function bool8_lsl(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
Dim i As Integer
Dim ir As Long
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
ir = a_0_255
For i = 1 To bits
ir = ir * 2
While (ir >= 256)
ir = ir - 256
Wend
Next
bool8_lsl = ir
End Function
Verschiebung nach links bedeutet Multiplikation mit 2.
Wenn dabei ein 9. Bit erzeugt wurde, dann wird es durch Subtraktion von 256 entfernt. Die Funktion ist identisch mit dem arithmetischen Shift nach links ASL.

Logischer Shift nach rechts (LSR, 8 Bit)

Function bool8_lsr(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
Dim i As Integer
Dim ir As Long
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
ir = a_0_255
For i = 1 To bits
ir = ir \ 2
Next
bool8_lsr = ir
End Function
Diese Verschiebung entspricht in jedem Fall einer ganzzahligen Division durch 2. Das links ergänzte Bit ist immer =0

Arithmetischer Shift (8 Bit)

Das rechts vorgestellte Beispiel zeigt einen arithmetischen Shift:

Der arithmetische Shift nach links ASL ist identisch mit dem logischen Shift LSL.

Den arithmetische Shift nach rechts (ASR) kann man so berechnen:
Das bei jedem Schritt links angefügte (Vorzeichen)-Bit wird schon vor Beginn der Schleife in der Variablen msb isoliert.
Im Algorithmus (rot) wird mittels ganzzahliger Division durch 2 nach rechts verschoben und das höchstwertige Bit durch Addition von msb hinzugefügt.
Function bool8_asl(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
If IsMissing(bits) Then bits = 1
bool8_asl = bool8_lsl(a_0_255, bits)
End Function

Function bool8_asr(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
Dim i As Integer
Dim ir, msb As Long
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
If bits > 8 Then bits = 8
ir = a_0_255
If (ir >= 127) Then
msb = 128
Else
msb = 0
End If
For i = 1 To bits
ir = (ir \ 2) + msb
Next
bool8_asr = ir
End Function

Rotation nach links (ROL 8 Bit)

Function bool8_rol(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
Dim i As Integer
Dim ir As Long
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
bits = bits Mod 8
ir = a_0_255
For i = 1 To bits
If ir > 127 Then
ir = (ir - 128) * 2 + 1
Else
ir = ir * 2
End If
Next
bool8_rol = ir
End Function
Jede Verschiebung oder Rotation nach links entspricht einer Multiplikation mit 2.
Wenn das links heraus-rotierte Bit gesetzt war, dann wird sein alter Wert (128) subtrahiert und der neue Wert (1) addiert.

Rotation nach rechts (ROR, 8 Bit)

Function bool8_ror(a_0_255 As Integer, _
Optional bits As Integer = 1) As Long
Dim i As Integer
Dim ir, msb As Long
If IsMissing(bits) Then bits = 1
If bits < 0 Then bits = 0
bits = bits Mod 8
ir = a_0_255
For i = 1 To bits
If (ir Mod 2 > 0) Then
ir = (ir \ 2) + 128
Else
ir = ir \ 2
End If
Next
bool8_ror = ir
End Function
Jede verschiebung oder Rotation nach rechts entsprciht einer ganzzahligen Division durch 2.
Wenn das rechts heraus-rotierte Bit gesetzt war, dann wird sein neuer Wert (128) addiert.
Alle Funktionen dieses Kapitels arbeiten mit 8-Bit-Worten. Sie verwenden als Argumente a_0_255, b_0_255 positive ganze Zahlen aus dem Bereich 0...255 und liefern ebensolche Ergebnisse. • Mit etwas Geschick kann man die Funktionen für größere Wort-Breite adaptieren. Dazu wurden die entsprechenden Variablen mit dem Typ Long angelegt. Von einer allgemeinen Formulierung wurde abgesehen, weil die Funktionen dann weniger übersichtlich sind, und weil das über die hier beabsichtigte BitLevel Demonstration hinaus geht.

Swap (8 Bit)

Diese Funktion vertauscht die beiden Nibbles des 8-Bit Arguments:
Function bool8_swap(a_0_255 As Integer) As Integer
bool8_swap = (a_0_255 Mod 16) * 16 + a_0_255 \ 16
End Function

♦ Details zur Verwendung von Basic-Modulen

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Algorithmen   >   BitLevel   >   Kalkulation & Basic