Even if we were to have some kind of IntegerLiteral type, it's very likely that the subexpression 2^32 would "collapse" it to an Int so that by the time you get to big(2^32), you're in the same boat. Otherwise, you end up having a growing portion of symbolic computation at the heart of the language, which is not really what Julia is about. You can certainly *do* symbolic math, but it's not a symbolic language.
On Mon, Jan 13, 2014 at 4:11 AM, Földes László <[email protected]>wrote: > I was just throwing in a value to stop a calculation if the result is > under that value, I could as well choose 2^16, it just happened to be 2^32. > > > On Sunday, January 12, 2014 5:50:23 PM UTC+1, Alessandro Andrioni wrote: > >> In this case, you just need either one of the values converted to a >> BigInt, and big(2)^32 is marginally more efficient than 2^big(32), >> since it allocates one less BigInt. >> >> Also, wouldn't typemax(Int)/typemax(Uint) be what you want here? >> >> On 12 January 2014 14:29, Ivar Nesje <[email protected]> wrote: >> > I really agree that this is a mistake that is easily made. There is a >> FAQ >> > answer that explains why we use integer arithmetic with silent >> overflow. >> > >> > I think Julia would benefit from a simpler way to express numerical >> > constants with type than to first create a Float64 / Int32/64 and then >> send >> > to constructor, but I have not (yet) found a syntax to suggest that >> would >> > get approval. >> > >> > One idea might be to implement a @big macro that would allow you to >> write >> > @big(2^32) >> > and it would be automatically translated to >> > big(2)^big(32) >> > >> > The problem is that it will not work (in a sensible way) for floating >> point, >> > because the macro will not be able to see the string representation, >> but the >> > closest Float64 version. This means that 0.1 will be >> > 1.000000000000000055511151231257827021181583404541015625e-01 instead >> of >> > 1.000000000000000000000000000000000000000000000000000000000000000000000000000002e-01 >> >> > >> > kl. 17:02:25 UTC+1 søndag 12. januar 2014 skrev Földes László følgende: >> >> >> >> This little piece of code tricked me: >> >> >> >> if value < big(2^32) >> >> println("Finished!") >> >> break >> >> end >> >> >> >> The println was never executed and couldn't find the problem for about >> 3 >> >> minutes when I tried it on a 64 bit OS, where it worked. >> >> The problem is that on 32-bit OS 2^32 equals to zero. I'm just getting >> >> used to Julia internals and it is not really a problem if it is >> apparent, >> >> but I clearly need more time with the language to spot these kind of >> error. >> >> >> >> if value < big(2)^big(32) >> >> println("Finished!") >> >> break >> >> end >> >> solve this. But this is ugly and it looks like something that can be >> >> automated. >> >> >> >> is there any coding style that can prevent this error? I would better >> >> receive an overflow error (if it is turned on with a flag to the Julia >> >> executable maybe) than a silent, never running piece of code. >> >
