@@paranjaynajan7717 Let me explain... Basically the whole error comes to the lack of needed bits. Your number is "made" out of powers of 2.
So decimal numbers are represented as
2^(-1) = 0,5
2^(-2) = 0,25
And so on...
To get all the necessary numbers "inbetween" you add a combination of these powers of two together.

But... Here comes the problem... There is only limited number of decimal bits available in your computer. So there's a limit to how precise your decimal number can get.

And when you play with different numbers it sometimes "overflows" and gives you less precise number than it theoretically should.

Hope it makes a bit of sense since I am not very good at explaining shit xD

@hi-ip2pj

2y↑12

step 1:
cut off anything before decimal and make result an integer
step 2:
add the results together
step 3:
cut off decimal and .
step 4:
add the results together
step 5:
make a string like this
{result from step 4}.{result from step 2}
step 6:
convert it to float

@Brad_Script

if I had to create a calculator in any langauge, I would create a Fraction class and store the number as an integer numerator and denominator. Then I would implement addition/mult/etc myself. It obviously slower than directly doing it on the CPU but it's 100% accurate.

0.1 + 0.2 becomes 1/10 + 1/5

then you would find the lowest common denominator, which is 10. then convert both fraction to take that denominator

1/10 + 2/10

the addition in here is simple, just add the nominators

3/10

you would then return that value as a Fraction object. You can then create a "toString" function to convert this to a number if you need it for display.

All comments from YouTube:

@LowLevelLearning

2y↑246

🔥COME HANG OUT ON TWITCH 🔥 https://www.twitch.tv/lowlevellearning

@williamdrum9899

First it was buffer overrun, then floats, what could be next. How about alignment faults?

@clementpoon120

2y↑2

stop making people think that c is hard

@zyansheep

BigNum gang...

@official-obama

step 1: prove 0.1+0.2=0.3
step 2: put it in comments
step 3: ???
step 4: profit

@gurrag79

Give me the dope on youtube man... I need it, bad.

6 More Replies...

@amateurprogrammer25

2y↑7.4K

> "Programming in C until I go insane"
> Video is 1 minute and 15 seconds long

Sounds about right

@irian3x3

1y↑85

Too long.

@RaymondStormbl3ssed

1y↑72

That’s 1 minute and 10 seconds too long

@mbunds

1y↑20

He lasted 1 1/4 minutes? Superhuman!

@irian3x3

1y↑10

@@Stay_away_from_my_swamp_water that's what she said

@bestwarwickla2

1y↑20

python pfp checks out lol

9 More Replies...

@Marcox385

2y↑12.7K

My guy, with "low level" in his channel name, went to Javascript and expected a better outcome lmao

@LowLevelLearning

2y↑3.3K

I WAS DESPERATE

@alecgreene9436

2y↑296

the way a lot programs circumvent this is by using ints right? you do all the math on ints and manually adjust results based on a fixed assumed number of decimal places

@echoes6092

2y↑118

@@alecgreene9436 yeah—or if you're doing it a lot, implement a class/type of Decimal (or use python with the built-in one) that does the adjustment for you

@RandomShowerThoughts

2y↑1

🤣🤣🤣🤣

@sahlaysta3399

2y↑44

@@alecgreene9436 java be like BigDecimal

35 More Replies...

@macewindont9922

2y↑6.8K

You must be truly desperate if you turned to javascript for math.

@LowLevelLearning

2y↑975

Times were tough

@31redorange08

2y↑10

Why?

@ramazanakbal6616

2y↑229

@@31redorange08 javascript coding is terrible in mathematics. You can't even add 0.1 to 0.7.

@31redorange08

2y↑41

@@ramazanakbal6616 Yes, you can. As can be seen in this video.

@melonenlord2723

2y↑96

@@ramazanakbal6616 You can, but not with matical perfect precision. In most cases it's enough.

33 More Replies...

@hosytaa_1449

2y↑2.8K

Funfact: this used to be called "coding in floats made me go insane"

@panickal

2y↑23

Wtf he made it worse??

@Wunkolo

2y↑129

@@panickal seems like he just wanted to target this towards C even though it's an IEEE 754 floating point precision problem that would happen in any language that uses single-precision floats.

@dimi5862

2y↑5

@@Wunkolo that happens at any precision

@rz1165

45w↑1

@@Wunkolo Can confirm, this problem exists in Java as well

@yonderalt2662

33w↑12

Floating point math makes anyone go insane, REGARDLESS of the language. Computers HATE decimal points. They work with two whole numbers: 1 and 0.Any "abstraction" that treats numbers as not whole will be a hack of an implementation, no matter how ypu approach it

4 More Replies...

@vilakshangupta3200

2y↑2.1K

Everyone in comments: Tries to give logical solution
Giga Chad: Just prints the number

@SKC_car

2y↑49

it is kinda a solution
if a+b
then print the number lol (not the answer, just print 17 times 0 + .3)

@Thraiel

2y↑248

GIGACHAD printf("3.00000000000000000");

@bruhmomenthdr7575

2y↑129

@@Thraiel Ah, yes. 0.1+0.2=3.00000000000000000

@orcpeon4781

2y↑12

@@Thraiel print("3.00000000000000000")

@rusluck6620

2y↑17

@@orcpeon4781 printf*

6 More Replies...

@toshimichi

2y↑7.6K

Him: tries to get 17 digits of accuracy
Me: laughs with COBOL

(COBOL has built-in binary-coded decimal support)

@alexandernyberg8668

2y↑3.2K

The only time in history a COBOL programmer has been happy about their choice of language

@evanbarnes9984

2y↑649

@@alexandernyberg8668 don't people who program COBOL tend to get seriously paid for maintaining legacy systems? Seriously though, at one point I was really curious and thought I'd try learning a bit of COBOL... What a monstronsity

@ktsnowy

2y↑235

COBOL actually uses decimal floating-point arithmetic, and not fixed-point

@Yukinebi

2y↑43

@@alexandernyberg8668 this comment killed me lmao

@9SMTM6

2y↑23

@@ktsnowy that's important, I mean fixed point arithmetic is probably gonna be present in every language in one or another shape.

68 More Replies...

@andrewrichesson8627

2y↑3.3K

float imprecision is fine until it's time to compare two floats. Then things get messy fast.

@spicynoodle7419

2y↑109

just use the epsilon, ez

@rsa5991

2y↑171

Funny how people blame float comparison problems on "imprecision", even though they are actually happening because floats are too precise.
Like, epsilon comparison is literally "comparison with reduced precision".

@pretzel7247

2y↑358

@@rsa5991 but the values are wrong just very precisely wrong

@raymundhofmann7661

2y↑37

@@spicynoodle7419 Will not protect from accumulated rounding errors.

@spicynoodle7419

2y↑6

@@raymundhofmann7661 well yea, there are other strategies for overcoming that.

30 More Replies...

@MatteoDeCarlo

2y↑58

The issues lies in 0.1, which in binary format is a periodic number. Periodic numbers cannot be saved in finite memory, so it gets truncated to 32 bits in C and 64 bits in python and JS, which use doubles as default.
To be precise less than 32 because not all bits are dedicated to the value, some are dedicated to other stuff like the exponent.

@Scarletraven87

15w↑2

👏

@eng.shh80

2y↑220

If you wanna get a 17 digits of accuracy then it's better to use double instead of float as fixed decimal point cannot represent all the fraction values.

@HelloForeignWorld

24w↑24

No computer can represent all possible fractions, so with limited memory you will always get inaccurate result under specific circumstances 😅

@danielsurvivor1372

24w↑2

First of all, wtf is dat.

And second, why y'all doing math, I thought it's coding stuff and not math stuff 😭

@koresaliva

20w↑33

@@danielsurvivor1372 Coding requires math tho, expecially if you get technical about it cough cough binary

@PixelThorn

19w↑3

Unfortunately if won't save you either, there is still a small error on the 17th decimal

@PixelThorn

19w

@@danielsurvivor1372float is 32 bit decimal type, double is 64 bit, i. e., double the memory available for decimal value representation

5 More Replies...

@bruceliu1657

2y↑856

2^-exponent is how numbers are represented in memory. This is a artifact of the base 2 system vs the base 10 system. python and javascript likely used a larger regsister. of 64 bits which 51 are allocated to decimal places. Which is a double. float uses 23 bits for decmal

@huhulili9021

2y↑4

Thanks for the explanation!

@Ruhrpottpatriot

2y↑32

Python doesn't even have a 32bit float, it only has a 64bit double.

@nikitademodov3446

2y↑5

How is this related to counting systems? You can write rational numbers in binary too: 0b0.1 -- there you go, that's 0.5. It's just that you'd need infinite memory to represent all numbers, but that's true for both binary and decimal.

@dennishou5944

2y↑85

@@nikitademodov3446 It's because we have the same problem in base-10 that exists in base-2. For example, 1/3 = 0.3333... but if only a fixed number of digits can be stored, then it becomes truncated as 0.333. Then, 1/3 + 1/3 + 1/3 is no longer 1, but rather 0.999. The same problem occurs with base-2, but because it is a different base than base-10, something that works properly in base-10 may not work properly in base-2 for the reason mentioned above.

@angeldude101

2y↑44

Everyone makes fun of 0.1 + 0.2 != 0.3, but that's literally true for every repeating fraction in existence regardless of base. Decimal is base 10=2*5, so it's great at representing fractions with denominators with prime factors of 2 and 5. Binary is base 2, and while it has major benefits in other areas, it can only represent fractions with a power of 2 denominator. Both systems fail to represent 1/3, 1/7, or 1/11 precisely.

15 More Replies...

@vari1535

2y↑541

"We literally shot lightning into rocks and tricked them to think." That is an AMAZING description of computers.

@dimi5862

2y↑26

They don't think though, all they do is extremely basic logical operations extremely fast

@thefreemonk6938

1y↑10

@@dimi5862 AI/ML says hello

@meta___

1y↑49

@@thefreemonk6938 technically it's still just mathematics and not actual thinking

@PAUL-ESNEED

1y↑22

@@thefreemonk6938 Still not thinking. Just compiling a ton of data with programmed rules of engagement.

@meowcat5596

1y↑44

@@dimi5862 nigga our brains be like that too, just some neurons firing extremely fast

16 More Replies...

@tomaspecl1082

2y↑531

Using two integers to represent a fraction is the way to go.

@pyromechanical489

2y↑20

or using some sort of fixed-point conversion!

@abhinavchavali1443

2y↑5

Lisp ftw

@9SMTM6

2y↑11

That ain't floating point.

I'm not sure it'd even be possible to really, mathematically correctly, solve the task, since all floating point numbers and their operations are not going to be well behaved in some instances, but if you choose a floating point representation that has a common denominator of the 3 numbers as basis, eg, decimal, it should get you most of the way.

@FunkyTurtle

How?

@okb6436

2y↑3

That way you can represent rational numbers, not real numbers

26 More Replies...

@SameAsAnyOtherStranger

2y↑645

Other than recalling some problem Intel had with the release of early Celeron processors, I couldn't really say how floating point decimals are problematic. I just know that they are. But you said in the video description that it was a matter of you maintaining your sanity for me to leave a comment, sooo...

Did you try turning it off and turning back on again?

@miguelguthridge

2y↑15

Another good one to try is 1.2 - 1.0

@eddieromanov

2y↑37

Old Celeron joke: At Intel, quality is job 0.99999995.

@chilldude1337

2y↑21

it is about binary numbers and IEEE754 standards for representing these specific fractions. Some values just cannot be represented as a finite sum of powers of 2. 0.3 is an example of it

@nadie9058

2y↑8

If I have my facts right, it is something similar to representing the number 1/3 in decimal, it is 0.333333... but the processor need to have it as a finite number so it truncates it. The result, when converted to decimal for us humans to understand, is different from expected as the truncation part loses information. I believe Computerphile has a video on this matter.

@fake12396

2y↑9

Another one stolen from reddit:

Scientists discovered a new hydrogen isotope with an atomic mass of 4.99999998, they named it pentium

7 More Replies...

@recarsion

2y↑112

I mean this isn't really a C problem so much as a floating-point type problem.

@cgme9535

2y↑4

Right

@lyrapuff7502

2y↑25

Left

@madbruv

2y↑2

@@lyrapuff7502 freedom not sides

@TheMightyShell

2y↑1

@@madbruv freedom is immaterial. If it can't be measured and made tangible then how are we ever supposed to come together over it? Thats what makes money so powerful

@geeshta

2y↑56

If you're forced to say "JavaScript, please" it's already too late

@raz0229

2y↑64

I got 1 minute of time left and I'm glad I made the right decision to click this video

@LowLevelLearning

2y↑8

welcome :)

@HonsHon

2y↑5

Time left for what?

@backfire10z29

2y↑6

@@HonsHon life

@jimmycimitir7754

2y↑5

@@HonsHon yup, he dead

@HonsHon

2y↑1

@@backfire10z29 I so sad

1 More Replies...

@cock_sauce8336

2y↑94

I love the fact that sometimes when you divide different numbers and it should get you the same result it still gives you a bit different floating point number. Now that's something I lose my sanity over because if you compare those two it can give you an uneven result. Sadge.

@gownerjones1450

2y↑2

Just never use floats

@cock_sauce8336

2y↑4

@@gownerjones1450 Eeehm... Have you ever heard of hardware ? Don't say "never" since there are many handy uses... Just not for the ultimate precision xD

@gownerjones1450

@@cock_sauce8336 Never use them. Easy.

@paranjaynajan7717

But why does it do that?

@cock_sauce8336

2y↑18

7 More Replies...

@rasowa2958

2y↑196

When you do thousands or millions of operations on floats this easily can become real issue.
Whenever I can modify the problem to use integers I often do. Integers are faster and precise.

@cyberwoodoo9466

2y↑3

Languages have different classes libraries to deal with such things , there's biginteger bigdecimal , numpy in python .
So you're just let's less informed about this whole thing.

@rasowa2958

2y↑49

@@cyberwoodoo9466 The problem is that operating on these special types/classes is waaay slower than using native types, and the error still occurs just on further decimal place. You are basically trading speed for better precision.
If your algorithm requires millions or billions calculations than speed may already be an issue.
If you can solve such problem using integers, this is a way to go, it is way faster and with no precision issue at all.

@cyberwoodoo9466

@@rasowa2958 you seem to be confused with coding time and actual calculation time , and if you're talking about coding time then yes learning diff thing takes time 😀

@rasowa2958

2y↑43

@@cyberwoodoo9466 No, I'm talking about calculation/execution time. Operations on native types are executed by CPU in one instruction. Operations, even such simple as addition, on non-native types require running whole another algorithm. It takes many many times longer.

@moochoopr9551

2y↑21

@@cyberwoodoo9466 You never coded them before ain't you?

20 More Replies...

@CaptainMaderik

2y↑231

You could use "long long" instead of "int" and then multiply your number by 10 to the 17th power, afterwards you find the sum and devide it by 10 to the 17th power :D

@agenta6412

1y↑19

Nice Google search

@gandalfgrey91

1y↑6

Dividing is too slow

@Nartymer

1y↑13

I used to do that in 9th grade when we learned c++ and had those dumb tasks of showing smth like the circumference of a circle with a 2-decimal precision and 0.01 approximation error and it would give me 80/100 points every fucking time until I did that

@jktech2117

1y↑1

or do the code i wrote on the comments of the vid

@Dom-zy1qy

26w↑5

@@Nartymer Highschool with a c++ elective? Surprised they're able to pay someone who knows C++ enough money to teach there. Also sounds like the curriculum would be too densely packed for a single semester class if it was.

But i can understand if c++ was just basically being used for script like things. Otherwise you'd have to divulge a lot of CS info.

3 More Replies...

@late7245

2y↑376

Use long double instead of float and use %.16Lf\n for printf

@custardtart1312

2y↑73

Dude, we all know that, therefore you totally misunderstood the point of the video! Whooooosh!! 🤓😜

@parkersmule

@@custardtart1312 loser comment

@groszak1

2y↑11

That won’t work in Microsoft Visual C++ and won’t work in ARM computers.

@grahamthomason8796

2y↑376

@@custardtart1312 Not everybody knew that (me for example). Don't make fun of people for posting useful information bruv

@kdoseptal

2y↑15

still does not solve the issue, just moves the precision "point" further from the decimal point (but it would satisfy the task, so you're right i guess)

10 More Replies...

@hi-ip2pj

2y↑12

@Mutual_Information

2y↑13

Before grad school we had to take a "pre-program" course on C++.. and it was by far the hardest class I took at that school. And that was Berkeley financial engineering.. there were some other seriously hard classes. C++ is not a drill.

@danielgracia6870

2y↑101

For videos like this is why I appreciate that our computer architectures professor taught us about IEEE754 standard for floating point number representation. It's so cool to understand why this happens.

@AsianSadge

1y↑8

Your computer architecture course code didn’t happen to be 323 did it

@odin1eye684

2y↑5

I want float theme merch!! Would go perfect with all the other stuff I got from you! Amazing. Best upcoming YouTuber right here

@LowLevelLearning

2y↑1

low level gang

@sprytnychomik

2y↑81

17 digits of accuracy using float might be a real challenge.

@bit2shift

2y↑8

it's not, just use "long double"

@BSPNode

2y↑2

@@bit2shift not all compilers / computers support “long double”

@bit2shift

2y↑7

@@BSPNode support your claim with a contemporary example of each 🙂

@MrBJiagge

44w↑1

Use double

@mortonmckoy1787

28w↑2

@@MrBJiagge yeah but float inaccuracy makes that the point of the challenge, how can you round the float to the nearest tenth while retaining its accuracy 17 digits in

1 More Replies...

@mohamedaymen1714

45w↑14

I just passed my exam and I made a huge mistakes , even though I studied very hard and I know that I was better then all of people around me and at the end I’m watching your videos to chill

@eduardkolesnik5819

2y↑2

My favourite PL to do calculations is CSS. Awesome "calc" functionality with pixel perfect precision. Usually when I want to make some high precision calculations, I just parse the value from width that was calculated via "calc" function.

@miicro1

2y↑4

As someone who is learning C++ and is currently experiencing things like this where more errors comes after another (even if the compiler shows no errors). This is quite funny

@shazmunchdylbertoid

2y↑22

I had to write a scientific calculator in typescript and Jesus I felt this

@DavisTibbz

31w

Oh no 😢 TS and maths

@Brad_Script

@andrekanara3818

32w

You make coding fun again. Re ignited the fire in me. Thanks bro from christchurch new zealand. Chur

@phillipgatlin1138

2y↑10

1) I suppose you could do the arithmetic manually for each place value, starting from the place of least value (i.e. the 17th (1 / 100 000 000 000 000 000) place value behind the whole value point) and then just do the arithmetic like its a whole value number (don't forget to carry), and finish the calculation when the computer reaches the fraction point. Doing arithmetic this way would also make it possible for arithmetic computations of arbitrary length (or how much memory you can allocate) if you store each place value (each digit) as a byte value in memory as in an array, you could even use ASCII characters to represent the digits but it would be more work than necessary converting between ASCII characters and numerical values, and be careful not to store a value greater than 9 in a place value, and you would still need to deal with overflows, and preserve the sign of a number, you could just use a bool for this. This probably wouldn't be as fast as using variables and literal values, like what the man in this video did, but this method should produce the correct result with floating point values. I would only do this if precision were really really important. This is basically doing arithmetic like the way you was taught in elementary school.

2) Or you could just convert the floating point values to integer type values, save the precision value, do the arithmetic as integers, then convert the types back to float values by dividing them with the precision value (for a precision of 17 place values this would be 1 / 100 000 000 000 000 000.

3) Try using a double or long double data type.

@kintustis

Start by getting some bitches first

@applesthehero

2y↑25

Telling a computer to test if 0.1 + 0.2 = 0.3 is like telling a human to test if 1/3 + 2/3 = 1, but using only decimal numbers not fractions (so 0.333333 + 0.666666 = 1)

With decimal numbers, 1/10, 1/5 and 3/10 can be represented precisely with 0.1, 0.2 and 0.3 because decimal is base 10. In base 10 you can precisely represent any fraction whose denominator is a sum of powers of the prime factors of 10 (2 and 5), and only such fractions. Introduce a multiple of 3 or 7 to the denominator, and you can now only approximate with decimal representation. With base 2 numbers (what a computer uses), you can only precisely represent fractions with a denominator that's a power of 2. 5 is not a power of 2, so you simply cannot precisely represent these numbers precisely in binary like you can in decimal.

Side note - this is one of the reasons people advocate for use of non-decimal numbers! Base 6 and 12 numbers allow you to precisely represent fractions with a denominator multiple of 3, for example. In base 6, 1/3 is simply 0.2, but 1/5 can no longer be precisely represented.

Pro tip: if you're having trouble working out what a fraction is in a different base, try multiplying it by the base first, then shifting the decimal back! (e.g. 1/3 in base 6 -> 6/3=2 -> 0.2)

@azozyhd3166

2y↑1

Respect

@longsteinpufferbatch4949

Thank-you
This helps a new learning programmer like me

@agrihonoberjorn1612

Thanks for the lesson take my like

@6754bettkitty

2y↑6

Gotta love floating-point arithmetic on computers!

@rafaelbordoni516

2y↑5

I remember I wrote a constructor for 3D vectors in Javascript, with normalization, dot and cross products, all that gist for a presentation I was assigned and as I was testing it, the cross product of any vector and it's normalized wasn't zero. No matter the vector, it was always the same almost zero number. Just told them it was floating point sorcery when I did my presentation.

@timangar9771

2y↑1

And was it?

@torchinthetowninthebentgra2070

2y↑1

You sir have made my night. I award you 10/10 for your sadistic computer science humor. Professors be like this though. This can't be done with a float type. Type float provides precision up to 5 decimal places. A long double on the other hand provides precision up to 19 decimal places and is also a floating-point number. Therefor we can declare the variables as type long double and use the following print statement: printf("%.19Lf \n", zeroPointOne + zeroPointTwo);

@abhishekpanthi6496

2y↑87

more scary thing than this is when my compiler design teacher gave me a small code and told me to explain phases of compiler with the help of the given code while making diagrams of all parsing steps it was kinda hard

@mradulagrawal1579

Oye tu yahan pe😂

@omarjimenezromero3463

16w

ayo, "compiler design"? if you not started with assembly i do not know how tf your teacher wanted you to explain it by yourself XD.

@erikkonstas

15w

Our Compilers class was really just yet another intro to languages and automata and then parsing algorithms, plus a bit of semantics... 😂😂😂 We never had to design an actual compiler.

@xDMrGarrison

2y↑3

I don't know what just happened, but I was still amused

@dominionian7193

35w

IEEE754 standard for finite precision floating point. In C, "float" is usually 32-bit single precision. For your 2nd and 3rd attempts, those were double precision.

@psdmaniac

2y↑3

IEEE 754. This is one of many examples that graduating IT is helpful.

@Hunar1997

2y↑5

In picolisp we have something better (needs practise first) than IEEE floats, scaled fixnums .. here we (scl 17) , then (format (+ 0.1 0.2) *Scl) you'll never encounter a float error

@Wolf-if1bt

2y↑3

These artifact come from the limited memory size of float and the fact they're stored in base 2 (and converted for display). All you've to do is develop your own arbitrary precision library for float in base 10.
Otherwise, throw out your computer and run your program on a HP48 calculator that stores and compute float in base 10.

@amilachinthaka3399

2y↑1

0:54 this one literally cracked me up🤣🤣🤣

@grass324

29w

limited attempts is literally hell

@01001000010101000100

2y↑17

If you used double instead of float you'd get a better result. To get exactly 0.3 you would have to use a different type like "decimal" that isn't built in C. I bet there are some libraries for that though. BTW, the reason the result is not exactly 0.3 is it's a binary floating point, not a decimal floating point. I don't ever touch it, I don't ever think of it. For practical use I just round the result when I need the exact value with a known precision and it works. BTW, the binary floating point is used because it's faster for the hardware to do the calculations. It's easier for the CPU, it counts and does all operations in binary so it's a minimal work for it. To make it work in decimal domain you need some extra steps that take time. Sometimes it's desire, so for those special cases you have special libraries. There are, for example, libraries providing really big numbers, like not limited to 64-bits. I played with one to calculate PI up to a very large number of digits for fun. There are plenty of methods for that, some of them use operations on very large decimal numbers, the other ones work all in binary and they are faster.

@cashbuyer4221

43w

If you put in %.2lf it would round to 2 digits

@Brad_Script

yes, that's what python and javascript use. That's why their values was closer to the real answer than the C program.

@guidichris

2y↑5

Makes perfect sense once you look closely at how .1, .2, and .3 are represented in binary.

@WarpRulez

2y↑5

The assignment doesn't specify that you have to use base-2 floating point numbers. Thus you can use base-10 floating point numbers. (Of course you'll have to implement them yourself, but they will give you the accurate result.)

@Jasmixd

20w

The assignment doesn't explicitly forbid the use of other data types, so you might as well implement fixed point arithmetic to the desired precision using integers and cast the input floats onto integers after multiplying them by a power of ten.
Or would that be bending the rules a bit too much?

@superkoksu487

first thing we were thought in uni about floats is to not compare them with ==
only ever with either < , > or <= , >=

@cheng1552

2y↑22

now this is where we look at the good old IEEE 754

@janholasek324

2y↑4

With float precision being 24 bits and 2^24 = 16777216, there is no way the number could be more precise than 7 or 8 significant digits. It is 7 digits here as 0.3 > 0.16...
This is what we can see in the output where 0.3000000 is precise and the rest should not be relied on.

@batuhangercek8158

2y↑1

that's where posit arithmetic really becomes useful

@blacklight683

2y↑2

(*goes insane in 2m*)
Game devs doing 3h+ for 4years:am I an insane to you?

@alexrossouw7702

2y↑41

You don't need 17 digits of accuracy when you merely sum floats with only one decimal digit each. Pad the rest with zeros and move on with your life.

@unflexian

2y↑29

when you're a bank and someone just deposited 0.2$ you suddenly start caring if money is being created

@wnsjimbo2863

2y↑16

@@unflexian banks use large integers for money and not float

@unflexian

2y↑2

@@wnsjimbo2863 I know, I was demonstrating the problem that led to this being used.

@Fine_Mouche

2y↑1

How you adding / padding n times 0 to a number ?

@alexrossouw7702

2y↑2

@@Fine_Mouche snprintf() in C

@johnbaxter7582

2y↑40

The lesson is: use floats at least as possible, try reducing it always to natural units (unsigned integers of any length)

@clementpoon120

20w

fixed point ftw

@MrSonny6155

20w↑1

To an extent I would agree, but there are many situations where perfect accuracy isn't needed while both speed and size are. This advice only holds for the most generalised, high-level applications like my hotkey script.

Sure, in some ways this is slowly becoming less of a problem in a world where good integrated hardware is affordable. But you know what's cooler than a game taking 16GB in RAM or 30 seconds to load a map? A game that takes only 1 each max.

@johnbaxter7582

20w↑1

@@MrSonny6155 yeah I agree, but I appreciate the clear 100% predictable existence of ints. I'm taking about very low level systems here

@whowho-bd6xb

18w

I have been learning coding for a few days and i understand more than i would think about what u are writing. god damn getting into coding isnt as horrible as it might seem

@erikkonstas

15w

Please be careful, when you meet a concept called "fork", it's very easy to end up with another one with the word "bomb" next to it...

@galaxytheinter6332

2y↑1

coding in c until I go completely insane
1 min video
me: seems about right

@gregtasi

2y↑15

Javascript please! - Had me dieing 🤣

@LowLevelLearning

2y↑1

XD!

@thearmyofiron

@@krellin yeah, all numbers stuff are doubles by default

@thearmyofiron

@@krellin that is what happens when a language is designed in haste. JavaScript was designed in less than 14 days

@HansBezemer

2y↑4

It's dead simple - write your own floating point routines, radix decimal. One integer for the exponent, one for the mantissa. Now do your addition and voila: infinite accuracy.

@Schnorzel1337

You take two integer and produce infinite accuracy. That does violate laws of computer science, math and even physics, maybe even religios laws.

@HansBezemer

@@Schnorzel1337 Not if you add two decimal values. In that case they are perfectly represented - and hence have infinite accuracy, but still limited precision of course.

@n00blamer

@@HansBezemer Infinite accuracy implies infinite number of decimal places, kind of impractical.

@HansBezemer

@@Schnorzel1337 What you mean is "precision" - which is the number of digits a number representation can hold. "Accuracy" is how ACCURATE a certain number is represented.

Irrational numbers CANNOT be represented accurately by ANY representation.

However, a representation of exponent -1 and mantissa 5 is an accurate representation of 0.5 (base 10), since both its relative and absolute error is infinitesimal.

@SamirPatnaik

Best intro to the origins of garbage collection timeline

@TeaBroski

1y↑1

You recognize a person of culture when you see their bash muscle memory going ctrl+r even for the last command they used

@ac3_train3r_blak34

2y↑8

hoping for a "but why though" follow-up. great video!

@rsa5991

2y↑8

1/10 is an infinite fraction in binary.
It's kinda like 1/3 ~= 0.3333333, but 0.3333333*3=0.9999999 !=1. Except in binary.

@mukulkumar8681

2y↑4

What you really need to know(and others who are perplexed) : https://en.wikipedia.org/wiki/Double-precision_floating-point_format#IEEE_754_double-precision_binary_floating-point_format:_binary64

@mukulkumar8681

2y↑2

Basically float carries 7 digits in precision and double carries 16 digits(trying to view more precision values shows garbage values), and due to the nature of the way floating values are stored, the answer to 0.1 + 0.2 is not equal to 0.3 precisely.
...
...
well, if you found this interesting and understood all that, you can take a step further and try to understand FISR algorithm

@frosty7674

2y↑2

The moment you opened up javascript i was like monkas

@bagzhansadvakassov1093

Floats are put in memory to a certain degree of precision. You can think of it as compressed image which has pixels, accurately enough creating picture. Floats are not compressed, but the number line is cut into blocks. But, you can avoid these problems if you have memory to represent numbers.

@brucerosner3547

2y↑6

I assume the question wants you to fool around with a so-called epsilon. Compute .1 + .2 + 10^-17. If it equals .1 +.2 you have 17 digits of precision. Maybe you should try 10^-16 and 10^-18 as well.

@davidwuhrer6704

Doesn't that just prove that floats don't have 17 digits precision?

@yeppiidev

2y↑4

slap on some double precision boi!

@cave_0

Came here to say this. A float is only four bytes

@yeppiidev

@@cave_0 wait so where do the extra data go?

@alexandernyberg8668

He did, that's what Javascript and Python use

@yeppiidev

@@alexandernyberg8668 yeah but he used a normal float, not a double precision float

@alexandernyberg8668

@@yeppiidev In the Python and Javascript examples he most certainly did

1 More Replies...

@abel090713

2y↑1

I was asked this during an interview and the best response i could come up with was "uhm"

@AlexAnder-dh8qz

51w

Imagine my rage, when in university I had task for function approximation, when requested approximation method headed to division of number that is close to 0, but not a 0 and it was out of double size, so automatically turned into 0. Spent hours to understand why operation that can't produce divizion by zero actually produced it somewhere in thouthands of iterations.

Some higher math things makes float and double a real pain, same as large amount of money sums could become a total mess for business reports and account totals when you use floating point based data types. Answer is simple - use special data structures that implement high-precision floating point operations.

@ZakariaHABRI

2y↑8

I have a dumb question. Why are you writing 'argc' and 'argv' when you're not expecting any input from the command line ? And are not using those variables ? Is it convention or something ? Nice vidz !

@vaccino3668

what if he wants to enter numbers through the terminal

@savagesarethebest7251

It is not just convention, but I think that it is required by the standard? But it is probably OK without depending on the compiler

@jek4397

2y↑2

@@savagesarethebest7251 Not required to compile a C program, but lots of CS students are taught to do this whether or not they need it

@obed818

2y↑6

Mathematicly speaking you cant prove a result by ask a computer to do it lol

@Tabu11211

thats actually the most profound takeaway from all of this imo

@obed818

@@Tabu11211 that’s right ahah

@xerzy

if people knew how many pages of formulas and reasoning are ACTUALLY required to prove 1+1=2... lo and behold, see Principia Mathematica for yourselves (and don't even bother about rational let alone real numbers) (also no, we don't use Peano's axioms in this blessed house)

@obed818

2y↑1

@@xerzy what a witchery

@ko-Daegu

@@obed818 360 pages proofing 1+1=2, t’s all done in formal logic. they first define what's a ‘1’, ‘2’, ‘plus’, and ‘equals’. then proceeded to prove the axiom.
it's a certified hood classic

3 More Replies...

@humbledb4jesus

i self taught basic on a commodore pet...then took fortran in the early 90's...awesome...enjoying every minute of it...

then 'c' came and i couldn't get past assigning variables...

astrophysics it is...

@anispinner

2y↑5

Sorry, already subbed.

@evilghostman07

2y↑16

As former coder. I given up because this type of stuff.

@adam.maqavoy

2y↑1

I love This kind of Fluff Coding ^^

@CrippleX89

2y↑2

Solution: the decimal type ;-)

@v0xl

2y↑1

I've never had any problems with floats

@halbgefressen9768

Look into numerical programming. That will explain it.

@panickal

FORMER CODER AHAHAHAHAHA

1 More Replies...

@monke2173

2y↑2

The woaoh wtf killed me😂😂😂

@jynx0riZ0r

"I don't understand."
That's the reason for the task.

@TheJackal917

2y↑12

Is it possible to have such an accuracy? Any pro at C/C++ here?

@cheng1552

2y↑7

i believe so but you need to use the original calculation of ieee754 to get back your answer

@v0xl

2y↑2

fixed point integers

@alexandernyberg8668

2y↑5

IEEE 754 defines sizes up to 256-bit floating point numbers which would give you 71 decimal digits of accuracy, but those aren't exactly common

@1Maklak

2y↑5

Long double has 128 bits, which is about 30 digits of accuracy and thousands in the exponent.

@Minty_Meeo

2y↑2

@@1Maklak long double is 80 bits or 128 bits, depending on the implementation.

8 More Replies...

@xubor007

That's a good interview question. I fiddled around and got a solution with quadmath, but you have to compile it with "-lquadmath"
> #include "quadmath.h"
> #include "stdio.h"
> int main() { char buf[64]; quadmath_snprintf(buf, sizeof(buf), "%.17Qf", 0.1Q + 0.2Q); printf(buf); }

@BavovnaCat

33w

IEEE 754 shenanigans be like

@515nathaniel

2y↑4

Actual solution in Python:

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.2')
Decimal('0.3')
>>> Decimal('0.1') + Decimal('0.2') == Decimal('0.3')
True

@pqnet84

2y↑3

You'll feel better once you realize that there is no 0.1 nor 0.2 in float, because float has a finite number of digit and both of them are periodic numbers.

@pleasedontwatchthese9593

Your not wrong but I wanted to add a fun fact. Doubles can fit every 32 bit integer perfectly. This is really convenient and the reason why a lot of weak typed languages use then as the default number type.

@n00blamer

@@pleasedontwatchthese9593 Indeed, 32 bit float misses lot of the values in the higher end (the epsilon between two values is > 1).

@n00blamer

.. which isn't surprising because some of the bits patterns are reserved for NaN, Inf, etc. just to get started..

@solstice9339

The “woaaah… whaaaaat tf…” is relatable on so many levels

@georgecop9538

2y↑1

Those bits are freaking me out. Solution: Use a fraction struct. (It should work)

@dwivedys

2y↑4

Very interesting. Ran the program on my computer. Learnt something new. It’s accurate till 5 places of decimal but not beyond. Need to understand floating point arithmetic in computers better

@qm3ster

2y↑1

Its completely accurate, the issue is it's not decimal.

@diosupremo4928

2y↑4

It have been a long time since i used C but maybe you should make a vector of chars or any type you want(with chars you work by Byte) and then resolve it bit by bit. If you dont care about performance you could work as a string and make a function to sum with chars, in ascii is not difficult using %, / and resting 48.

@unknownlordd

2y↑1

I respect this man's sacrifices

@LowLevelLearning

2y↑1

🙏

@ShaunakDe

CSharp and the decimal type... nuff said lol

@danko5678

2y↑3

It's funny how you use interpreted languages for testing purposes

@yokunjon

JS is a JIT compiled language, not an interpreted one; unless you live in 15 years ago.

@sipos0

2y↑13

This is why all programmers need to understand low level things like float representations, and why you should never trust a programmer who hasn't programmed in C (or C++ or Rust).

@musicalchicken1024

2y↑2

I agree that programmers need to understand low level concepts such as memory and float representations and even much more. However, just because you are not in close contact with them such as when u use c or c++ doesn’t mean that they dont understand these concepts, however much detached they may be…

@sipos0

@@musicalchicken1024 It is possible to understand them without writing some C, C++ or Rust, but it is far more efficient to learn by writing something low level I think than any other way of learning these concepts properly.

@paulwomack5866

I learnt about this issue using BASIC on a 2001 PET.

@sipos0

@@paulwomack5866 fair enough

@musicalchicken1024

@@sipos0 i guess so, it is also the best way to gain experience with these concepts ig.

@MichToJoshya

27w

I actually suffered a similar bug in a production system that was supposed to work on really small percentages (which again blow up to be big after being multiplied by number of clients which ran in 100s of millions). This was in a big 3 software firms.
And I was a new hire.

@nickpetrovsky

Why no to avoid float and switch to fixed point. Something like — integer implementation:

int a = int(.1*10.0), b =int (.2*10.0);
printf(“%f”, float(a+b)/10.0);

@LindX31

2y↑4

“Coding in c until I go completely insane”
I love how the video is literally 1:14 minute long 😆

@dawnstar24

2y↑4

This happens because the machine uses true or false ie 0 1. So there are inaccuracies when using float. If it used 10 digit system. This problem won't occur.

@sandman94

2y↑1

Sussy float destroys programmer's sanity

@A.Sidney

51w

I remember I had to make a super long rounding off system that took like 100+ lines so I could fix the .1 + .2 issue. It was for my Roblox Calculator project (coded in lua.).
And I was only able to get my answers accurate to 14 sf.

@esra_erimez

2y↑8

What is it called when you do arithmetic for your own pleasure? Mathturbation

@Mariomm_marti

2y↑5

fun-fact. It's impossible to get 0.3 with 17 digits of precision. That's the fun thing about the video. I don't know how people comments there are ways to do it. It's impossible.

@jimmyneutron129

Well it's possible, but that would require special librairies, take more time and more memory

@Mariomm_marti

@@jimmyneutron129 you can’t physically represent 0.3 in memory using xmm registries. You can override, round, and whatever you want. 0.3 is not a computer friendly value based on the IEEE 754 and mantissa' behaviour

@jimmyneutron129

2y↑1

@@Mariomm_marti https://en.m.wikipedia.org/wiki/Arbitrary-precision_arithmetic
I didn't say it was a friendly value, but there are ways to do it if you are willing to sacrifice memory and time

@cippo1995

Floating point limited precision says hello! xD

@Egon3k

51w

the beauty of floats :)

@nTheta

2y↑4

last video

@LowLevelLearning

wat

@Ciubix8513

2y↑8

You just need to implement your own float type, it's really quite simple

@n00blamer

Intel had even instructions for BCD in x86 but it's no longer supported in 64 bit mode (gone with the x87 instructions, which are still available in 32 bit mode though, so the bloat is still in there even on latest processors, just not possible to use unless run some skank OS from 1990's).

Load More Comments...

More Comments

just now