# Binary

Binary is a way to write any number as a sum of 2 to the power of n. Where n is the position of the factor of 2 in the binary string.

For example:

• `1 = 2^0 = 1`
• `10 = 2^1 + 0 = 2`
• `100 = 2^2 + 0 + 0 = 4`
• `111 = 2^2 + 2^1 + 2^0 = 4 + 2 + 1 = 7`

It is common to have to convert binary numbers to regular numbers and vice versa.

As an aside, to convert decimal numbers to binary we will be using Rust's `%` remainder operator, not `rem_euclid()` I wrote a little about their difference.

### Convert regular number to binary.

``````fn convert_to_binary(input: i32) -> Vec<i32>{
let mut current = input;
let mut binary = vec![];
while current > 0 {
match current % 2 {
0 => {
binary.push(0);
current = current/2;
},
1 => {
binary.push(1);
current = (current-1)/2;
}
}
}
binary
}
``````

### Convert a binary number to a regular number.

``````fn convert_to_regular(input: Vec<i32>) -> i32 {
let mut result = 0;
for i in 0..input.len() {
match input[i] {
0 => {
result += 0;
},
1 => {
let new_value = 2.pow(input.len() -1 -i ); //
result += result + new_value;
}
}
}
result
}
``````

#### Understanding 2's complement.

We must find a way to represent negative numbers in binary.

• For a positive number, represented in binary, flip its bits (1's complement) and add 1 to get its negative representation in binary.
``````0101 = 5;
1010 = -8 + 2 = -6
Remember the +1!
1011 = -8 + 2 + 1 = -5
``````
• Note, we can identify negative numbers in binary that can represent them because they begin with 1.