:-) I just realized that you gave me a link to what I already read here in
the mailinglist (probably when I searched for similar questions)
I was just thinking on the macro as well and putting everything inside
quotation marks as: big("2")^big("32") that would sorta work for float, but
I realized this *issue* is not about production code. I totally accept that
production code should use native integer arithmetics without added
checkings/type promotions, I thought that in development phase Julia could
throw an error when such overflow occurs (this feature turned on with an
argument to the julia executable).
On Sunday, January 12, 2014 5:29:05 PM UTC+1, Ivar Nesje wrote:
>
> I really agree that this is a mistake that is easily made. There is a FAQ
> answer<http://docs.julialang.org/en/latest/manual/faq/#why-does-julia-use-native-machine-integer-arithmetic>
> 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.
>>
>
