# What is an unsigned integer ?

An integer in mathematics , is any number which belong to the set Z . The set Z , contains positive whole numbers , such as : 1 , negative whole numbers such as : -1 , and the number : 0 .

Asking what is a signed or an unsigned integer , is actually asking , how to represent integers such as : -1 , 0 , and 1 , in the computer .

Representing numbers in the computer , is done on a limited number of bits , for example 8 bits , or 16 bits .

In this first part , we will describe , what is an unsigned integer , and in a second part , we will describe , what is a signed one .

## Unsigned integers

This being said , we can first choose to encode the non negative numbers , as such the positive whole numbers , such as 1 or 2 etc. , and the number 0 .

Encoding in the computer can be performed using only a limited number of bits , since a computer memory is limited .

As such , once the number of bits to encode a non negative integer values has been chosen , only a limited set , of non negative integers can be represented . This limited set of non negative integers , with its encoding , is called an unsigned integer set . An unsigned integer , has a non negative numeric integer value , and it has an encoding .

Encoding in the computer , consists of representing data , using a string of bits formed only of 0 and 1 , such as 10101 , called a binary representation . Binary as in the digits used , consist only of the two values 0 , or 1 .

In unsigned encoding , non negative integers , are encoded using the binary positional numeral system . In the binary positional numeral system , 0101 as an example , has a value of 5 in the decimal positional numeral system.

In a high level programming language , unsigned integers are represented using some data type , for example in c or c++ unsigned integers , are represented using the following data types :

unsigned char
# typically 8 bits .
# at least 8 bits .

unsigned short
# typically 16 bits .
# at least 16 bits .

unsigned int
# typically 32 bits .
# at least 16 bits .

unsigned long
# typically 64 bits
# at least 32 bits .

unsigned long long
# typically 64 bits
# at least 64 bits .

Having chosen a number of bits , and how to encode non negative integers in the computer , we end up with an unsigned integer set , formed of a limited number of non negative integers and their encodings , the question to ask hence , is what operations can be performed on this set .

For all the following sections , let us say , that encoding is performed using only 2 bits , as such the unsigned integers set is :

Addition is performed using the binary positional numeral system , as such it works like regular addition , with carry and so on .

A problem that is faced , when performing addition using unsigned integers , is that , there is a limited number of bits used for encoding . This can lead to overflow , which is that a result is too large to be represented , using the chosen encoding .

When the result of an unsigned addition , is too large to be represented using the selected number of bits , the excessive bits are thrown away , so the resulting number of bits is truncated to fit the selected number of bits . This is the same as :

As such , the result of performing unsigned integer addition , when the numbers of bits selected for encoding , is only 2 , is :

To detect if unsigned integer addition overflow has occurred , it is sufficient to check if the result of the unsigned addition , is smaller of any of its two operands .

int unsignedAdditionOverflow( unsigned int x , unsigned int y ){
/* Check if unsigned int addition overflow ,
will occur , return 1 , if it does , 0
otherwise .*/
return ( x + y )  < x;}// end unsignedAdditionOverflow

## Unsigned integer multiplication

Unsigned integer multiplication , works like regular multiplication , because it is being performed using base 2 .

The problems faced by unsigned multiplication , are caused by the limited number of bits used , which lead to overflow .

For unsigned integer multiplication , when overflow occurs , the exceeding bits are thrown away , and the result is truncated to the selected number of bits . This is the same as :

As an example , a table of unsigned multiplication , when encoding is performed using two bits is :

To detect unsigned multiplication overflow in C , it can be done using this method , or one of its derivatives .

#include<limits.h>
/* The limits.h header contains the
min and  max values , that integer
types in C , can have on a certain
machine . */

int unsignedMultiplicationOverflow( unsigned char x , unsigned char y ){
//Check for unsigned char multiplication overflow
if( x == 0 || y == 0 )
return 0; //no unsigned char multiplication overflow
if( x == 1 || y == 1 )
return 0; // no unsigned char multiplication overflow
unsigned char z = UCHAR_MAX / x ;
/* Perform unsigned division ,
For example , x = 20 , UCHAR_MAX = 255
z = 12 .
z is the greatest number such that :
z * x <= UCHAR_MAX */
if( y > z )
return 1;//unsigned char multiplication overflow
else
return 0; /*no unsigned char multiplication overflow*/}//end unsignedMultiplicationOverflow

## Unsigned integer division

Unsigned integer division works the same as regular integer division , since the division is being performed using base 2 . It returns only the quotient , without any remainder or fractional part .

No overflow can occur while performing unsigned integer division , and the result of dividing by 0 is undefined .

## Unsigned integers subtraction

When subtracting , the larger unsigned value , from the smaller unsigned value , the result is correct , but when subtracting the smaller unsigned value from the larger unsigned value , the result is negative .

The formula to compute the result , when the subtraction of two unsigned integers yield a negative value , is the following :

As an example , the following tables details unsigned subtraction using 2 bits :

To check if the subtraction of two unsigned integers , will yield a modulo result , this can be done as follows :

int unsignedSubstractionModulo( unsigned char x , unsigned char y ){
// Check if y - x cause modulo result .
if( x <= y )
return 0; // no unsigned char substraction modulo result
else
return 1;/* unsigned char substraction modulo result */}// end unsignedSubstractionModulo

## Commutativity , associativity , and distributivity

commutative : a + b = b + a
associative : a + ( b + c ) = ( a + b ) + c

unsigned Multiplication
commutative : a * b = b * a
associative : a * ( b * c ) = ( a * b ) * c