A bit is used to denote a binary digit. A binary digit can have two possible values either 0 or 1. As a beginner level programmer, you don't have to work with operations at the bit level.
Working with primitive data types such as: integer, float, boolean, string etc is enough. You may need to work at bit level when you are dealing with low level programming.
Swift provides a rich set of operators, apart from basic operators, to manipulate bits. These operators are similar to the logical operators, except that they work on binary representations of data (bits).
Bitwise operators are operators that are used to change individual bits of an operand. Operand is a variable or constant in which the operation is done.
All bitwise operators available in swift are listed below:
It is represented by tilde ~
sign and can be applied on a single operand. This inverts all the bits. i.e changes 1 to 0 and 0 to 1.
If x is a variable/constant that holds binary value i.e 0 or 1. The bitwise not operation on the x variable can be represented in table below:
x | ~x |
---|---|
0 | 1 |
1 | 0 |
let initalNumber:UInt8 = 1
let invertedNumber = ~initalNumber
print(invertedNumber)
When you run the above program, the output will be:
254
In the above program, the statement let initalNumber:UInt8 = 1
is of type Unsigned int of size 8 bits. So, 1 in decimal can be represented as 00000001
in binary.
The bitwise not operator changes all the bit of a variable or constant, the bit 0 is changed to 1 and 1 to 0. So invertedNumber contains bits 11111110
. After converting it into decimal it is represented as 254. So, the statement print(invertedNumber)
outputs 254 in the screen.
You can also perform bitwise operator directly in the bits as:
let initialBits: UInt8 = 0b11111111
let invertedBits = ~initialBits
print(invertedBits)
When you run the above program, the output will be:
0
initialBits contains binary value 11111111
that corresponds to 255 in decimal. To represent the number in binary we have 0b
as a prefix in the literal. Without 0b
as a prefix, it will treat it as a normal integer and you will get an overflow error (UInt8 can store numbers from only 0 to 255).
Since, we have used bitwise not operator, it changes all the 1 to 0. So, the constant invertedBits contains 00000000
which is equivalent to 0 in UInt8
.
let initalNumber:Int = 1
let invertedNumber = ~initalNumber
print(invertedNumber)
When you run the above program, the output will be:
-2
In the above program, 1 in decimal can be represented as 00000001
in binary. The bitwise not operator changes all the bit of a variable or constant, the bit 0 is changed to 1 and 1 to 0. So, invertedNumber contains bits 11111110
. This should output 254 in the screen. But instead returns -2. Strange, Right?? Let's explore below how did this happen.
let initalNumber:Int = 1
is a signed int that can hold both positive and negative integers. That's why when we applied not operator for a signed integer, the returned binary may also represent a negative number.
How did compiler interpreted -2 as 11111110
in binary?
The compiler used Two's complement to represent integers. To get the two's complement negative notation of an integer, you should first write out the number in binary then invert the digits, and add one to the result.
Steps to find out Two's complement of -2:
00000010
11111101
11111110
That's how compiler interprets binary number 1111110
as -2
in decimal. But, there is a little twist that compiler made which we did not notice. It also inferred the type of invertedNumber as Int8
type.
To understand this, let's see an example below:
print(Int8(bitPattern: 0b11111110))
print(0b11111110)
When you run the above program, the output will be:
-2 254
In the above example, compiler treated the binary number to -2 in decimal only for the Signed 8-Bit Integer. Therefore statement print(Int8(bitPattern: 0b11111110))
outputs -2 in the screen.
But for the normal integer type whose size is 32/64 bit and can hold large values, it interprets the value as 254
. Therefore, statement print(0b11111110)
outputs 254 in the screen.
It is represented by &
and can be applied on two operands. The AND operator compares two bits and returns 1 if both bits are 1, otherwise returns 0.
If x and y are variable/constant that holds binary value i.e 0 or 1. The Bitwise AND operation on x and y can be represented in table below:
x | y | x & y |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 1 | 1 |
1 | 0 | 0 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits & yBits
print("Binary:",String(result, radix: 2))
print(result)
When you run the above program, the output will be:
Binary: 10000011 131
In the above program, the statement let result = xBits & yBits
combines the bits of two operands xBits and yBits. It returns 1 it both of the bits are 1 otherwise it returns 0.
String(value , radix: )
initializer is used to represent number in different number system. If we supply radix value 2. It converts the number to binary number system. Similarly, we can use 16 for hex and 10 for decimal.
The statement print("Binary:",String(result, radix: 2))
outputs Binary: 10000011 in the screen. 10000011
is equivalent to 131 in decimal,the statement print(result)
outputs 131 in the console.
It is represented as |
and can be applied on two operands. The bitwise OR operator compares two bits and generates a result of 1 if one or more of its inputs are 1 otherwise 0.
If x and y are variable/constant that holds binary value i.e 0 or 1. The Bitwise OR operation on x and y can be represented in table below:
x | y | x | y |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 1 | 1 |
1 | 0 | 1 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits | yBits
print("Binary:", String(result, radix: 2))
print(result)
When you run the above program, the output will be:
Binary: 11111111 255
In the above program, the statement let result = xBits | yBits
combines the bits of two constants xBits and yBits. It returns 1 if any of the bits are 1 otherwise it returns 0.
The statement print("Binary:",String(result, radix: 2))
outputs Binary: 11111111 in the screen. Since, 11111111
is equivalent to 255
in decimal, the statement print(result)
outputs 255 in the screen.
It is represented as ^
and can be applied on two operands. The XOR operator compares two bits and generates a result of 1 if exactly one of its inputs are 1 otherwise it returns 0.
If x and y are variable/constant that holds binary value i.e 0 or 1. The Bitwise XOR operation on x and y can be represented in table below:
x | y | x ^ y |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 1 | 0 |
1 | 0 | 1 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits ^ yBits
print("Binary:", String(result, radix: 2))
print(result)
When you run the above program, the output will be:
Binary: 1111100 124
In the above program, the statement let result = xBits ^ yBits
combines the bits of two constants xBits and yBits. It returns 1 if exactly one of the bits is 1 otherwise it returns 0.
The statement print("Binary:",String(result, radix: 2))
outputs Binary: 1111100 (equivalent to 01111100)in the screen. Since, 1111100
is equivalent to 124
in decimal, the statement print(result)
outputs 124 in the screen.
This operators are used to move all bits in a number to the left or the right by a certain number of places and can be applied on single operand. It is represented as <<
or >>
.
There are two kinds of shift operators:
<<
<<
.let someBits:UInt8 = 0b11000100
print(someBits << 1)
When you run the above program, the output will be:
136
In the above program, we have used left shift operator. Using <<
1 means to shift the bit by 1 to the left. The digits get shifted to the left by one position, and the last digit on the right is filled with a zero.
You can also see the digit that gets shifted "off the end" from left side is lost. It does not wrap around again from the right. Shifting it one bit to the left removes the 1 from the binary and adds 0 in the right to fill the shifted value as well rest of the other bits are shifted towards left position by 1.
This returns 10001000
which is equivalent to 136
in UInt8
. Therefore, print(someBits << 1)
statement outputs 136 in the screen.
>>
>>
let someBits: UInt8 = 4
print(someBits >> 1)
When you run the above program, the output will be:
2
In the above program, we have used right shift operator on a unsigned integer. Using >>
1 means to shift the the bit by 1 to the right. The bit positions that have been vacated by the shift operation are always zero-filled on a unsigned integer.
Since, 4 is represented as 00000100
in binary. Shifting it one bit to the right, returns 00000010
which is equivalent to 2
in UInt8
. Therefore, print(someBits >> 1)
statement outputs 2 in the screen.
let someBits:Int = -4
print(someBits >> 1)
When you run the above program, the output will be:
-2
In the above program, we have used right shift operator on a unsigned integer. Unlike positive numbers, using >>
for negative numbers, 1 is used to fill the vacant place, instead of 0.
Since, -4
is represented as 11111100
in binary. Shifting it one bit to the right and placing 1 in vacant position, returns 11111110
which is equivalent to -2
for Int8
type. Therefore, print(someBits >> 1)
statement outputs -2 in the screen.