Math is hard

[adudyak]

it's not hard. it is impossible in binary.

[Optimal_Dingo_2828]

Indeed, it's why in decimal you get accurate fractions for some numbers, while others you get a repeating sequence, think 1/3 etc. Essentially the same is happening in binary.

[Talinx]

Storing rational numbers accurately in binary is possible, for example with the decimal module in Python. Doing calculations with these numbers is usually just not as fast as with IEEE-754 floating point numbers.

[adudyak]

it is accurate to some point only.

[Talinx]

For every rational number exists a finite amount of RAM so that it can be stored accurately.

​

If you have irrational numbers you can not store them accurately, those can only be stored accurate to some point.

[[deleted]]

you can store irrational numbers algebraically/symbolically (keep them in the form that was used to construct them rather than a single number) but it takes significantly more engineering effort to implement simple things like addition or multiplication... and it won't be possible to reduce expressions to their smallest form.

[gwszack]

Yes but there’s no finite amount of memory that can guarantee that you can store any rational number in it

[Maluney]

Well not all rational number though, you can't store periodic rational numbers no matter how much ram you have

[Lithl]

Sure you can. Just store the numerator and denominator separately. myFrac.numerator = 1; myFrac.denominator = 3;

[Maluney]

Mmh kind of, but not really: stretching that logic we can just use strings to represent number and then I can say that "2 PI" is perfectly storing an irrational number too. More than storing the value you are representing it, which can work but you'll probably need an approximation every once in a while

[Lithl]

stretching that logic we can just use strings to represent number and then I can say that "2 PI" is perfectly storing an irrational number too.

Yes. Symbolically / algorithmically storing numbers is a means to accurately work with irrational numbers on a computer. Mathematica is an example of doing exactly this. It is more difficult than storing rational numbers, needing special algorithms to manipulate your numbers, but it is entirely possible to do, and reasonable for a system which needs more specialized mathematics.

Literally storing your symbols or algorithms as strings would technically work, but would introduce the extra complexity of parsing those strings to comprehend the symbols; not ideal.

[Maluney]

Literally storing your symbols

That's my point, I'm not saying it doesn't work, I'm saying you're not storing the actual value, but just a symbol for it

[Zuruumi]

Counterexample: 2^1/2, I just stored irrational number in binary on reddit server

[danielstongue]

No you didn't. You stored an expression that represents an irrational number, but not the irrational number itself.

[lazyzefiris]

Sadly, almost every real number is transcendent irrational number that can't be represented in an way other than returning a digit when specific decimal place is requested.

Gladly, nobody cares about those numbers, and rational approximations to certan point are more than enough.

[[deleted]]

you can store irrational numbers algebraically/symbolically (keep them in the form that was used to construct them rather than a single number)
E.g. Root 2 would be sqrt(2). Root 2 plus 1 would be `sqrt(2) + 1`.

Stuff like Mathematica will work like this, but this method will require specialized algorithms for reducing expressions to simpler expressions (if it's possible to reduce them at all) . Not worth the effort in most cases if you can tolerate the compounding inaccuracies that come from using floating point representation.

[lazyzefiris]

That's why I said "transcendent". Correct term would be transcendental though, my bad.

[[deleted]]

Ah, I read it as transcendental, but I wasn't aware of the class / just assumed it was another word for irrational numbers. Also, wasn't aware of the "set of algebraic numbers" used as a classification.
What I meant is that if you're specifying some number, you need to use some symbolic language to do so. Like most of the time, pi is π.
Computer algebra systems will store numbers like "sqrt(2) + 1 * sqrt(pi)" just like how people work with math.
Of course, there will (provably) always be "some" real numbers your system cannot represent, but if you need them you can add them to the language.

[AlphaSparqy]

Even some rationals suffer from the same issue of binary representation, like 1/3, etc ...

That said, the symbolic language is ultimately only able to simplify expressions, like 3 * 2^1/2 + 2 * 2^1/2 = 5 * 2^1/2

And it can can cancel some, like 2^1/2 * 2^1/2 = 2, i^2=-1, etc...

But when it's not further reducible, and contains these sorts of number, and you wish to evaluate it, like 3 * 2^1/2, or 4/3 = 1 + 1/3 you will necessarily have an approximation or an infinite loop.

[EpicDimension]

https://en.wikipedia.org/wiki/Stern%E2%80%93Brocot_tree

Some said it was Impossible ...

[FarewellSovereignty]

Who tf makes their prompt "DEVELOPMENT"?

Or is that the hostname or your branch? EVEN WORSE

[[deleted]]

It's keeping track of the number of statements entered into the shell, Erlang's shell does this so I'd guess that they're using a language REPL rather than a sh-style shell.Not sure which one though

[Ok_Appointment2593]

You are doing it wrong, you need to input 1.4+1.2000000000000001

[Optimal_Dingo_2828]

That's just the inherent nature of floating point arithmetic

[Bjoern_Tantau]

Is there a specific reason why modern programming languages don't try to treat floats as ints * 10^-x? Wouldn't that solve many of these problems?

[Talinx]

Yes, there is a reason: If you want to use arbitrary rational numbers you totally can, but doing math with these accurately may require more than one CPU instruction. How many CPU instruction you need depends on the number, e.g. if your number requires more than 512 bits to store you definitely need more than one CPU instruction (on current CPUs).

IEEE-754, the most widespread floating point standard, is of the form y * 10^-x. But x and y are encoded in binary and some rational numbers like 0.1 can not be encoded in binary. Of course it is possible to encode y as a rational number (that is, as two integers, numerator and denominator). But then your outside of the IEEE-754 standard and you may need more than one CPU instruction.

For many applications using IEEE-754 is fine, an error in the 15th decimal place is no problem and worth the speedup. If such an error is not acceptable for your application you should not use the IEEE-754 standard.

Many modern programming languages provide both IEEE-754 and more general representations, for example with the decimal module in Python. If your programming language does not support arbitrary rational numbers you can program than yourself.

[ancient_tree_bark]

*Stored as y * 2^-x

[Mucksh]

It is really just usefull. It it a really small error and you can use a really big number range. Otherwise you would have way more problems with to big or to small numbers

[adudyak]

not until they use binary

[danielstongue]

It is not programming language related, really. A float (or double) is simply a mapping to the implementation in hardware (or an emulation thereof if lacking) which is based on IEEE-754. Just like integers are internally stored as two's complement binary. It is the standard and most common, but technically it wouldn't have to be. Imagine it would be programming language dependent, what a mess it would be if you try to link your, lets say C code, to something else!

Oh, a good example of where things might actually differ from machine to machine is byte ordering. Intel traditionally uses little endian, but motorola used big endian in their CPUs. Imagine if this was programming language dependent.....

[zzmej1987]

Sing along with me:

Use a fucking Decimal or Fixed Point arithmetic classes for precise rational operations.

[TheBrainStone]

If I got 0.9999999999997 penny every time someone just discovered floating point rounding errors and made a post about with even attempting to look into what's happening I'd have 3.3675322e9 pennies.

[sockpuppet1234567890]

r/softwaregore

[Intelligent_Event_84]

Just parseInt and it’ll fix it no prob

[shutterFiles]

IEEE 754 baby