Binary Coded Decimal (BCD) & Douglas Adams' 42 - Computerphile 

It’s a nice looking shirt! I have quite a few Hawaiians myself. I have always had a passion for electronics and computers and I have learned a lot through your videos on Computerphile. I love Microcomputers and home brew cpu’s and computer builds I am going to be studying computer engineering at the University of Cincinnati next year. I hope that one day I will be able to go to the UK to check out the centre of computing history and maybe sneak into one of your classes at Nottingham. Thanks for all you have done.

Best wishes for your computer engineering studies. I'm pleased that our "Computerphile" videos helped you on the way.

I hope you don't mind me saying this, professor Dave B, but your likeliness to professor Donald Ervin Knuth is quite uncanny. I wonder if he joined your stroll through Stanford University's mall. 😄

...and I learned the meaning of a new word! to nibble - knabbern :D

Prof. Brailsford, please only wear Hawaiian shirts from now on. I thought you were cool before but now you've proven how much cooler you are!

I could not. But it seems that I cannot resist listening all night.

+Klapaucius Fitzpatrick Yep, that's how writing works, lol.

SQL uses both, actually. Asterisk is used in SELECT statements and means all matching records, % and _ with the LIKE operator. _ works like DOS ?, and matches a single character. % works like DOS *, and matches zero to all following characters.

Thank you! As a developer for a number of years. I've had difficulty multiplying numbers.

Well, now you know. :D

In regular expressions, the asterisk is used to me "zero or more of whatever happened previously". Since an asterisk at the beginning of a regex is nonsense, we must conclude that there was a supercomputer previous to Deep Thought which computed part of the answer, which Deep Though is saying must be repeated indefinitely. In summary, the meaning of life is that it is something which goes on, and on, and on.

And the Earth was created by mice to compute the ultimate question.

@@chucku00 They only LOOKED like mice in this dimension.

Of course it was not able, there was a spatial detour to be constructed.

re: rounding problems inherent in a true binary calculator. Should be rounding problems inherent in a floating point calculator.

That, and as it has been the standard since "the beginning of time" there's really no reason to change. (Yes, many do provide a non-BCD interface. I'd not be overly surprised to find one using the 64-bit UNIX epoch.)

Cool

mwalsher. asm and nasm are standard GNU toolset. I worked with it on a modern computer to write a rudimentary OS just to learn how OSes work at the lowest level. Had a mix of C compiled to assembly and raw assembly to do a handoff for memory management purposes using PC memory management instructions. Pretty much anywhere I wanted to access the underlying machine from C, I had to write a two part C and assembly pair of functions to create a binding to the instruction and inject repeated setup stuff like stuffing args into registers and memory locations. It's great what you can do with a modern computer. My rudimentary OS is complex enough that it could handle a program and exposed an OpenGL 3.3 binding that had to be watched careful because keeping those alive without drivers is a real challenge. Originally I was going to try making a game on it but the binding management is so heavy that modern OSes with drivers handle so much better it's crazy.

Xilefian - A 'fun' something I discovered with PC CMOS RTC when investigating Y2K was that at least one design had a flaw for leap years, very relevant to all this. If you've got a value in pure binary, you can easily check if it is divisible by four by checking for zero in the least significant two bits, but this won't work for BCD. That fact didn't stop them trying! So consider the year 1992 (the century part 19, is just stored elsewhere as a static value not part of the clock), so we have just 92, in BCD, the least bits are not zero, so the defective chips did not have a leap year in 92, but for 94 and 98 they did! So if you have a vintage PC that gets the date wrong at the end of February, this is the little known about reason! Thankfully Y2K itself was a leap year because it was divisible by 400 and so an exception to the 100 year rule.

@Gerben van Straaten Hours : Duodecimal (or Tetravigesimal on a 24 hours basis) Minutes : Sexagesimal

in ML/AI, code you write sets up stats models which process input data for patterns to determine a response, instead of programming its behavior directly. you don't pre-load all outcomes, but models are flexible

SED - SEt to Decimal. An instruction on the 65xx. Makes it's math instructions operate on BCD values.

oh wow! great acheivement!

Yes, this is so often misquoted. They wanted the answer to the *ultimate question* of life, the universe and everything.

Thank you

And you would think that something is fundamentally wrong with the universe, but the calculation actually works in base 13!

So Windows XP is a gobble-based operating system. And Windows 7 is a meal-based operating system.

RaymondHng Sure if you like. But we never called 8-bit operating systems 'byte-based' in that context.

And what about 36 bits? 72 bits?

36bit = Mushrooms and 72bit = Peyote 😂

128bit = buffet?

Most early high speed scientific computers stored entire numeric (binary) words of data or an entire instruction in each addressable unit of memory (IBM 700 and 7000 series with 36-bit words, for example), so a single arithmetic operation required six memory cycles: fetch the first instruction, load the first operand into the accumulator, fetch the second instruction, add/subtract/whatever the second operand against the accumulator, fetch the third instruction, and store the accumulator in the desired memory word. These machines had the fastest arithmetic-logic units of the era, and wide parallel logic circuits that required the minimum number of CPU cycles per memory cycles to get the job done. But commercial computers, like the IBM-1401, generally had variable word length arithmetic and stored each character in its own memory location. Arithmetic and text operations were done with each character from one area of memory matched against its corresponding character in another, replacing one of them with the result. Their logic and memory cycles were also longer, making them much slower in raw computing power than the big number crunchers. But they were more than fast enough to keep up with high speed card and print devices and tape decks. Extra processing power to compute an invoice, payroll, or grade point average would be wasted if the data files could not be read or written fast enough. I once used the entire 132 character as an accumulator in a Fibonacci series program on a 1401, and even the 100+ digit to 100+ digit addition didn’t slow down the high speed printer (one line in 100 ms)! Only when the System-360 architecture, allowing a mix of binary and decimal (BCD) operations and memory accesses, was introduced, was a single machine practical that could do both kinds of processing efficiently.

x86 has similar instructions. I recently coded FizzBuzz directly in assembly and used exactly this to represent the counter.

Not any more it doesn't - long mode/x64 - reuses those opcodes for something else.

I did not know that, thanks for the addition. Although to be entirely correct, modern 64 bit CPUs still have these instructions, but only when running in any mode other than long mode.

Penny Lane Ti-99/4A had decimal base100 floating point.

IEEE754: 0.1 + 0.2

The IBM-1620 had BCD integer instructions, but to save logic circuits, they used a table in the first few hundred digit pairs to get the answers. The FORTRAN and other language compilers used library subroutines to implement decimal floating point.

Mister Hat The fixed decimal format is used in several circumstances, to represent both cents and percentages.

because some things, like small parts like nuts and bolts for example, cost less than a penny.

Yes, I ran into that at some point. I was looking at zero ohm surface mount resistors on an electronics website... (why would you want a zero ohm resistor? Well, obviously it's a jumper. It lets you build a single circuit board then bridge relevant traces to create various different options without needing an entirely new circuit board design.) And the way they're priced is... Interesting. I believe thanks to volume pricing it was roughly the same price to buy 5000 of the things as it was to buy 10? Can't remember the exact rates, but, yeah, cheap doesn't begin to cover it. XD Actually, looking it up.... A single unit is 13.8 cents. Already you see a fraction of a cent involved. But... Volume pricing at 1000 units is 1.9 cents At 10,000 it's 0.6 cents and at 50,000 it's 0.4 cents So in all cases you're dealing in 10ths of a cent. But also consider that the volume price is 1/34.5 of the unit price. And those '50,000 unit' volume prices... Yeah, that's going to set you back all of $200 But if you look at a slightly different version of the product with the same price for a single unit but that reaches a low of 0.3 cents at just 100 units... Well, those 100 units collectively cost 30 cents. While individually they cost 13.8 cents. Anyway, that's off topic really. But fractions of a cent do get used in some context, regardless.

Midrange and Mainframe's do... they use decimals (BCD - packed, signed, unsigned; along with other numerical formats) with the numerical length(s) and the decimal point(s) defined (both in the input fields and the result field independently defined) and with the ability to do rounding (half adjust) that works as expected without the imprecision of floating point calculations. It makes working with accounting or manufacturing data and transactions so much simpler (except where the result is ill defined and an overflow occurs or a lack of precision causes the result to be zero when the answer is less than the fractional part of the number). Its great for its intended use but falls down at the most annoying moments as the initial programming has to make some assumptions that don't always hold up over time.

Assuming you start with dollars and cents, that works for addition, subtraction, and multiplication, but it doesn't necessarily work for division, since you can get a part of a cent. And sometimes you even do more complex calculations involving higher maths. That said, using fixed decimal does exist, instead of using floating point. But it's going to be more than 2 decimal places. And, even then, it will ultimately have to round.

At this point we should really teach hexadecimal to our children and ditch decimal x)

I read hexadecimal for a living. I have to review register dumps in order to verify a design before we approve it for manufacturing. (display and camera controllers for an ARM system-on-chip). the 8 digit hexadecimal represents a 32-bit register. And the registers can have multiple fields packed into them, often weird sizes like 5 or 6-bit fields. Horizontal pixel count for display is 13-bits to represent 0 to 8191, and it's packed into the same 32-bit register with the vertical line count. I have scripts that decode the fields for me, but sometimes if something is weird I have to make sure the scripts are working correctly and I must work it out by hand.

Classic printers expect a 7 or 8-bit value for every character they print. Since the printer's capabilities will probably include things like 26 upper case, 26 lower case, 10 digits, lots of punctuation and special characters, you begin to see why the values need to be made larger than just the 4 bits being used by a single BCD digit. So, it was decided that the number characters would reside in the ASCII table from 00110000 to 00111001 (characters 48 to 57) so that the conversion could be done quickly by simply slapping 0011 onto the front of the BCD digit. It may be helpful to pull up an ASCII table online and look at how it's all arranged.

You can't really make it entirely dynamic. It's up to the programmer to decide what a sensible scale is when he uses something like Java's BigDecimal class. Otherwise the code has no way of knowing how far it needs to run a calculation. For example: the result of 1/3 is 0.33333333333... etc. If there was no fixed limit, it could theoretically use up all available space just to store that result, because it never ends. Even if you made a special case for periodic parts of numbers, you'd still have to deal with all the irrational numbers.

Yes there is. There are "infinite" precision integers (limited by system memory) and arbitrary precision floating point numbers.

Yes there is. There are "infinite" precision integers (limited by system memory) and arbitrary precision floating point numbers.

It's called 'arbitary precision arithmatic' and it does indeed exist. It's just really slow to compute with.

All 65xx processors have a single one-byte opcode that sets them to BCD mode (no other special BCD instructions needed).

See reply to Neil Roy (above)

Or, to sound fancy, you could call it a decimal power float. Scientific notation joys.

*thank you*

Surely that should be 43||!43?

@Jason You mean because 0x2bH === 0x43D?

True?

To A, or not to A? That isn't the question.

printf("0x2b | ~0x2b, that is 0xff (%#x) ", 0x2b | ~0x2b);

I really enjoyed that story, The last question, one of my favourites. Thanks for the memory jog.

Fiat lux

FYI, The correct way to type this would be: ``` There are 10 types of people in the world 01. those who understand binary 02. those who don’t 10. those who didn’t expect this joke to be base 10 ```

Actually, by that logic it would be: There are 11 types of people in the world 01. those who understand binary 10. those who don’t 11. those who didn’t expect this joke to be base 11

I think you mean 1 2 10

There are 10 types of people in the world: Those, who understand base two jokes; those, who understand base three jokes; those, who understand base four jokes; those, ....

There are 10 types of people in the world: People who understand hexadecimal, And f the rest

Next video :)

He mentions in the video that it takes a fair amount of work to convert a binary number into a BCD for output. Going into more detail would turn off a lot of viewers.

Gordon Richardson But this is computerphile, since it is not like they never explained algorithms before on this channel. I suspect that this was more of an introduction video, since the next video will be about it.