Sensible information to binary operations utilizing the UInt8 sort in Swift

Integer sorts in Swift

The Swift programming language has a bunch of various integer sorts. The Swift integer APIs had been cleaned up by an outdated proposal named Protocol-oriented Integers, which resulted in a extra generic approach of expressing these sort of information sorts.

Numeric information sorts in Swift are sort secure by default, this makes a bit tougher to carry out operation utilizing completely different integer (or floating level) sorts. Integers are divided into two primary teams: signed and unsigned integers. As well as every members of those teams may be categorized by bit sizes. There are 8, 16, 32 & 64 bit lengthy signed & unsigned integers plus generic integers. 🤔

Generic integers:

• Int (32 or 64 bit)
• UInt (32 or 64 bit)

Signed integers:

Unsigned integers:

It’s best to know that the Int and UInt sort dimension could differ on completely different platforms (32 vs 64 bits), however with a purpose to be constant, Apple recommends to all the time choose the generic Int sort over all the opposite variants. The Swift language all the time identifies all of the integers utilizing the Int sort by default, so should you hold utilizing this kind you can carry out integer operations with out sort conversions, your code shall be simpler to learn and it is going to be simpler to maneuver between platforms too. 💪

More often than not you should not care in regards to the size of the integer sorts, we will say that the generic Int and UInt sorts are very often one of the best selections once you write Swift code. Besides in these instances when your purpose is to put in writing extraordinarily reminiscence environment friendly or low stage code…

Representing numbers as integers

Now that we all know what sort of integers can be found in Swift, it is time to discuss a bit about what sort of numbers can we symbolize utilizing these information sorts.

print(Int.min)      
print(Int.max)      
print(UInt.min)     
print(UInt.max)     
print(UInt8.min)    
print(UInt8.max)    
print(UInt16.min)   
print(UInt16.max)   
print(UInt32.min)   
print(UInt32.max)   
print(UInt64.min)   
print(UInt64.max)   
print(Int8.min)     
print(Int8.max)     
print(Int16.min)    
print(Int16.max)    
print(Int32.min)    
print(Int32.max)    
print(Int64.min)    
print(Int64.max)    

So there’s a minimal and most worth for every integer sort that we will retailer in a given variable. For instance, we will not retailer the worth 69420 inside a UInt8 sort, as a result of there are merely not sufficient bits to symbolize this big quantity. 🤓

Let’s look at our 8 bit lengthy unsigned integer sort. 8 bit implies that we have now actually 8 locations to retailer boolean values (ones and zeros) utilizing the binary quantity illustration. 0101 0110 in binary is 86 utilizing the “common” decimal quantity format. This binary quantity is a base-2 numerical system (a positional notation) with a radix of two. The quantity 86 may be interpreted as:

0*28+1*27+0*26+1*25+0*24 + 1*23+1*22+0*21+0*20
0*128+1*64+0*32+1*16 + 0*8+1*4+1*2+0*1
64+16+4+2
86

We are able to convert forwards and backwards between decimal and binary numbers, it is not that onerous in any respect, however let’s come again to this matter afterward. In Swift we will verify if a sort is a signed sort and we will additionally get the size of the integer sort by the bitWidth property.

print(Int.isSigned)     
print(UInt.isSigned)    
print(Int.bitWidth)     
print(UInt8.bitWidth)   

Primarily based on this logic, now it is fairly simple that an 8 bit lengthy unsigned sort can solely retailer 255 as the utmost worth (1111 1111), since that is 128+64+32+16+8+4+2+1.

What about signed sorts? Nicely, the trick is that 1 bit from the 8 is reserved for the optimistic / adverse image. Often the primary bit represents the signal and the remaining 7 bits can retailer the precise numeric values. For instance the Int8 sort can retailer numbers from -128 til 127, because the most optimistic worth is represented as 0111 1111, 64+32+16+8+4+2+1, the place the main zero signifies that we’re speaking a couple of optimistic quantity and the remaining 7 bits are all ones.

So how the hack can we symbolize -128? Is not -127 (1111 1111) the minimal adverse worth? 😅

Nope, that is not how adverse binary numbers work. With a purpose to perceive adverse integer illustration utilizing binary numbers, first we have now to introduce a brand new time period known as two’s complement, which is an easy methodology of signed quantity illustration.

Fundamental signed quantity maths

It’s comparatively straightforward so as to add two binary numbers, you simply add the bits so as with a carry, similar to you’d do addition utilizing decimal numbers. Subtraction then again is a bit tougher, however fortuitously it may be changed with an addition operation if we retailer adverse numbers in a particular approach and that is the place two’s complement is available in.

Lets say that we would like so as to add two numbers:

• 0010 1010 (+42)
• 0100 0101 +(+69)
• 0110 1111 =(+111)

Now let’s add a optimistic and a adverse quantity saved utilizing two’s complement, first we have to categorical -6 utilizing a signed 8 bit binary quantity format:

• 0000 0110 (+6)
• 1111 1001 (one’s complement = inverted bits)
• 1111 1010 (two’s complement = add +1 (0000 0001) to 1’s complement)

Now we will merely carry out an addition operation on the optimistic and adverse numbers.

• 0010 1010 (+42)
• 1111 1010 +(-6)
• (1) 0010 0100 =(+36)

So, you may suppose, what is the take care of the additional 1 to start with of the 8 bit outcome? Nicely, that is known as a carry bit, and in our case it will not have an effect on our remaining outcome, since we have carried out a subtraction as a substitute of an addition. As you’ll be able to see the remaining 8 bit represents the optimistic quantity 36 and 42-6 is strictly 36, we will merely ignore the additional flag for now. 😅

Binary operators in Swift

Sufficient from the idea, let’s dive in with some actual world examples utilizing the UInt8 sort. To start with, we must always discuss about bitwise operators in Swift. In my earlier article we have talked about Bool operators (AND, OR, NOT) and the Boolean algebra, now we will say that these features function utilizing a single bit. This time we will see how bitwise operators can carry out varied transformations utilizing a number of bits. In our pattern instances it is all the time going to be 8 bit. 🤓

Bitwise NOT operator

This operator (~) inverts all bits in a quantity. We are able to use it to create one’s complement values.

let x: UInt8 = 0b00000110    
let res = ~x                 
print(res)                   
print(String(res, radix: 2)) 

Nicely, the issue is that we’ll hold seeing decimal numbers on a regular basis when utilizing int sorts in Swift. We are able to print out the right 1111 1001 outcome, utilizing a String worth with the bottom of two, however for some purpose the inverted quantity represents 249 in response to our debug console. 🙃

It is because the which means of the UInt8 sort has no understanding in regards to the signal bit, and the eighth bit is all the time refers back to the 28 worth. Nonetheless, in some instances e.g. once you do low stage programming, similar to constructing a NES emulator written in Swift, that is the correct information sort to decide on.

The Information sort from the Basis framework is taken into account to be a set of UInt8 numbers. Truly you may discover numerous use-cases for the UInt8 sort should you take a deeper have a look at the prevailing frameworks & libraries. Cryptography, information transfers, and many others.

Anyway, you may make an extension to simply print out the binary illustration for any unsigned 8 bit quantity with main zeros if wanted. 0️⃣0️⃣0️⃣0️⃣ 0️⃣1️⃣1️⃣0️⃣

import Basis

fileprivate extension String {
    
    func leftPad(with character: Character, size: UInt) -> String {
        let maxLength = Int(size) - rely
        guard maxLength > 0 else {
            return self
        }
        return String(repeating: String(character), rely: maxLength) + self
    }
}

extension UInt8 {
    var bin: String {
        String(self, radix: 2).leftPad(with: "0", size: 8)
    }
}

let x: UInt8 = 0b00000110   
print(String(x, radix: 2))  
print(x.bin)                
print((~x).bin)             
let res = (~x) + 1          
print(res.bin)

We nonetheless have to supply our customized logic if we need to categorical signed numbers utilizing UInt8, however that is solely going to occur after we all know extra in regards to the different bitwise operators.

Bitwise AND, OR, XOR operators

These operators works similar to you’d anticipate it from the reality tables. The AND operator returns a one if each the bits had been true, the OR operator returns a 1 if both of the bits had been true and the XOR operator solely returns a real worth if solely one of many bits had been true.

• AND & – 1 if each bits had been 1
• OR | – 1 if both of the bits had been 1
• XOR ^ – 1 if solely one of many bits had been 1
• Let me present you a fast instance for every operator in Swift.

let x: UInt8 = 42   
let y: UInt8 = 28   
print((x & y).bin)  
print((x | y).bin)  
print((x ^ y).bin)  

Mathematically talking, there’s not a lot purpose to carry out these operations, it will not provide you with a sum of the numbers or different primary calculation outcomes, however they’ve a unique goal.

You should use the bitwise AND operator to extract bits from a given quantity. For instance if you wish to retailer 8 (or much less) particular person true or false values utilizing a single UInt8 sort you should utilize a bitmask to extract & set given components of the quantity. 😷

var statusFlags: UInt8 = 0b00000100


print(statusFlags & 0b00000100 == 4)   
print(statusFlags & 0b00010000 == 16)  
statusFlags = statusFlags & 0b11101111 | 16
print(statusFlags.bin)  
statusFlags = statusFlags & 0b11111011 | 0
print(statusFlags.bin) 
statusFlags = statusFlags & 0b11101111 | 0
print(statusFlags.bin) 
statusFlags = statusFlags & 0b11101011 | 4
print(statusFlags.bin) 

That is good, particularly should you do not need to fiddle with 8 completely different Bool variables, however one there’s one factor that could be very inconvenient about this resolution. We all the time have to make use of the correct energy of two, after all we might use pow, however there’s a extra elegant resolution for this concern.

Bitwise left & proper shift operators

By utilizing a bitwise shift operation you’ll be able to transfer a bit in a given quantity to left or proper. Left shift is basically a multiplication operation and proper shift is an identical with a division by an element of two.

“Shifting an integer’s bits to the left by one place doubles its worth, whereas shifting it to the correct by one place halves its worth.” – swift.org

It is fairly easy, however let me present you a number of sensible examples so you may perceive it in a bit. 😅

let meaningOfLife: UInt8 = 42



print(meaningOfLife << 1) 
print(meaningOfLife << 2) 
print(meaningOfLife << 3) 
print(meaningOfLife >> 1) 
print(meaningOfLife >> 2) 
print(meaningOfLife >> 3) 
print(meaningOfLife >> 4) 
print(meaningOfLife >> 5) 
print(meaningOfLife >> 6) 
print(meaningOfLife >> 7) 

As you’ll be able to see we have now to watch out with left shift operations, because the outcome can overflow the 8 bit vary. If this occurs, the additional bit will simply go away and the remaining bits are going for use as a remaining outcome. Proper shifting is all the time going to finish up as a zero worth. ⚠️

Now again to our standing flag instance, we will use bit shifts, to make it extra easy.

var statusFlags: UInt8 = 0b00000100


print(statusFlags & 1 << 2 == 1 << 2)


statusFlags = statusFlags & ~(1 << 2) | 0
print(statusFlags.bin)


statusFlags = statusFlags & ~(1 << 2) | 1 << 2
print(statusFlags.bin)

As you’ll be able to see we have used numerous bitwise operations right here. For the primary verify we use left shift to create our masks, bitwise and to extract the worth utilizing the masks and eventually left shift once more to match it with the underlying worth. Contained in the second set operation we use left shift to create a masks then we use the not operator to invert the bits, since we will set the worth utilizing a bitwise or perform. I suppose you’ll be able to work out the final line based mostly on this information, but when not simply follow these operators, they’re very good to make use of as soon as you already know all of the little the small print. ☺️

I feel I will reduce it right here, and I am going to make simply one other submit about overflows, carry bits and varied transformations, perhaps we’ll contain hex numbers as properly, anyway do not need to promise something particular. Bitwise operations are usueful and enjoyable, simply follow & do not be afraid of a little bit of math. 👾