# Math operation known issue? a^b

Today is my first day with Julia. While, working with the command line I realized that some results were negative and wrong. I am new, so if I made a mistake please let me know. What is wrong?

Thanks a lot!

Issue:

No, this is expected. Itâ€™s called integer overflow. Once you reach the highest representable number it wraps around to the lowest. This is how integer works on computers.

If you use floats instead it works:

``````julia> 20.0^20
1.048576e26
``````

(although floats have their own set of issues: PSA: floating-point arithmetic)

6 Likes

If you want really big numbers, use `big"20"^1000` to use arbitrary precision (but slow) math.

2 Likes

Thank you! Floats worked pretty well.

I tried this suggestion. Because â€śâ€ť makes a string it added up all the 20â€™s together.

@rougem Welcome to Julia. Please continue to ask questions. People here astore numbers re very friendly.

One thing you should know - this behaviour with integers or floating point numbers is because computers really store numbers as binary digits. We somehow have to translate how those binary digits represent oru familiar decimal numbers.

I do not want to complicate things but there have been ternary computer architectures, notably by the Russians. Also the decatron tube baseed machine we saw at Bletchley Park in the UK.

But binary is the way of all computers these days.

Youâ€™re misreading what Oscar suggested: he is using the `big""` string macro (see docs here), which is constructing a `BigInt` rather than a string object.

``````julia> big"20"^20
104857600000000000000000000
``````
3 Likes

Hi John,

Thank you for your kind message. I tried the same with python. It did not cause problems with integers or floats. What is the difference between Julia and Phyton? Do you know?

certainly, I did. Thank you.

Python trades safety for speed: it automatically checks whether an operation is going to overflow, if so it autopromotes the numbers to a larger format. This is slow

1 Like

Instead of `big"20"` you could also write `big(20)`. This also works for floats: `big(20.0)` is a `BigFloat`, while `big(20)` is a `BigInt`.

Julia is also smart about parsing long integers. If you write:

``````julia> typeof(20)
Int64

julia> typeof(20000000000000000000)
Int128

julia> typeof(200000000000000000000000000000000000000)
BigInt
``````

It doesnâ€™t work for floats, though

``````julia> 1.7e308
1.7e308

julia> 1.8e308
ERROR: syntax: overflow in numeric constant "1.8e308"
Stacktrace:
[1] top-level scope at REPL[269]:0

julia> big"1.8e308"
1.800000000000000000000000000000000000000000000000000000000000000000000000000002e+308
``````
1 Like

Thanks a lot for all these great info they will be verg useful once I start coding. Fingers crossed.