Comments for Complete Ramblings of Justin Winkler

Comment on When crap just doesn’t add up… by Velociroflcoptersaurus

Velociroflcoptersaurus — Mon, 08 Dec 2008 02:43:04 +0000

rad

Comment on When crap just doesn’t add up… by Rodrigo

Rodrigo — Mon, 20 Oct 2008 16:45:51 +0000

Hi, well, i don’t know too much about esential programming, reading some internet web sites about this topic, i saw that “it’s a world” to know about float and decimal numbers.

But how about to focus on functionality, i mean, a lot of people prefer “microsoft excel” or another ofimatic program and base their lives on it, they don’t focus on accuaracy or precission, they just only round a decimal number bigger than “5″ the previous decimal, and dislike scientific notation, How to do that?? it is there a class, or function?? i’m a newbie and i feel that this requirement it is not satisfied.

Comment on When crap just doesn’t add up… by Justin

Justin — Mon, 08 Sep 2008 03:18:12 +0000

Very true, Julian. By using the to_d method appended to String by bigdecimal/util, you are no longer converting a Float type, therefor never encounter the accuracy issue. This may be the best way to construct a BigDecimal.

Comment on Forwarding a dynamic argument “…(rest)” array in Flex by Fabio Barreiro

Fabio Barreiro — Fri, 05 Sep 2008 20:37:59 +0000

Thanks!!! I was stuck and this topic saved my life

Comment on Forwarding a dynamic argument “…(rest)” array in Flex by Jonathan

Jonathan — Fri, 01 Aug 2008 15:38:49 +0000

just an FYI, if you want to do the same trick with a RemoteObject you can do this:
var call : AsyncToken = someRemoteObj.someOpperation.send.apply(this, args);

thanks for the post! Helped me a lot.

Comment on When crap just doesn’t add up… by Julian Burgess

Julian Burgess — Thu, 12 Jun 2008 13:31:33 +0000

Unless I’m dumb, isn’t string the answer?

x = “1.00000000000000000000000000000000001″.to_d
=> #
puts x.to_s(”F”)
“1.00000000000000000000000000000000001″

Comment on Forwarding a dynamic argument “…(rest)” array in Flex by dl

dl — Fri, 18 Jan 2008 06:03:27 +0000

Thanks! I was trying to figure this out for hours.

Comment on When crap just doesn’t add up… by Fu

Fu — Fri, 12 Oct 2007 13:36:58 +0000

x = 1.00000000000001.to_d
=> #

puts x.to_s(’f')
=> 1.00000000000001

It seems that 14 places is the limit.

x = 1.000000000000001.to_d
=> #
puts x.to_s(’f')
=> 1.0

Going to the 15th drops the resolution.

Comment on When crap just doesn’t add up… by Spacebat

Spacebat — Wed, 10 Oct 2007 21:41:19 +0000

x = 1.2000000000000000001.to_d

I think what’s actually happening here is, Ruby converts the literal number into a float. The float can’t represent the 1 at the end so its lost. Then to_d is called and never sees the 1 at the end.

I remember using Borland compilers back in the 90s, and they supported BCD (Binary Coded Decimal). This was the recommended format for financial calculations, but it was slower and slightly wasteful of memory compared to binary floats. Still I’d wager its faster/smaller than BigDecimal (unless the latter is implemented in the former)

Comment on When crap just doesn’t add up… by Jim R. Wilson

Jim R. Wilson — Tue, 09 Oct 2007 18:44:39 +0000

Nope, nevermind - it really is a problem. In Ruby, 1.2 - 1.0 - 0.2 gives you -5.55111512312578e-17