Bitwise Operator - Revision history

Iwiseman: /* 3. Bit Rotation Operators */

2026-04-18T01:36:16Z

3. Bit Rotation Operators

@@ Line 209: / Line 209: @@
    result = 0b1011
-Note: Rust, C# (BitOperations), and C++20 (std::rotl/rotr) provide built‑in rotate functions.
+Note: Rust, C# (BitOperations), and C++20 (std::rotl/rotr) provide built‑in rotate functions.<br>
 = Language Support Table =

Iwiseman: /* 3. Bit Rotation Operators */

2026-04-18T00:47:39Z

3. Bit Rotation Operators

← Older revision		Revision as of 00:47, 18 April 2026
Line 190:		Line 190:

	== 3. Bit Rotation Operators ==		== 3. Bit Rotation Operators ==

			Bit rotation moves bits around in a loop.
			Bits that fall off one end are wrapped around to the other end in the same order they fell off.

	; Rotate Left (ROL)		; Rotate Left (ROL)
	: ROL(0b1001, 1) = 0b0011		: ROL(0b1001, 1) = 0b0011
			: (the leftmost bit '1' drops off and reappears on the right)

	; Rotate Right (ROR)		; Rotate Right (ROR)
	: ROR(0b1001, 1) = 0b1100		: ROR(0b1001, 1) = 0b1100
			: (the rightmost bit '1' drops off and reappears on the left)

			'''Ordering rule:'''
			If multiple bits drop off, they are placed on the opposite end in the same order.
			Example:
			ROR(0b1110, 2)
			rightmost bits '10' drop off → reappear on the left as '10'
			result = 0b1011

	Note: ~~Only~~ Rust, C++20~~, and C#~~ provide built‑in rotate functions.		Note: Rust, C# (BitOperations), and C++20 (std::rotl/rotr) provide built‑in rotate functions.

	= Language Support Table =		= Language Support Table =

Iwiseman: /* Two's Compliment */

2026-04-18T00:40:19Z

Two's Compliment

← Older revision		Revision as of 00:40, 18 April 2026
Line 4:		Line 4:
	This is a mysterious word, but like decimal is a way to store numbers, Two's Compliment is a way to signed integers.<br>		This is a mysterious word, but like decimal is a way to store numbers, Two's Compliment is a way to signed integers.<br>
	<br>		<br>
	In this system, the ~~MSB acts as the sign bit~~:		In this system we
	~~0 = positive,~~ 1 ~~= negative.~~		*Take the binary for +N
			*Invert all bits
			*Add 1
			So here is an example<br>
			Step 1: +10
			0000000000001010
			Step 2: Invert
			1111111111110101
			Step 3: add 1
			1111111111110101
			+1
			----------------
			1111111111110110

	= Signed vs Unsigned Values =		= Signed vs Unsigned Values =

Iwiseman: /* Logical Right Shift in C and C++ */

2026-04-18T00:34:46Z

Logical Right Shift in C and C++

← Older revision		Revision as of 00:34, 18 April 2026
Line 147:		Line 147:

	int main() {		int main() {
	int i = -10;		int i = -10;

	cout << "i dec : " << i << endl;		cout << "i dec : " << i << endl;
	~~std::~~cout << "i bin : " << ~~std::~~bitset<8>(i) << ~~std::~~endl;		cout << "i bin : " << bitset<32>(i) << endl;

	int y = i >> 1;		int y = i >> 1;

	cout << "C++ Arithmetic right shift" << endl;		cout << "\nC++ Arithmetic right shift" << endl;
	cout << "y dec : " << y << endl;		cout << "y dec : " << y << endl;
	~~std::~~cout << "y bin : " << ~~std::~~bitset<8>(y) << ~~std::~~endl;		cout << "y bin : " << bitset<32>(y) << endl;

	unsigned x = (unsigned)i >> 1;		unsigned x = (unsigned)i >> 1;

	cout << "~~Fake~~ C++ logical right shift to unsigned" << endl;		cout << "\nFake C++ logical right shift to unsigned" << endl;
	cout << "x dec : " << x << endl;		cout << "x dec : " << x << endl;
	~~std::~~cout << "x bin : " << ~~std::~~bitset<8>(x) << ~~std::~~endl;		cout << "x bin : " << bitset<32>(x) << endl;
	}		}
	</Syntaxhighlight>		</Syntaxhighlight>
	And the output was		And the output was
	i dec : -10		i dec : -10
	i bin : ~~11110110~~		i bin : 11111111111111111111111111110110
	C++ Arithmetic right shift
			C++ Arithmetic right shift
	y dec : -5		y dec : -5
	y bin : ~~11111011~~		y bin : 11111111111111111111111111111011
	Fake C++ logical right shift to unsigned
	x dec : 2147483643		Fake C++ logical right shift to unsigned
	x bin : ~~11111011~~		x dec : 2147483643
			x bin : 01111111111111111111111111111011

	== 3. Bit Rotation Operators ==		== 3. Bit Rotation Operators ==

Iwiseman: /* 2. Bitwise Shift Operators */

2026-04-18T00:15:04Z

2. Bitwise Shift Operators

← Older revision		Revision as of 00:15, 18 April 2026
Line 138:		Line 138:

	int x = i >> 1; // arithmetic shift, sign bit copied		int x = i >> 1; // arithmetic shift, sign bit copied

			Wanted to make logical shift really clear to wrote
			<Syntaxhighlight lang="c++">
			#include <iostream>
			#include <bitset>

			using namespace std;

			int main() {
			int i = -10;

			cout << "i dec : " << i << endl;
			std::cout << "i bin : " << std::bitset<8>(i) << std::endl;

			int y = i >> 1;

			cout << "C++ Arithmetic right shift" << endl;
			cout << "y dec : " << y << endl;
			std::cout << "y bin : " << std::bitset<8>(y) << std::endl;

			unsigned x = (unsigned)i >> 1;

			cout << "Fake C++ logical right shift to unsigned" << endl;
			cout << "x dec : " << x << endl;
			std::cout << "x bin : " << std::bitset<8>(x) << std::endl;
			}
			</Syntaxhighlight>
			And the output was
			i dec : -10
			i bin : 11110110
			C++ Arithmetic right shift

			y dec : -5
			y bin : 11111011
			Fake C++ logical right shift to unsigned
			x dec : 2147483643
			x bin : 11111011

	== 3. Bit Rotation Operators ==		== 3. Bit Rotation Operators ==

Iwiseman: /* Logical Right Shift ( >>> ) */

2026-04-17T23:57:05Z

Logical Right Shift ( >>> )

← Older revision		Revision as of 23:57, 17 April 2026
Line 120:		Line 120:
	1110 1000 >>> 3 = 0001 1101		1110 1000 >>> 3 = 0001 1101

	Only available in TypeScript/JavaScript. ~~In a language which doe not support it you can do~~ in C++		Only available in TypeScript/JavaScript.

			=== Logical Right Shift in C and C++ ===
			C and C++ do not provide a dedicated logical right shift operator for signed
			values. The operator >> performs an arithmetic right shift on signed types
			and a logical right shift on unsigned types.

			To force a logical right shift, cast the value to an unsigned type:

	int i = -10;		int i = -10;
	unsigned x = (unsigned)i >> n;		unsigned x = (unsigned)i >> 1;
	Casting to unsigned ~~forces i~~ to ~~be treated~~ as an unsigned and ~~therefore~~ the ~~MSB is used e.g. 0b1010 is now treated as 0b11010~~
			Casting to unsigned causes >> to treat the bits as an unsigned integer, so
			zeros are shifted in from the left.

			Without the cast, >> performs an arithmetic shift and preserves the sign bit:

			int x = i >> 1; // arithmetic shift, sign bit copied

	== 3. Bit Rotation Operators ==		== 3. Bit Rotation Operators ==

Iwiseman: /* Logical Right Shift ( >>> ) */

2026-04-17T23:51:36Z

Logical Right Shift ( >>> )

← Older revision		Revision as of 23:51, 17 April 2026
Line 120:		Line 120:
	1110 1000 >>> 3 = 0001 1101		1110 1000 >>> 3 = 0001 1101

	Only available in TypeScript/JavaScript.		Only available in TypeScript/JavaScript. In a language which doe not support it you can do in C++
			int i = -10;
			unsigned x = (unsigned)i >> n;
			Casting to unsigned forces i to be treated as an unsigned and therefore the MSB is used e.g. 0b1010 is now treated as 0b11010

	== 3. Bit Rotation Operators ==		== 3. Bit Rotation Operators ==

Iwiseman: /* 2. Bitwise Shift Operators */

2026-04-17T23:44:56Z

2. Bitwise Shift Operators

@@ Line 86: / Line 86: @@
 == 2. Bitwise Shift Operators ==
-; (Arithmetic) Right Shift ( >> )
+Bitwise shifts move bits left or right. The important difference is what gets
-Shifts the left hand side to the right n positions
+inserted into the leftmost bit when shifting right.
-; Logical Right Shift ( >>> )
+=== (Arithmetic) Left Shift ( << ) ===
-: 0b1000 >>> 3 = 0b0001
+Example:
-(Only in TypeScript/JavaScript)
+<< 2 = 0100
 == 3. Bit Rotation Operators ==

Iwiseman at 23:37, 17 April 2026

2026-04-17T23:37:48Z

← Older revision		Revision as of 23:37, 17 April 2026
Line 1:		Line 1:
			=Introduction=
			I do not ever retain information so thought I would write this down for next time I forget
			=Two's Compliment=
			This is a mysterious word, but like decimal is a way to store numbers, Two's Compliment is a way to signed integers.<br>
			<br>
			In this system, the MSB acts as the sign bit:
			0 = positive, 1 = negative.

			= Signed vs Unsigned Values =
			Bits by themselves have no meaning. A sequence like:

			11101000

			is just eight bits. The '''type''' that holds those bits decides how they are interpreted.

			== Unsigned Types ==
			Unsigned types treat the bits as a positive integer.

			Example (8‑bit):
			11101000 = 232

			Unsigned values never represent negative numbers.

			== Signed Types ==
			Signed types use the most significant bit (MSB left hand side) as a sign indicator using two's complement.

			Example (8‑bit):
			11101000 = −24

			The bit pattern is the same as the unsigned example, but the type interprets it differently.

			== Why This Matters for Bitwise Operations ==
			Right‑shift behaviour depends on whether the value is signed or unsigned:

			* '''Signed types''' use an ''arithmetic right shift'' (>>), which preserves the sign bit.
			* '''Unsigned types''' use a ''logical right shift'' (>>), which always shifts in zeros.
			* Some languages provide '''logical right shift''' explicitly (>>>), which always shifts in zeros regardless of sign.

			== Key Idea ==
			Bits are not inherently signed or unsigned.
			The '''type''' determines how the bits are interpreted and how operators behave.


	= Bitwise Operations Overview =		= Bitwise Operations Overview =

Iwiseman: /* 2. Bitwise Shift Operators */

2026-04-17T23:28:50Z

2. Bitwise Shift Operators

← Older revision		Revision as of 23:28, 17 April 2026
Line 43:		Line 43:

	== 2. Bitwise Shift Operators ==		== 2. Bitwise Shift Operators ==

	; (Arithmetic) Left Shift ( << )		; (Arithmetic) Left Shift ( << )
	Shifts the right hand side to the left n positions		Shifts the right hand side to the left n positions