Name: 浮動小数点数 (Part1: Fp vs Fixed) - コンピュータマニア (Floating Point Numbers (Part1: Fp vs Fixed) - Computerphile)
Uploaded: 2021-01-14T10:38:08.000Z
Duration: 15 min 41 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

We were talking a few weeks ago about how we can add additional processes into a computers (sic) to do specialist tasks

One of the things we talked about was floating point processors

様態の副詞

Now these days they're built directly onto your CPU

But, you can still get some CPUs –some of the variants of the ARM CPU– and certainly if you go back in history

Some of the other CPUs you can get didn't have a floating-point unit. They could do math but they could only do integer math

So they could add 1 and 2 but they couldn't add 1.5 and 2.5

Well you "could" but you had to write the software to handle the fractional part of the number an do the math

and stick it back together in the right order. So I was wondering

What's the difference in speed that a floating-point person would actually make?

So as I said most computers we have these days have floating-point units of some sort built-in

So I went back to one of my old ones and I decided to write a program to test it

So I wrote a very simple program which does a 3d spinning cube. So the program is relatively straightforward

It's got a series of eight points which restores representation into a series of matrix transformations on them

To get them into the screen coordinates and then we draw the lines

so I did this using floating point maps and the programs running here and we can see it's

Reasonably quick it takes no point not for five a second to calculate where all the screen coordinates need to be for each frame

sometimes varies but that's in general what it takes so I then went off onto a

Ordered myself a floating point ship for the Falcon and I then inserted it

into the machine and I recompiled the program this time to use

The floating point unit. So this version it's doing floating point maps

But it's all being done in software this machine code instructions for the six 8030 chip in there

To calculate all those different floating point numbers

so then we compiled the program this time to actually use the floating point unit and

This version runs about 4.5 times faster it takes no point

Not one seconds rather no point naught four five seconds to do exactly the same calculations. This is exactly the same source code

I just recompile a using GCC to produce a version that used the floating-point

Unit and you can actually see that the graphics are slightly smoother and the time is much less

So the fact we can speed it up by doing it in hardware. Perhaps isn't that surprising?

There's lots of tasks where you could either implement it in software or implement it in harder

And if you implement it in hard way it's often

Faster to do so so we are going to try that but it's actually worth thinking about what's involved in adding up

Floating-point numbers Tom did a good video

Right back at the beginning computer file looking at how floating-point numbers are represented as a sort of high-level and it will say well

It - naught point nine nine nine nine nine nine nine then after a while

you'll stop but actually when you get down to the sort of

Level of the computer's having to deal with them and see how they're stored

It's quite interesting to see how they're stored and how then manipulating them

Are you writing software to do something simple like adding two numbers together?

Actually ends up being quite an involved task compared to adding together two binary numbers

So let's look at how we add numbers together

So let's let's take a number and to save time I've printed out the bits. So let's take the number

Let's say 42 because why everyone who uses that so we've got here the number 42 is one zero

One zero one zero and then we need to fill the rest of these with zeros. Well ignore that for now

So that's bit naught over on the right hand side through two bit

One two three, and these of course are the same with the powers of 2

So 2 2 zeros is ones two to the one is two four eight

Just like we have powers of 10 when we do decimal numbers. So let's everyone to add together 42 and

23 so I've got another binary number here 23 so the same bits and

We'll just basically do addition. So 0 plus 1 Shaun is

0 and we have to carry the 1 0 plus 1 plus 1

We've run it up 42 this numbers 23 42 plus 23 is 65 and sorry produced

So rubbing up in binary is a relatively straightforward thing

What we do is we take from the right each pair of bits add them together

We also produce a carry bit and then we add the carry on in the next column just like we do

And you can generate systems that represent

I guess they'd be called or fractional numbers

Using this so you can use a system which is quite common

Was used in Adobe Acrobat as used on the iOS for 3d graphics at one point

which is fixed point numbers where you say that say about 32 bits the top 16 bits are going to represent the sort of

Integer part the bottom 16 bits are going to represent

the fractional part and the basic way to think about that is you multiplied every number by 6 on

65,536 shifts everything along and then when you want to produce the final result you divide it all by 6

65536 now the problem with fixed point numbers is that they have a fixed scale

Fixed is key in the name. So for example, if we use

32-bit fixed point numbers splitting into 16 bits and 16 bits. That's great. We can go up to

65,000 or so on the integer part, but if we need to get to 70,000 we can't story

65536 the other thing we'd agree to go to 1

1072 sort of a thing we can't because we don't have that resolution on occasion

We need the bits down here to represent very small quantities and occasion

We want them to represent very large quantities for something like 3d graphics or graphics in general

Fixed point numbers can work. Well for general-purpose things. They don't work that well

So what people tend to do is they use floating-point numbers, which is the right things as tom said in

scientific notation so rather than writing

102 4 we write it as 1 point 0 to 4 times 10 to the 3 so we're using scientific notation

We can do the same in binary rather than writing

One times two this time rather than 10 to the 1 2 3 4 so we can write it 2 to the 4

So what floating-point numbers do is that they say okay rather than representing

Numbers using a fixed number as bits for each we're going to represent them in scientific notation effectively. We're the sort of

Number that were then going to multiply by 2 to the something to shift it to the right point to make things absolutely clear

Decimal numbers here to represent the 2 times 10 to the 4 so I will cheat and use this here

102 the 1 0 0 so I guess the question that remains is how do we represent this in a computer?

We've got to change this notation, which we can write nicely on a piece of paper to represent the binary number

字幕リスト動画再生

浮動小数点数 (Part1: Fp vs Fixed) - コンピュータマニア (Floating Point Numbers (Part1: Fp vs Fixed) - Computerphile)

sort

significant

slightly

trick