If

If
10000000000000000000000000.0 == 10000000000000000000000000.02

evaluates to True, you should seriously re-consider your life choices.

Other urls found in this thread:

en.wikipedia.org/wiki/Machine_epsilon
twitter.com/SFWRedditGifs

3(.333...) evaluates to 1 irl. Close enuff

>terminating decimal
>being anything close to a repeating decimal
lmaoing @ u're life

just round my shit up senpai

You should reconsider your life choices if you think it's safe to compare values of floating point numbers without a proper epsilon value.

>they're putting ads on faucets now

>tap.exe has stopped working

It's pretty smart, what else are you going to look at while you wash your hands?

>what else are you going to look at while you wash your hands?
myself reflection in the mirror

The epsilon value is not needed in this case because the direct quotient integral is a reference to the floating space integer with respect to the enumerating vertices.

My hands

not everyone is a narcissist

I don't imagine you can look down at your hands in the sink without also seeing the faucet

That little screen isn't blocking your reflection, unlike something along the lines of this.

Sure, but I'm not looking at the faucet; I'm looking at my hands.

I have never considered vandalizing anything in my life until I saw this picture

>not everyone is a narcissist
true, but not everyone is good looking, thats why he looks in the mirror and you look at the faucet.

>The "Virgin hand washing" vs. The "Chad Cleanse"

I need to clean my hands somehow after I fap to myself in the mirror.

see
if you think epsilon applies to this then you must have "slipped through the cracks" when you passed Calc I

I'm that second poster. There's a difference between the epsilon we use in math and a machine epsilon. See en.wikipedia.org/wiki/Machine_epsilon for more.

I'd much rather look at my hands and have a quiet moment of contemplation than have some obnoxious fucking ad for some bullshit I'm never going to buy blaring in my face.

>he actually washes his hands
just don't piss on your hands or shit on them.

you're telling me you don't wash your hands after taking a shit?

>terminating decimal
>being a terminating real number in base 2
I'm about 3 posts away from filtering / u /

Why would I? It's not like I play with the turds before I flush.

but you do wipe right?

Of course

>touches the door handle
>doesn't wash his hand

fucking kill yourself

>washes his hands
>doesn't wash his hands afterwards

If 0.999... evaluates to 1, kys.

see
>'0.999... equals 1 bro!'
I bet you can't do the proof, like the mathlet you are.

What do you expect when the people doing the programming never actually use the loo?

so what languages does this not evaluate to true

I'm x = 0.999...
10x = 9.999...
10x - x = 9.999... - 0.999...
9x = 9
x = 1

that is not a proof dumbass

No, you just should learn that standard rounded maths isn't arbitrary precision maths for obvious performance reasons.

It is part of fuckinglrn2program chapter 2.

that must be the special kind of float that uses ellipsis

PS: In most languages its "rounded" by truncation, even. Not rounded like in your standard maths.

That's literally how proofs work.

Here's another one.

.9+.09+.009.... = .9*sum(.1^n from n = 0 to infinity) = .9 * 1/(1-.1) = .9/.9 = 1

that's literally not a proof you fucking brainlet

Let S equal the series a + ar + ar^2 +....

Therefore rS equals ar + ar^2 + ar^3 +...

Therefore S - rS equals a + ar - ar + ar ^2 - ar^2 +...

Simplifying S-rS = a

Solving for S we get S to be equal to a/(1-r)

Subbing in the values .9 and .1 into a and r respectively we get

.9+.09+.009+...=.9999...=.9/(1-.1)=1

You dumb shit.

it's not about the language, it's about the math implementation. pretty much all languages use single/double precision floating point numbers which represent the two numbers in the same way. I'm not sure about long double though

specialised libraries like GMP are needed here. or you could avoid this whole situation by not being a dummy and making sure that you don't get numbers of such magnitude when writing math code.

It's even better. It's basic algebra.
Choke on a shot of black.

Double precision floating point uses 53 bits for the fractional part of the number. It's only accurate to 16 decimal digits at most. Not sure what the IEEE standard calls for but it's probably just to set the lost info to be zero or some shit. In which case any language conforming to IEEE standard will return true for the statement 10000000000000000000000000.0 == 10000000000000000000000000.02

>any language conforming to IEEE standard will return true for the statement 10000000000000000000000000.0 == 10000000000000000000000000.02
(not true, by the way)

Then it doesn't conform to the standard.

>inb4 forgot to write QED

i hope our civilization dies soon.

>more things to hack
>Neuromancer shit happening in our lifetime
>codelets like you complain because you can't get in on the action
never gonna make it

what the fuck is neuromancer

What the fuck is google

Also, read it, it's good.

Prove that 10 * 0.999... = 9.999...

>engineer general

and this is why infinite doesn't exist

>working with ruby
PLEASE SEND HALP

> don't mindme, just too stupid to understand how floating-point numbers are represented in memory

>Prove that 10 * 0.999... = 9.999...
That's how math works, retard.

this

bc 1.07.1
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
10000000000000000000000000.0 == 10000000000000000000000000.02
0

>>> from decimal import Decimal as d
>>> d('10000000000000000000000000.0') == d('10000000000000000000000000.02')
False

There. You're happy now?

Even worse


It echoes.

>@taco
lmao

proofs are for fags that end up poor
math is just a toolbox i don't need to know how someone thought up and proved a hammer would hit nails as long as i know how to hit nails with a hammer.

Wow holy shit OP limitations exist in the way we store data call everybody and let's get out best people on this.

Python 2.7.10 (default, Feb 7 2017, 00:08:15)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 10000000000000000000000000.0 == 10000000000000000000000000.02
True

>php

tacos are not homo