breslow day test nas produced by integer overflow

#BRESLOW DAY TEST NAS PRODUCED BY INTEGER OVERFLOW CODE#

The first issue is that this simply isn’t the philosophy of the language at all. The presumption of this complaint seems to be that people should be able to use Julia without knowing how its numerical types work and get completely mathematically accurate results. If you’re using Ints and you’re unhappy about them wrapping around when you take big exponents, then you’re using the wrong tool. I think this is a very key post because it highlights what I was trying to say: you need to understand your tools (numerical types) and use the right one. You simply have to know and understand your tools. And yes, this can happen also in Julia even if the mean function itself does a better job. This is not at all theoretic you can easily run into this when working with images. Floating point numbers of course have their own quirks, such as this classic: octave:1> mean(single(1.2 * ones(10000000, 1))) It’s about as likely to give an incorrect result but a higher risk that you don’t notice.

In fact I find the satiating integer arithmetic of Matlab and Octave rather more insidious than the wraparound of Julia. My point is that there are traps out there if you are unwary and that it isn’t something specific to Julia. I don’t find it particularly interesting what type you get from literals, you could as easily have received it as a function argument, read it from a file, or obtained it from a large array which someone behind your back had optimized the storage of. Normalizing a vector to sum to one does not work?ĭid you forget copying the first assignment here?

#BRESLOW DAY TEST NAS PRODUCED BY INTEGER OVERFLOW CODE#

If you’re writing code where accuracy is important, then you need to use the right tools, understand those tools and what they guarantee and what they don’t, and most of all, you need to test, test, test. But that’s true of floating-point as well-if someone is using floats in any of these languages naively, there are many examples of how they can get completely wrong answers. You do have to understand these things and use the appropriate types for what you’re doing and understand their failure modes. Note that whether this is more correct depends on whether you care about the high bits or low bits of the computation. Octave, Matlab and R only give you the last option.

Floating-point operations, which lose precision and are fast and don’t wrap around.

Big integer operations, which never lose precision and never overflow but are very slow.

Native integer operations, which never lose precision and are very fast but can wrap around.

What you’ve found here is not that Julia is less accurate than Octave (or Matlab or R), but that Octave forces floating-point operations, whereas Julia gives you these choices:

Julia, on the other hand, supports actual integer ^ which has no roundoff but does wrap around for native integer types.

There is no way to do exact integer exponentiation in Octave without having floating-point round-off.

Your exponentiation example doesn’t contradict that, rather it shows that Octave implements x^y as floating-point exponentiation, even if the arguments are integers.

example shows that integers in Octave do overflow (by wrapping around)-operations with native integer types do this just as they do in Julia.

Breslow day test nas produced by integer overflow