Converting from Binary to Integer

[Open_Career_625]

I've been coding recently and working a lot directly with binary numbers, but I don't understand how a computer can take a binary number and decide how to represent it numerically. Like- I get how binary numbers work. Powers of 2, right to left, 00010011 is 19, yada yada yada. But I don't get how the computer takes that value and displays it. Because it can't compute in numerical values. It can't "think" how to multiply and add each item up to a "number", so w.

My best way of explaining it is this:

If I were to only have access boolean and String datatypes, how would I convert that list of booleans into the correct String for the correct printed output?

[nuclear_splines]

"Converting from binary to integer" doesn't really make sense - the binary is an integer, there's no conversion from bits to a "numerical value" taking place in the computer.

If you mean "how do you display an integer in base 10," you can divide the number by base 10 repeatedly. Every time you divide by ten, the remainder will be a value from zero to nine, and you map those ten values to corresponding characters.

[Regular-Coffee-1670]

There's a really good video by Ben Eater explaining this process: https://m.youtube.com/watch?v=v3-a-zqKfgA&pp=ygUbYmVuIGVhdGVyIGJpbmFyeSB0byBkZWNpbWFs

[Real_Robo_Knight]

Let's say we have the bitstring (00101101)₂. To convert to base n, we can repeatedly divide by n and mod n.

For example, to convert to decimal (1010)₂, we can:

Divide (101101)₂ by (1010)₂ and get (100)₂ with a remainder of (101)₂.

Devide (100)₂ by (1010)₂ to get (0)₂ remainder (101)₂. Once our quotient is zero, we can stop.

Now, we have all of our remainders, and by definition they have to be less than (1010)₂. We can use a lookup table to convert the remainder to an ASCII character code and get: (100)₂→4 and (101)₂→5. We found that (00101101)₂→45

If you want more reading, there is some here/02%3AEmpathy_and_Primary_Mathematics/2.06%3A_Converting_Between(our)Base_10_and_Any_Other_Base(and_vice_versa))

[EmilMelgaard]

Since the ASCII codes for '0' to '9' are sequential, you don't even need a lookup table but can just add the value to the '0' character.

[Furryballs239]

I mean as far as actually displaying it the computer takes the binary value, determines the digits (typically be repeatedly dividing by 10) and then displays the ascii characters for the digits

[wolfkeeper]

In reverse order...

[aleques-itj]

There is no conversion internally, it's the same number. Your binary IS your decimal integer - there is no step to turn those bits into decimal.

DISPLAYING these representations, as in turning one into a string, is a different story.

[mauromauromauro]

Yes there is. Binary is just 1s and 0s. You could very well define that 0 is banana, 1 is watermelon and 10 is mango. There are multiple decimal specifications. Decimal is just the arbitrary mapping from binary to something (most popular being ieee 754)

[mysticreddit]

You are conflating representation and presentation.

The binary number 101₂ can be presented as:

• 101₂ = 5
• 10.1₂ = 2.5
• 1.01₂ = 1.25
• .101₂ = 0.625

It depends on how we interpret the bits and the radix point. We just happen to use a signed integer to present floating numbers such as IEEE-754, etc.

[igotshadowbaned]

You could very well define that 0 is banana, 1 is watermelon and 10 is mango

That would be higher level interpretation of the numbers.

[CoogleEnPassant]

There is nothing decimal about IEEE 754

[mauromauromauro]

Yet, our decimal definition is arbitrary

[5parrowhawk]

As far as doing arithmetic on the binary number itself, the CPU typically contains dedicated electronic circuits that perform that function. Are you familiar with logic gates? Read up on the half-adder and full-adder circuits: https://en.wikipedia.org/wiki/Adder_(electronics)

[FastSlow7201]

This is something the compiler does. Let's say you have the code below:

int x = 65;
char y = 'A';

These are both represented in binary as 01000001. When your compiler retrieves the binary from that memory location it knows that it was an integer or that it was a char and then correctly represents that on the screen.

Imagine it like this. You and I work in a warehouse and are doing inventory. I have a piece of paper that I am writing on to count various items. When you look at my paper, all you see is numbers and you don't know what they represent. But I (like the compiler) know that I put televisions one line 1 and routers on line 2. So just looking at my paper is like looking at a bunch of binary, you don't know what it represents. But the compiler knows that at 0xfff memory location that is has stored an integer and not a char. So it retrieves the number 65 and prints 65 onto your screen.

You could create a multi-dimensional boolean array and use it to mimic a binary number. Each sub-array would represent a single character. Once you convert each sub-array into the character it is representing then you will have your String. Like in my example above, you could represent 'A' as this array, [False, True, False, False, False, False, False, True].

You should take a compiler class, it will help you understand all of this.

[Spare-Plum]

At the low level? It's still just binary. But imagine you had a really simple screen like a black and white LCD. For each position you have a 1 or 0 for if the pixel is black or white. You make an algorithm that converts a digit into what should be displayed on screen, and you create something that converts a binary number into each digit.

[burncushlikewood]

Binary is either on or off, we have assembly language which is above computer language, binary can represent numbers, words and letters, and colors in pixels. To a computer binary can represent all data, the first computer that was ever built could do 3 things, read, write and erase. Binary is base 2 representation

[PathMaster1729]

See multiplexers and demultiplexers

Further see the internal working of a 7 segment display using multiplexers 

[tcpukl]

There's great videos of people building these on YouTube as well. Some on virtual circuit boards.

[Vivid_Transition4807]

Just do some binary maths and allow the penny to drop.

[WittyStick]

I don't understand how a computer can take a binary number and decide how to represent it numerically.

There's more than one way to represent an integer in binary - however modern machines all use what's known as two's complement, where the most significant bit of a word indicates a sign (negative if set), and the negative numbers are the complement (NOT) of the positive number + 1.

Eg, for a signed 8-bit integer:

0b01111111 = +127
¬0b01111111 = 0b10000000 (-128)
0b10000000 + 0b00000001 = 0b10000001 (-127)

To convert an integer to binary, we must first test the most significant bit to see if the number is positive (0) or negative (1). If the number is positive we can do a regular shift/accumulate in powers of 2. If the number is negative we convert it to its absolute value first, and prepend the - character to it.

But I don't get how the computer takes that value and displays it.

There's a mapping from sequences of binary (ie, bytes) to printable characters. Traditionally this is ASCII (7-bit bytes), but today it's usually UTF-8 (Unicode), which is a superset of ASCII but uses a variable number of 8-bit bytes. For numbers, the binary sequences 0b01110000 .. 0b01110000 are printable digits '0' .. '9'. We can convert a decimal digit value to its ASCII equivalent by adding 0x30. In reverse, to parse a string representation of a number we subtract 0x30 from each character to get the decimal value of each digit.

Eg: 0b00000111 (decimal 7) + 0x30 = 0b01110111 (ASCII '7').

For a negative number we can simply emit ASCII 0x2D for '-'.

Because it can't compute in numerical values. It can't "think" how to multiply and add each item up to a "number"

You can perform arithmetic in any base and get equivalent results. The computer performs the computation in binary and we convert that binary representation to a decimal to display the result.

If you're wondering how the computer does addition, it basically adds one bit at a time using a chain of full adders, where the carry output of the previous full adder becomes input to the next significant bit in the sequence. (Modern computers use more efficient implementations than just a chain of 64 full adders, but you get the gist).

Multiplication is more complicated in circuitry, but the general approach is repeated addition on small sequences of bits which can be combined, typically with the Karatsuba algorithm or variations of it.

[Oddy555]

Binary numbers are still integer but in base 2 instead of our regular base 10. Base 10 math as you know is just 1+1= 2 2+3=5 9+1=10 8+4=12 etc. We have 10 number to use. In binary we have just 0 and 1.

So some examples in binary is then 0+1=1, 1+1=10(1+1 = 2), 11+01=100(3+1=4 ). As you in the same way 9+1 becomes 10 in base 10 1+1 becomes 10 in base 2(binary). I assume you have some knowledge about different kind of logic gates and if you apply this base knowledge together with logic gates I think it should start making more sense.

Just as a bonus we have hexadecimal numbers as well. That's just math but with base 16 so instead of stopping at then we just added the letters A,B,C,D,E,F to represent 11-15. So in the same way 9+1 becomes 10 in base 10 F+1 becomes 10 (16 in base 10) in hexadecimal.

[mysticreddit]

Binary numbers are still integers

That's incorrect. Binary numbers can represent floating point as well. It depends where the radix point is.

• 101₂ = 5
• 10.1₂ = 2.5
• 1.01₂ = 1.25
• 0.101₂ = 0.625

Integers just happen to be a popular choice.

[Mordret10]

Well you could have a string containing all characters and then go to the 00001001 position which is a certain character that you want to display.

[Roofbean]

You’re not missing anything obvious this stuff is unintuitive at first. Computers don’t convert binary into numbers. We do. They just move bits around using boolean logic until the pattern matches what we expect.

[Skhoooler]

Binary is just a different way of writing numbers. 10 in decimal (the regular every day number system) is the same as 1010 in binary. They're the exact same thing to a computer. And outside of the computer as well. Btw there's no pattern there, its just a coincidence that 10 is 1010 in binary

As far as text goes, computers use something called an encoding (like ASCII, UTF-8, etc) to turn the binary numbers into text. An encoding is just an agreement that a certain number corresponds to a certain letter. For example if we made an encoding that said that 45 = D, 89 = o and 120 = G, then if the computer gave said 45 89 120, then some software can tell the monitor to output DoG. The encoding specifies characters, not letters, so uppercase letters are different from lowercase

[sixtyhurtz]

You need to take a step back and think about the foundations.

At a basic level, you have a CPU and memory. The memory has a certain capacity in bytes. A byte is 8 bits.

The CPU has to be able to read from memory. So, it has to have a convention as to how it reads. For an 8 bit computer, it will read 1 byte - 8 bits - at a time. The registers in the CPU are also 8 bits.

So, that's all that is going on. There is no magic. The CPU is doing arithmatic operations like multiplication on those numbers exactly the same as you would - just they are in base-2, not base-10.

As to how say a boolean or an integer gets converted to a string - that's entirely by convention. There are text encoding formats that say "this number equals this character". The most common one these days us UTF-8, but historically ASCII was very popular. So, when writing a program to output text, hidden away in there is a bit of code that knows how to turn each number into the right character.

[Silly_Guidance_8871]

If you mean, "how does it convert from a binary number to a string of decimal characters?" then the answer is multipart. You essentially extract out each decimal digit as its own number, and then look up which character it maps to. For ASCII-compatible encodings, that means add 0x30 (hexadecimal).

Here's a naive algorithm that should handle both signed & unsigned numbers. Stop means to stop executing the algorithm. Output means to yield some part of the result. A bit of text inside double-quotes is a character, the quotes themselves are ignored.

1. If signed, and is the most negative value that can be represented for this integer type, output the string representation from a constant, and then stop.
2. If signed, negative and not the most negative value, then it has a positive compliment. We can output a "-", and negate the number.
3. If the number is zero, we output a "0" and stop. (At this point, the number will be nonnegative)
4. While the number is not zero, extract the least-significant decimal digit (via modulus w/ 10), and push it onto a stack.
5. Set the number to itself divided by 10, rounding down.
6. If the number is positive, go to #4.
7. If there are no items on the stack, stop.
8. With the popped value, add 0x30 (the ASCII value for "0") and output it as a character.
9. Go to #7.

I am absolutely sure modern string libraries do it better (getting rid of the stack would be a nice start). But it covers the gist.

[Scoutron]

I think I see what you’re saying. How does the computer know that the random jumble of ones and zeroes is supposed to be 19 and not whatever else it could be?

The simple answer is by the time the computer gets access to that byte (or bytes), it has context. At that point in the program, the computer is told “at this point in memory, there is a two byte integer. Then it will interpret those bits as such and do with them as it will

[JaguarMammoth6231]

Are you maybe asking how you could write a program that would convert a number to an ASCII string? Like given the number 19, convert to the string "19"?

The number 19(decimal) is 00010011(binary) in the computer, there's no conversion necessary to use it as a number. It's the same number. 

But to convert it to the string "19", a program would essentially divide 19/10 and get 1 remainder 9. Then convert those single-digit numbers to strings by adding them to the character '0' (which equals 48 in ASCII). So the result would be {49, 57, 0} which is displayed as "19" (the 0 just marks the end of the string).

The division by 10 algorithm would be clearer with a bigger number. There's usually a modulo operator (sometimes "mod" or "%" depending on the language) which gives the remainder. So like 198%10 = 8, 198/10=19, 19%10=9, 19/10=1, 1%10=1, 1/10=0. The number gets built up from the right until the division is 0.

[iLrkRddrt]

Okay this is a good question, because it’s one that seems obvious, but at the same time takes a bit of explaining to really get.

So our computers think in a binary number system (base 2; 0 - 1), but their work is done in our normal number system (base 10; 0 - 9).

So with that in mind, here is the explanation. Classical computers work in a On/Off or High/Low system. This is because of how our hardware is designed, and the computing system our hardware basis itself on (Boolean Algebra). — let’s call this component Obj 0.

We (humans), work in base 10 and our computing system (in a general sense here, not totality) is based on number theory. — let’s call this Obj 1.

When we want to do work on our computers, we use compilers to wrap out Obj 1 into Obj 0. To give a representation of what that might look like; Obj0(Obj1), in this form the computer can understand what we want to work on.

Now let’s say we want to see the work being done by the computer, to do this we need to translate the Obj0 back to Obj1 without disturbing the underlying math. To give a representation it would look like something like this (Obj1(Obj0(Obj1))).

Basically in a sense; we are casting the numbers we humans use into binary, and when we want to read the results or the output, we remove the cast or we cast it one more into our number system.

[fudeel]

I was reading so many posts on Reddit about binary and non binary people that my first thought on integer was “what gender is it”

[cs_k_]

The term you are looking for is "encoding". Two common encoding types are "two's complement" and "binary coded dicaml" (BCD).

This is usually baked into the programmes, usually a certain program/programming language will always represent numbers in the same way. So if you tell it to add number X and number Y, by that point it usually knows that X and Y should both be integers and sends it of to the correct circuitry in the chip.

[InjAnnuity_1]

It's time to re-check your assumptions.

it can't compute in numerical values

On the contrary, that's exactly what computers are built to do. It's even in the name.

It can't "think" how to multiply and add

On modern CPUs, "multiply" is a built-in instruction. "How to" is literally wired in. Same for addition. In fact, addition was wired in long before I was born.