Bitweiser Operator - Versionsgeschichte

Xenein: /* growthexperiments-addlink-summary-summary:3|0|0 */

2024-11-15T02:59:35Z

Linkvorschlag-Funktion: 3 Links hinzugefügt.

← Nächstältere Version		Version vom 15. November 2024, 04:59 Uhr
Zeile 123:		Zeile 123:
	Bei den ''bitweisen Verschiebungen'' (engl. ''{{lang\|en\|bitwise shift}}'') werden die Bits als einzelne Zeichen an einer bestimmten Bit-Position aufgefasst – und nicht als Paare korrespondierender Bits wie in den oben stehenden Operationen. Dabei bedeutet das Kollektiv der Bits bei der [[#Arithmetische Verschiebung\|arithmetischen Verschiebung]] eine Binärzahl oder bei der – etwas elementareren – [[#Logische Verschiebung\|logischen Verschiebung]] eine [[Bitkette]] (resp. eine vorzeichenlose (engl. ''{{lang\|en\|unsigned}}'') Binärzahl). Der Hauptunterschied besteht in der Behandlung des eventuellen Vorzeichenbits. Schaltungstechnisch können bitweise Verschiebungen und Rotationen um eine beliebige Stellenanzahl in Form von [[Barrel-Shifter]]n realisiert werden.		Bei den ''bitweisen Verschiebungen'' (engl. ''{{lang\|en\|bitwise shift}}'') werden die Bits als einzelne Zeichen an einer bestimmten Bit-Position aufgefasst – und nicht als Paare korrespondierender Bits wie in den oben stehenden Operationen. Dabei bedeutet das Kollektiv der Bits bei der [[#Arithmetische Verschiebung\|arithmetischen Verschiebung]] eine Binärzahl oder bei der – etwas elementareren – [[#Logische Verschiebung\|logischen Verschiebung]] eine [[Bitkette]] (resp. eine vorzeichenlose (engl. ''{{lang\|en\|unsigned}}'') Binärzahl). Der Hauptunterschied besteht in der Behandlung des eventuellen Vorzeichenbits. Schaltungstechnisch können bitweise Verschiebungen und Rotationen um eine beliebige Stellenanzahl in Form von [[Barrel-Shifter]]n realisiert werden.

	Bei diesen Operationen werden die Binär-Zeichen um eine angegebene Anzahl von Bitpositionen nach links oder rechts ''verschoben''. Die Richtungsangabe wird dabei unabhängig von der Rechnerarchitektur (und deren [[Byte-Reihenfolge\|Endianness]]) immer in der ''(big-endian)'' Standardkonvention des [[Dualsystem]]s verstanden: Links bedeutet Multiplikation und rechts Division mit einer Zweierpotenz. [[Register (Computer)\|Register]] der Prozessoren sowie Datentypen der Programmiersprachen beherbergen eine definierte endliche Anzahl von Bits, weshalb die spezifizierte Anzahl an Bits an einem Ende aus dem Register oder Datum „hinausgeschoben“, während die gleiche Anzahl am anderen Ende „hineingeschoben“ („hereingezogen“) wird.		Bei diesen Operationen werden die Binär-Zeichen um eine angegebene Anzahl von Bitpositionen nach links oder rechts ''verschoben''. Die Richtungsangabe wird dabei unabhängig von der [[Rechnerarchitektur]] (und deren [[Byte-Reihenfolge\|Endianness]]) immer in der ''(big-endian)'' Standardkonvention des [[Dualsystem]]s verstanden: Links bedeutet Multiplikation und rechts Division mit einer Zweierpotenz. [[Register (Computer)\|Register]] der Prozessoren sowie Datentypen der Programmiersprachen beherbergen eine definierte endliche Anzahl von Bits, weshalb die spezifizierte Anzahl an Bits an einem Ende aus dem Register oder Datum „hinausgeschoben“, während die gleiche Anzahl am anderen Ende „hineingeschoben“ („hereingezogen“) wird.

	Auf diese Weise induzieren die bitweisen Verschiebungsoperationen eine [[Bitwertigkeit#Adressierung von Bits\|Adressierung der Bits]] innerhalb eines Bytes.		Auf diese Weise induzieren die bitweisen Verschiebungsoperationen eine [[Bitwertigkeit#Adressierung von Bits\|Adressierung der Bits]] innerhalb eines Bytes.
Zeile 150:		Zeile 150:
	Dieses Verfahren stellt somit eine Alternative zur Multiplikation bzw. Division mit Zweierpotenzen dar. Divisionsergebnisse werden abgeschnitten. Ebenfalls ist es möglich, eine ''n''-Bit-Zahl modulo 2<sup>''k''</sup> zu rechnen, indem sie um jeweils ''n–k'' nach links und wieder nach rechts verschiebt. <!-- Das Ergebnis ist dann die Differenz zwischen der Ausgangszahl und dem Ergebnis der Verschiebungen. --> Etwas schneller noch kann man die modulo-Berechnung über das bitweise UND mit 2<sup>''k''</sup>–1 durchführen.		Dieses Verfahren stellt somit eine Alternative zur Multiplikation bzw. Division mit Zweierpotenzen dar. Divisionsergebnisse werden abgeschnitten. Ebenfalls ist es möglich, eine ''n''-Bit-Zahl modulo 2<sup>''k''</sup> zu rechnen, indem sie um jeweils ''n–k'' nach links und wieder nach rechts verschiebt. <!-- Das Ergebnis ist dann die Differenz zwischen der Ausgangszahl und dem Ergebnis der Verschiebungen. --> Etwas schneller noch kann man die modulo-Berechnung über das bitweise UND mit 2<sup>''k''</sup>–1 durchführen.

	Eine Verschiebung um 0 Bitpositionen ändert den Wert nicht (~~„identische~~ ~~Abbildung“~~). Ist für <math>m\ge 0,n\ge 0</math> die Verschiebung um <math>m+n</math> Bitpositionen definiert, dann gilt sowohl für (beidesmal) logische wie für (beidesmal) arithmetische Verschiebungen die „Hintereinanderausführung“:		Eine Verschiebung um 0 Bitpositionen ändert den Wert nicht („[[identische Abbildung]]“). Ist für <math>m\ge 0,n\ge 0</math> die Verschiebung um <math>m+n</math> Bitpositionen definiert, dann gilt sowohl für (beidesmal) logische wie für (beidesmal) arithmetische Verschiebungen die „Hintereinanderausführung“:
	((xyz) >> m) >> n = (xyz) >> (m+n) (signed und unsigned)		((xyz) >> m) >> n = (xyz) >> (m+n) (signed und unsigned)
	((xyz) << m) << n = (xyz) << (m+n) (signed und unsigned)		((xyz) << m) << n = (xyz) << (m+n) (signed und unsigned)
Zeile 162:		Zeile 162:
	\|}		\|}

	Bei einer ''logischen Verschiebung'' (engl. ''{{lang\|en\|logic shift}}'') werden die hinausgeschobenen Bits verworfen und Nullen nachgezogen, unabhängig von Schieberichtung und Vorzeichen. Deshalb sind logische und arithmetische Verschiebung nach links (bis auf die eventuelle Setzung von Flags) identische Operationen. Bei der logischen Verschiebung nach rechts werden jedoch Nullen statt Kopien des Vorzeichenbits eingefügt. Daher wird die logische Verschiebung bei Bitketten oder vorzeichenlosen Binärzahlen eingesetzt, während arithmetische Verschiebungen bei vorzeichenbehafteten Zweierkomplementzahlen verwendet werden.		Bei einer ''logischen Verschiebung'' (engl. ''{{lang\|en\|logic shift}}'') werden die hinausgeschobenen Bits verworfen und Nullen nachgezogen, unabhängig von Schieberichtung und Vorzeichen. Deshalb sind logische und arithmetische Verschiebung nach links (bis auf die eventuelle Setzung von Flags) identische Operationen. Bei der logischen Verschiebung nach rechts werden jedoch Nullen statt Kopien des Vorzeichenbits eingefügt. Daher wird die [[logische Verschiebung]] bei Bitketten oder vorzeichenlosen Binärzahlen eingesetzt, während arithmetische Verschiebungen bei vorzeichenbehafteten Zweierkomplementzahlen verwendet werden.
	<div style="clear:both;"></div>		<div style="clear:both;"></div>

MarcoMA8: /* C und C++ */ Defekter Weblink ersetzt

2024-11-10T04:27:23Z

C und C++: Defekter Weblink ersetzt

← Nächstältere Version		Version vom 10. November 2024, 06:27 Uhr
Zeile 217:		Zeile 217:
	weist der Variable <code>x</code> das Ergebnis der bitweisen Verschiebung von <code>y</code> um zwei Stellen nach links zu. Dies führt zum selben Ergebnis wie <code>x = y * 4</code>.		weist der Variable <code>x</code> das Ergebnis der bitweisen Verschiebung von <code>y</code> um zwei Stellen nach links zu. Dies führt zum selben Ergebnis wie <code>x = y * 4</code>.

	In C und C++ verwenden Berechnungen mit vorzeichenlosen Werten logische Verschiebungen; Berechnungen mit vorzeichenbehafteten Werten verhalten sich abhängig von der Implementierung (engl. ''{{lang\|en\|implementation-defined behavior}}''), sofern der rechte Operand negativ ist, durch einen Linksshift sich das Vorzeichen ändert oder ein negativer Wert einem Rechtsshift unterzogen wird.<ref>{{~~Webarchiv~~\|url=~~http~~://std.~~dkuug.dk~~/~~JTC1~~/~~SC22~~/~~WG14~~/www/docs/n843.htm \|~~wayback~~=~~20220803145528~~ \|~~text~~=~~ISO/IEC~~-~~Standard~~ „C ~~programming language“~~ \|~~archiv-bot~~=2024-07-~~29 15:21:26 InternetArchiveBot~~ }}~~, Abschnitt 6.5.7#5 (englisch)~~</ref>		In C und C++ verwenden Berechnungen mit vorzeichenlosen Werten logische Verschiebungen; Berechnungen mit vorzeichenbehafteten Werten verhalten sich abhängig von der Implementierung (engl. ''{{lang\|en\|implementation-defined behavior}}''), sofern der rechte Operand negativ ist, durch einen Linksshift sich das Vorzeichen ändert oder ein negativer Wert einem Rechtsshift unterzogen wird.<ref>{{Internetquelle \|url=https://www.open-std.org/jtc1/sc22/wg14/www/docs/n843.htm \|titel=JTC1/SC22/WG14 N843 \|werk=open-std.org \|datum=1998-08-03 \|sprache=en \|abruf=2024-11-10}}</ref>

	Ebenso ist das Ergebnis laut C- und C++-Sprachnorm ''undefiniert'', wenn die Anzahl der Bitverschiebungen größer oder gleich der Bitbreite der Rechenarchitektur ist.<ref>A7.8 Shift Operators, Appendix A. Reference Manual, The C Programming Language</ref> Wird beispielsweise auf einer 32-Bit-Architektur von Intel-Prozessoren gearbeitet (IA32), so bewirkt eine Verschiebung um 32 Stellen oft gar keine Veränderung des Ergebnisses, d. h. für <code>x = y << 32</code> ergibt sich <code>x == y</code>. Der Grund liegt in der Art und Weise, wie die Compiler die Schiebeoperation in Maschinencode umsetzen. Die meisten Prozessoren haben direkte Befehle zum Schieben von Bits, wobei die Anzahl der Verschiebungen nur in begrenzter Breite im Maschinenbefehl codiert wird. Für IA32 sind z. B. 5 Bitstellen vorgesehen, um die Zahl der Verschiebungen abzulegen.<ref>SAL,SAR,SHL,SHR – Shift, Chapter 4. Instruction Set Reference, IA-32 Intel Architecture Software Developer’s Manual</ref> Daher können nur Verschiebungen im Bereich 0 bis 31 korrekt ausgeführt werden. Entsprechende Beschränkungen können für andere Architekturen und Datentypen ebenso vorhanden sein.		Ebenso ist das Ergebnis laut C- und C++-Sprachnorm ''undefiniert'', wenn die Anzahl der Bitverschiebungen größer oder gleich der Bitbreite der Rechenarchitektur ist.<ref>A7.8 Shift Operators, Appendix A. Reference Manual, The C Programming Language</ref> Wird beispielsweise auf einer 32-Bit-Architektur von Intel-Prozessoren gearbeitet (IA32), so bewirkt eine Verschiebung um 32 Stellen oft gar keine Veränderung des Ergebnisses, d. h. für <code>x = y << 32</code> ergibt sich <code>x == y</code>. Der Grund liegt in der Art und Weise, wie die Compiler die Schiebeoperation in Maschinencode umsetzen. Die meisten Prozessoren haben direkte Befehle zum Schieben von Bits, wobei die Anzahl der Verschiebungen nur in begrenzter Breite im Maschinenbefehl codiert wird. Für IA32 sind z. B. 5 Bitstellen vorgesehen, um die Zahl der Verschiebungen abzulegen.<ref>SAL,SAR,SHL,SHR – Shift, Chapter 4. Instruction Set Reference, IA-32 Intel Architecture Software Developer’s Manual</ref> Daher können nur Verschiebungen im Bereich 0 bis 31 korrekt ausgeführt werden. Entsprechende Beschränkungen können für andere Architekturen und Datentypen ebenso vorhanden sein.

InternetArchiveBot: InternetArchiveBot hat 1 Archivlink(s) ergänzt und 0 Link(s) als defekt/tot markiert.) #IABot (v2.0.9.5

2024-07-29T15:21:26Z

InternetArchiveBot hat 1 Archivlink(s) ergänzt und 0 Link(s) als defekt/tot markiert.) #IABot (v2.0.9.5

← Nächstältere Version		Version vom 29. Juli 2024, 17:21 Uhr
Zeile 217:		Zeile 217:
	weist der Variable <code>x</code> das Ergebnis der bitweisen Verschiebung von <code>y</code> um zwei Stellen nach links zu. Dies führt zum selben Ergebnis wie <code>x = y * 4</code>.		weist der Variable <code>x</code> das Ergebnis der bitweisen Verschiebung von <code>y</code> um zwei Stellen nach links zu. Dies führt zum selben Ergebnis wie <code>x = y * 4</code>.

	In C und C++ verwenden Berechnungen mit vorzeichenlosen Werten logische Verschiebungen; Berechnungen mit vorzeichenbehafteten Werten verhalten sich abhängig von der Implementierung (engl. ''{{lang\|en\|implementation-defined behavior}}''), sofern der rechte Operand negativ ist, durch einen Linksshift sich das Vorzeichen ändert oder ein negativer Wert einem Rechtsshift unterzogen wird.<ref>[http://std.dkuug.dk/JTC1/SC22/WG14/www/docs/n843.htm ISO/IEC-Standard „C programming language“], Abschnitt 6.5.7#5 (englisch)</ref>		In C und C++ verwenden Berechnungen mit vorzeichenlosen Werten logische Verschiebungen; Berechnungen mit vorzeichenbehafteten Werten verhalten sich abhängig von der Implementierung (engl. ''{{lang\|en\|implementation-defined behavior}}''), sofern der rechte Operand negativ ist, durch einen Linksshift sich das Vorzeichen ändert oder ein negativer Wert einem Rechtsshift unterzogen wird.<ref>{{Webarchiv\|url=http://std.dkuug.dk/JTC1/SC22/WG14/www/docs/n843.htm \|wayback=20220803145528 \|text=ISO/IEC-Standard „C programming language“ \|archiv-bot=2024-07-29 15:21:26 InternetArchiveBot }}, Abschnitt 6.5.7#5 (englisch)</ref>

	Ebenso ist das Ergebnis laut C- und C++-Sprachnorm ''undefiniert'', wenn die Anzahl der Bitverschiebungen größer oder gleich der Bitbreite der Rechenarchitektur ist.<ref>A7.8 Shift Operators, Appendix A. Reference Manual, The C Programming Language</ref> Wird beispielsweise auf einer 32-Bit-Architektur von Intel-Prozessoren gearbeitet (IA32), so bewirkt eine Verschiebung um 32 Stellen oft gar keine Veränderung des Ergebnisses, d. h. für <code>x = y << 32</code> ergibt sich <code>x == y</code>. Der Grund liegt in der Art und Weise, wie die Compiler die Schiebeoperation in Maschinencode umsetzen. Die meisten Prozessoren haben direkte Befehle zum Schieben von Bits, wobei die Anzahl der Verschiebungen nur in begrenzter Breite im Maschinenbefehl codiert wird. Für IA32 sind z. B. 5 Bitstellen vorgesehen, um die Zahl der Verschiebungen abzulegen.<ref>SAL,SAR,SHL,SHR – Shift, Chapter 4. Instruction Set Reference, IA-32 Intel Architecture Software Developer’s Manual</ref> Daher können nur Verschiebungen im Bereich 0 bis 31 korrekt ausgeführt werden. Entsprechende Beschränkungen können für andere Architekturen und Datentypen ebenso vorhanden sein.		Ebenso ist das Ergebnis laut C- und C++-Sprachnorm ''undefiniert'', wenn die Anzahl der Bitverschiebungen größer oder gleich der Bitbreite der Rechenarchitektur ist.<ref>A7.8 Shift Operators, Appendix A. Reference Manual, The C Programming Language</ref> Wird beispielsweise auf einer 32-Bit-Architektur von Intel-Prozessoren gearbeitet (IA32), so bewirkt eine Verschiebung um 32 Stellen oft gar keine Veränderung des Ergebnisses, d. h. für <code>x = y << 32</code> ergibt sich <code>x == y</code>. Der Grund liegt in der Art und Weise, wie die Compiler die Schiebeoperation in Maschinencode umsetzen. Die meisten Prozessoren haben direkte Befehle zum Schieben von Bits, wobei die Anzahl der Verschiebungen nur in begrenzter Breite im Maschinenbefehl codiert wird. Für IA32 sind z. B. 5 Bitstellen vorgesehen, um die Zahl der Verschiebungen abzulegen.<ref>SAL,SAR,SHL,SHR – Shift, Chapter 4. Instruction Set Reference, IA-32 Intel Architecture Software Developer’s Manual</ref> Daher können nur Verschiebungen im Bereich 0 bis 31 korrekt ausgeführt werden. Entsprechende Beschränkungen können für andere Architekturen und Datentypen ebenso vorhanden sein.

Nomen4Omen: Tippfehler

2024-01-27T11:22:18Z

Tippfehler

← Nächstältere Version		Version vom 27. Januar 2024, 13:22 Uhr
Zeile 1:		Zeile 1:
	In der [[Informatik]] ist ein '''bitweiser Operator''' ein [[Operator (Mathematik)\|Operator]], der auf ein oder zwei [[Bitkette]]n, [[Bitfeld]]ern, Bitfolgen oder Bitvektoren auf der Ebene der einzelnen [[Bit]]s angewendet wird. Insbesondere in den Programmiersprachen der [[C (Programmiersprache)\|C]]-Familie können [[Dualsystem\|Binärzahlen]] ohne weitere [[Syntax#Syntax formaler Sprachen\|syntaktische]] Kennzeichnung als Bitfolgen aufgefasst werden.		In der [[Informatik]] ist ein '''bitweiser Operator''' ein [[Operator (Mathematik)\|Operator]], der auf ein oder zwei [[Bitkette]]n, [[Bitfeld]]ern, Bitfolgen oder Bitvektoren auf der Ebene der einzelnen [[Bit]]s angewendet wird. Insbesondere in den Programmiersprachen der [[C (Programmiersprache)\|C]]-Familie können [[Dualsystem\|Binärzahlen]] ohne weitere [[Syntax#Syntax formaler Sprachen\|syntaktische]] Kennzeichnung als Bitfolgen aufgefasst werden.

	Die zugrundeliegenden Operationen auf den einzelnen Bits sind [[Logikgatter\|schaltungstechnisch]] die allereinfachsten, und alle höheren Operationen lassen sich auf sie ~~zurücxkführen~~. Die ''bitweisen'' Operationen werden wegen ihrer geringeren Bedeutung für die Geschwindigkeit eines Computersystems jedoch meist weniger durch Optimierung bevorzugt als die komplexeren arithmetischen Operationen wie Addition und Subtraktion.		Die zugrundeliegenden Operationen auf den einzelnen Bits sind [[Logikgatter\|schaltungstechnisch]] die allereinfachsten, und alle höheren Operationen lassen sich auf sie zurückführen. Die ''bitweisen'' Operationen werden wegen ihrer geringeren Bedeutung für die Geschwindigkeit eines Computersystems jedoch meist weniger durch Optimierung bevorzugt als die komplexeren arithmetischen Operationen wie Addition und Subtraktion.

	== Bitweise Operatoren ==		== Bitweise Operatoren ==

Pemu am 27. Januar 2024 um 00:29 Uhr

2024-01-27T00:29:14Z

← Nächstältere Version		Version vom 27. Januar 2024, 02:29 Uhr
Zeile 1:		Zeile 1:
	In der [[Informatik]] ist ein '''bitweiser Operator''' ein [[Operator (Mathematik)\|Operator]], der auf ein oder zwei [[Bitkette]]n, [[Bitfeld]]ern, Bitfolgen oder Bitvektoren auf der Ebene der einzelnen [[Bit]]s angewendet wird. Insbesondere in den Programmiersprachen der [[C (Programmiersprache)\|C]]-Familie können [[Dualsystem\|Binärzahlen]] ohne weitere [[Syntax#Syntax formaler Sprachen\|syntaktische]] Kennzeichnung als Bitfolgen aufgefasst werden.		In der [[Informatik]] ist ein '''bitweiser Operator''' ein [[Operator (Mathematik)\|Operator]], der auf ein oder zwei [[Bitkette]]n, [[Bitfeld]]ern, Bitfolgen oder Bitvektoren auf der Ebene der einzelnen [[Bit]]s angewendet wird. Insbesondere in den Programmiersprachen der [[C (Programmiersprache)\|C]]-Familie können [[Dualsystem\|Binärzahlen]] ohne weitere [[Syntax#Syntax formaler Sprachen\|syntaktische]] Kennzeichnung als Bitfolgen aufgefasst werden.

	Die ~~zugrunde liegenden~~ Operationen auf den einzelnen Bits sind [[Logikgatter\|schaltungstechnisch]] die allereinfachsten, und alle höheren Operationen lassen sich auf sie ~~zurückführen~~. Die ''bitweisen'' Operationen werden wegen ihrer geringeren Bedeutung für die Geschwindigkeit eines Computersystems jedoch meist weniger durch Optimierung bevorzugt als die komplexeren arithmetischen Operationen wie Addition und Subtraktion.		Die zugrundeliegenden Operationen auf den einzelnen Bits sind [[Logikgatter\|schaltungstechnisch]] die allereinfachsten, und alle höheren Operationen lassen sich auf sie zurücxkführen. Die ''bitweisen'' Operationen werden wegen ihrer geringeren Bedeutung für die Geschwindigkeit eines Computersystems jedoch meist weniger durch Optimierung bevorzugt als die komplexeren arithmetischen Operationen wie Addition und Subtraktion.

	== Bitweise Operatoren ==		== Bitweise Operatoren ==

Hutch: Abschnittlink korrigiert

2023-11-23T06:03:42Z

Abschnittlink korrigiert

← Nächstältere Version		Version vom 23. November 2023, 08:03 Uhr
Zeile 29:		Zeile 29:
	=== UND ===		=== UND ===
	[[Datei:0...15 AND.svg\|mini\|Bitweises [[Konjunktion (Logik)\|UND]] von 4 [[Bit]]]]		[[Datei:0...15 AND.svg\|mini\|Bitweises [[Konjunktion (Logik)\|UND]] von 4 [[Bit]]]]

	Das ''bitweise UND'' wird auf zwei Bitfolgen gleicher Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es jeweils Bits an der gleichen Stelle (jeweils das erste Bit, jeweils das zweite Bit usw.) mit einem logischen UND ([[Konjunktion (Logik)\|logische Konjunktion]]) verknüpft. Bei jedem Paar ist das Ergebnisbit <code>1</code>, falls beide Bits <code>1</code> sind, ansonsten <code>0</code>. Beispiel:		Das ''bitweise UND'' wird auf zwei Bitfolgen gleicher Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es jeweils Bits an der gleichen Stelle (jeweils das erste Bit, jeweils das zweite Bit usw.) mit einem logischen UND ([[Konjunktion (Logik)\|logische Konjunktion]]) verknüpft. Bei jedem Paar ist das Ergebnisbit <code>1</code>, falls beide Bits <code>1</code> sind, ansonsten <code>0</code>. Beispiel:

Zeile 75:		Zeile 76:
	=== ODER ===		=== ODER ===
	[[Datei:0...15 OR.svg\|mini\|Bitweises [[ODER]] von 4 [[Bit]]]]		[[Datei:0...15 OR.svg\|mini\|Bitweises [[ODER]] von 4 [[Bit]]]]

	Das ''bitweise ODER'' wird auf zwei Bitfolgen gleicher Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es jeweils Bits an der gleichen Stelle mit einem logischen ODER (logische [[Disjunktion]]) verknüpft. Bei jedem Paar ist das Ergebnisbit <code>0</code>, falls beide Bits <code>0</code> sind, ansonsten ist das Ergebnisbit <code>1</code>. Beispiel:		Das ''bitweise ODER'' wird auf zwei Bitfolgen gleicher Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es jeweils Bits an der gleichen Stelle mit einem logischen ODER (logische [[Disjunktion]]) verknüpft. Bei jedem Paar ist das Ergebnisbit <code>0</code>, falls beide Bits <code>0</code> sind, ansonsten ist das Ergebnisbit <code>1</code>. Beispiel:

Zeile 97:		Zeile 99:
	=== XOR ===		=== XOR ===
	[[Datei:Z2^4; Cayley table; binary.svg\|mini\|Bitweises [[Exklusives Oder\|exklusives ODER]] von 4 [[Bit]]]]		[[Datei:Z2^4; Cayley table; binary.svg\|mini\|Bitweises [[Exklusives Oder\|exklusives ODER]] von 4 [[Bit]]]]

	Das ''bitweise exklusive ODER'' wird auf zwei Bitfolgen der gleichen Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es die logische [[XOR]]-Operation auf jedem Paar korrespondierender Bits durchführt. Das Ergebnisbit ist <code>1</code>, falls die zwei Bits unterschiedlich sind, und <code>0</code>, falls sie gleich sind. Beispiel:		Das ''bitweise exklusive ODER'' wird auf zwei Bitfolgen der gleichen Länge angewendet und gibt eine Bitfolge derselben Länge zurück, indem es die logische [[XOR]]-Operation auf jedem Paar korrespondierender Bits durchführt. Das Ergebnisbit ist <code>1</code>, falls die zwei Bits unterschiedlich sind, und <code>0</code>, falls sie gleich sind. Beispiel:

Zeile 118:		Zeile 121:

	== Bitweise Verschiebungen ==		== Bitweise Verschiebungen ==

	Bei den ''bitweisen Verschiebungen'' (engl. ''{{lang\|en\|bitwise shift}}'') werden die Bits als einzelne Zeichen an einer bestimmten Bit-Position aufgefasst – und nicht als Paare korrespondierender Bits wie in den oben stehenden Operationen. Dabei bedeutet das Kollektiv der Bits bei der [[#Arithmetische Verschiebung\|arithmetischen Verschiebung]] eine Binärzahl oder bei der – etwas elementareren – [[#Logische Verschiebung\|logischen Verschiebung]] eine [[Bitkette]] (resp. eine vorzeichenlose (engl. ''{{lang\|en\|unsigned}}'') Binärzahl). Der Hauptunterschied besteht in der Behandlung des eventuellen Vorzeichenbits. Schaltungstechnisch können bitweise Verschiebungen und Rotationen um eine beliebige Stellenanzahl in Form von [[Barrel-Shifter]]n realisiert werden.		Bei den ''bitweisen Verschiebungen'' (engl. ''{{lang\|en\|bitwise shift}}'') werden die Bits als einzelne Zeichen an einer bestimmten Bit-Position aufgefasst – und nicht als Paare korrespondierender Bits wie in den oben stehenden Operationen. Dabei bedeutet das Kollektiv der Bits bei der [[#Arithmetische Verschiebung\|arithmetischen Verschiebung]] eine Binärzahl oder bei der – etwas elementareren – [[#Logische Verschiebung\|logischen Verschiebung]] eine [[Bitkette]] (resp. eine vorzeichenlose (engl. ''{{lang\|en\|unsigned}}'') Binärzahl). Der Hauptunterschied besteht in der Behandlung des eventuellen Vorzeichenbits. Schaltungstechnisch können bitweise Verschiebungen und Rotationen um eine beliebige Stellenanzahl in Form von [[Barrel-Shifter]]n realisiert werden.

Zeile 168:		Zeile 170:
	\| [[Datei:Rotate left logically.svg\|mini\|Arithmetischer Linksshift]]		\| [[Datei:Rotate left logically.svg\|mini\|Arithmetischer Linksshift]]
	\|}		\|}

	Im Gegensatz zur logischen Verschiebung hat bei der ''arithmetischen'' (manchmal auch ''algebraischen'') ''Verschiebung'' (engl. ''{{lang\|en\|arithmetic shift}}'') das höchstwertige Bit die Rolle des Vorzeichens (in der Darstellung als [[Zweierkomplement]]). Der zugrunde liegende Datentyp ist die vorzeichenbehaftete (<code>signed</code>) binäre Ganzzahl, für die der Compiler den arithmetischen Shift generiert. Hinausgeschobene Bits gehen verloren. Bei einer Verschiebung nach rechts werden Kopien des Vorzeichenbits an der Vorzeichenstelle eingeschoben (engl. ''{{lang\|en\|sign propagation}}''); bei einer Verschiebung nach links werden auf der rechten Seite Nullen nachgezogen. Beispiel (4-Bit-Register):		Im Gegensatz zur logischen Verschiebung hat bei der ''arithmetischen'' (manchmal auch ''algebraischen'') ''Verschiebung'' (engl. ''{{lang\|en\|arithmetic shift}}'') das höchstwertige Bit die Rolle des Vorzeichens (in der Darstellung als [[Zweierkomplement]]). Der zugrunde liegende Datentyp ist die vorzeichenbehaftete (<code>signed</code>) binäre Ganzzahl, für die der Compiler den arithmetischen Shift generiert. Hinausgeschobene Bits gehen verloren. Bei einer Verschiebung nach rechts werden Kopien des Vorzeichenbits an der Vorzeichenstelle eingeschoben (engl. ''{{lang\|en\|sign propagation}}''); bei einer Verschiebung nach links werden auf der rechten Seite Nullen nachgezogen. Beispiel (4-Bit-Register):

Zeile 176:		Zeile 179:
	= 1100		= 1100

	Bei der Rechtsverschiebung wird das niedrigstwertige (das in der konventionellen Binärdarstellung am weitesten „rechts“ stehende, das Einer-) Bit hinausgeschoben und das [[Bitwertigkeit#~~Bit-Reihenfolge~~\|höchstwertige Bit]] (MSB), das „Vorzeichenbit“, am hochwertigen („linken“) Ende erneut eingefügt, wodurch das Vorzeichen der Zahl erhalten bleibt. Bei der Linksverschiebung wird eine neue <code>0</code> am niedrigwertigen („rechten“) Ende eingefügt und das höchstwertige Bit aus dem Register hinausgeschoben. Ist das neue Vorzeichenbit verschieden vom zuletzt hinausgeschobenen (wechselt also das Vorzeichen beim letzten Schiebevorgang), dann wird in vielen Rechnerfamilien das [[Übertragsbit\|Überlauf- oder Carry-Flag]] gesetzt, andernfalls gelöscht.		Bei der Rechtsverschiebung wird das niedrigstwertige (das in der konventionellen Binärdarstellung am weitesten „rechts“ stehende, das Einer-) Bit hinausgeschoben und das [[Bitwertigkeit#Bitreihenfolge\|höchstwertige Bit]] (MSB), das „Vorzeichenbit“, am hochwertigen („linken“) Ende erneut eingefügt, wodurch das Vorzeichen der Zahl erhalten bleibt. Bei der Linksverschiebung wird eine neue <code>0</code> am niedrigwertigen („rechten“) Ende eingefügt und das höchstwertige Bit aus dem Register hinausgeschoben. Ist das neue Vorzeichenbit verschieden vom zuletzt hinausgeschobenen (wechselt also das Vorzeichen beim letzten Schiebevorgang), dann wird in vielen Rechnerfamilien das [[Übertragsbit\|Überlauf- oder Carry-Flag]] gesetzt, andernfalls gelöscht.

	Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach links ist äquivalent zu einer Multiplikation mit <math>2^{n}</math> (sofern kein Überlauf auftritt). Eine arithmetische Verschiebung einer vorzeichenbehafteten (<code>signed</code>) Binärzahl ([[Zweierkomplement]]zahl) um <math>n</math> nach rechts entspricht einer ganzzahligen Division durch <math>2^{n}</math> mit Rundung auf die nächstkleinere Zahl – Beispiele: <code>1>>1 == 1>>31 == 0</code> und <code>(-1)>>1 == (-1)>>31 == -1</code>.		Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach links ist äquivalent zu einer Multiplikation mit <math>2^{n}</math> (sofern kein Überlauf auftritt). Eine arithmetische Verschiebung einer vorzeichenbehafteten (<code>signed</code>) Binärzahl ([[Zweierkomplement]]zahl) um <math>n</math> nach rechts entspricht einer ganzzahligen Division durch <math>2^{n}</math> mit Rundung auf die nächstkleinere Zahl – Beispiele: <code>1>>1 == 1>>31 == 0</code> und <code>(-1)>>1 == (-1)>>31 == -1</code>.
Zeile 182:		Zeile 185:

	=== Zyklische Verschiebung ===		=== Zyklische Verschiebung ===

	==== Zyklische Verschiebung ohne Übertragsbit ====		==== Zyklische Verschiebung ohne Übertragsbit ====
	{\| class="float-right"		{\| class="float-right"

Redeemer: /* Bitweise Verschiebungen */ Das Herausschieben von Bits hat einen Namen, insbesondere wenn es wie im beschriebenen Fall eigentlich eine mathematische Operation abbilden sollte.

2023-02-06T22:33:47Z

Bitweise Verschiebungen: Das Herausschieben von Bits hat einen Namen, insbesondere wenn es wie im beschriebenen Fall eigentlich eine mathematische Operation abbilden sollte.

← Nächstältere Version		Version vom 7. Februar 2023, 00:33 Uhr
Zeile 142:		Zeile 142:
	01001111 >>> 1 = 00100111 (signed und unsigned)		01001111 >>> 1 = 00100111 (signed und unsigned)

	Eine logische (oder arithmetische) Verschiebung um <math>n</math> (Bitpositionen) nach ''links'' ist äquivalent zu einer Multiplikation mit <math>2^{n}</math>, sofern keine 1-Bits hinaus- (bzw. in die Vorzeichenposition hinein)geschoben werden. Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach ''rechts'' ist äquivalent zu einer Division durch <math>2^{n}</math>; hinausgeschobene 1-Bits gehen verloren.		Eine logische (oder arithmetische) Verschiebung um <math>n</math> (Bitpositionen) nach ''links'' ist äquivalent zu einer Multiplikation mit <math>2^{n}</math>, sofern keine 1-Bits hinaus- (bzw. in die Vorzeichenposition hinein)geschoben werden ([[Ganzzahlüberlauf]]). Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach ''rechts'' ist äquivalent zu einer Division durch <math>2^{n}</math>; hinausgeschobene 1-Bits gehen verloren.

	<math>\mathrm{12_{10} = }</math><span style="font-family:monospace;">00001100 << 2 = 00110000</span><math>\mathrm{ = 48_{10} = 12 \cdot 2^{2} = 12 \cdot 4}</math>		<math>\mathrm{12_{10} = }</math><span style="font-family:monospace;">00001100 << 2 = 00110000</span><math>\mathrm{ = 48_{10} = 12 \cdot 2^{2} = 12 \cdot 4}</math>

TaxonBot: Bot: Überarbeitung veralteter Syntax / HTML-Validierung

2021-04-10T11:34:52Z

Bot: Überarbeitung veralteter Syntax / HTML-Validierung

← Nächstältere Version		Version vom 10. April 2021, 13:34 Uhr
Zeile 144:		Zeile 144:
	Eine logische (oder arithmetische) Verschiebung um <math>n</math> (Bitpositionen) nach ''links'' ist äquivalent zu einer Multiplikation mit <math>2^{n}</math>, sofern keine 1-Bits hinaus- (bzw. in die Vorzeichenposition hinein)geschoben werden. Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach ''rechts'' ist äquivalent zu einer Division durch <math>2^{n}</math>; hinausgeschobene 1-Bits gehen verloren.		Eine logische (oder arithmetische) Verschiebung um <math>n</math> (Bitpositionen) nach ''links'' ist äquivalent zu einer Multiplikation mit <math>2^{n}</math>, sofern keine 1-Bits hinaus- (bzw. in die Vorzeichenposition hinein)geschoben werden. Eine arithmetische Verschiebung um <math>n</math> (Bitpositionen) nach ''rechts'' ist äquivalent zu einer Division durch <math>2^{n}</math>; hinausgeschobene 1-Bits gehen verloren.

	<math>\mathrm{12_{10} = }</math><tt>00001100 << 2 = 00110000</tt><math>\mathrm{ = 48_{10} = 12 \cdot 2^{2} = 12 \cdot 4}</math>		<math>\mathrm{12_{10} = }</math><span style="font-family:monospace;">00001100 << 2 = 00110000</span><math>\mathrm{ = 48_{10} = 12 \cdot 2^{2} = 12 \cdot 4}</math>

	Dieses Verfahren stellt somit eine Alternative zur Multiplikation bzw. Division mit Zweierpotenzen dar. Divisionsergebnisse werden abgeschnitten. Ebenfalls ist es möglich, eine ''n''-Bit-Zahl modulo 2<sup>''k''</sup> zu rechnen, indem sie um jeweils ''n–k'' nach links und wieder nach rechts verschiebt. <!-- Das Ergebnis ist dann die Differenz zwischen der Ausgangszahl und dem Ergebnis der Verschiebungen. --> Etwas schneller noch kann man die modulo-Berechnung über das bitweise UND mit 2<sup>''k''</sup>–1 durchführen.		Dieses Verfahren stellt somit eine Alternative zur Multiplikation bzw. Division mit Zweierpotenzen dar. Divisionsergebnisse werden abgeschnitten. Ebenfalls ist es möglich, eine ''n''-Bit-Zahl modulo 2<sup>''k''</sup> zu rechnen, indem sie um jeweils ''n–k'' nach links und wieder nach rechts verschiebt. <!-- Das Ergebnis ist dann die Differenz zwischen der Ausgangszahl und dem Ergebnis der Verschiebungen. --> Etwas schneller noch kann man die modulo-Berechnung über das bitweise UND mit 2<sup>''k''</sup>–1 durchführen.

Ot: Änderungen von 91.64.159.119 (Diskussion) auf die letzte Version von Nomen4Omen zurückgesetzt

2020-12-01T07:35:54Z

Änderungen von 91.64.159.119 (Diskussion) auf die letzte Version von Nomen4Omen zurückgesetzt

← Nächstältere Version		Version vom 1. Dezember 2020, 09:35 Uhr
Zeile 9:		Zeile 9:

	=== NICHT ===		=== NICHT ===
	~~nicht~~ ist eine ~~synaktische~~ ~~sprache~~ die ~~von~~ ~~der~~ ~~bildung~~ dann ist dies die Bildung des [[Einerkomplement]]s. Jede <code>0</code> wird durch eine <code>1</code> ausgetauscht und umgekehrt. Beispiel:		Das ''bitweise NICHT'' oder ''Komplement'' ist eine [[einstellige Verknüpfung]], die eine logische [[Negation]] (Inversion) jedes Bits durchführt. Wird die Bitfolge als Binärzahl aufgefasst, dann ist dies die Bildung des [[Einerkomplement]]s. Jede <code>0</code> wird durch eine <code>1</code> ausgetauscht und umgekehrt. Beispiel:

	NICHT 0111		NICHT 0111

91.64.159.119: /* Bitweise Operatoren */

2020-12-01T07:33:48Z

Bitweise Operatoren

← Nächstältere Version		Version vom 1. Dezember 2020, 09:33 Uhr
Zeile 9:		Zeile 9:

	=== NICHT ===		=== NICHT ===
	~~Das ''bitweise NICHT'' oder ''Komplement''~~ ist eine ~~[[einstellige Verknüpfung]], die eine logische [[Negation]] (Inversion) jedes Bits durchführt.~~ ~~Wird~~ die ~~Bitfolge~~ ~~als~~ ~~Binärzahl~~ ~~aufgefasst,~~ dann ist dies die Bildung des [[Einerkomplement]]s. Jede <code>0</code> wird durch eine <code>1</code> ausgetauscht und umgekehrt. Beispiel:		nicht ist eine synaktische sprache die von der bildung dann ist dies die Bildung des [[Einerkomplement]]s. Jede <code>0</code> wird durch eine <code>1</code> ausgetauscht und umgekehrt. Beispiel:

	NICHT 0111		NICHT 0111