Often big numbers become negative

Question

Since I started using eclipse for project euler, I noticed that big numbers sometime become a seemingly random negative numbers. I suppose this has something to do with passing the boudry of the type.

I'll be glad if you could explain to me how these negative numbers are generated and what is the logic behind it. Also, how can I avoid them (preferable not with BigInteger class). Danke!=)

I guess "using eclipse" means "using java". I hope you know eclipse has nothing to do with your problem — Elazar, Jun 20 '13 at 16:33
Eclipse is just an IDE. This means its just a place you edit, compile, and run your code. You're probably coding in Java. — But I'm Not A Wrapper Class, Jun 20 '13 at 16:39
avoidance depends on your specific problem. sometimes you cannot avoid using `Biginteger`, sometimes you can. — Elazar, Jun 20 '13 at 16:40
yeah thanks. Sorry I was just unsure whether this is something that changes between different development platforms or not — user2435678, Jun 20 '13 at 16:47
When you do addition, subtraction or multiplication in the primitive types `int` or `long` you are actually doing that modulo 2³² or 2⁶⁴, respectively. — starblue, Jun 23 '13 at 19:08

score 22 · Accepted Answer · edited Feb 08 '17 at 14:42

This image shows what you're looking for. In your case it's obviously larger numbers, but the principle stays the same.

Examples of limits in java are:
int: −2,147,483,648 to 2,147,483,647.
long: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

In the image 0000, 0001 etc, shows the binary representation of the numbers.

Image explaining two's complement

EDIT: In project euler you often have to think of a way to work around the lagre numbers. The problems are designed with numbers that big so that you can't use the ordinary way of problem solving. However, if you find that you really need to use them, i suggest studying BigInteger anyway. You will find it useful in the long run, and it's not all that complicated. Here is a link with lots of understandable examples: BigInteger Example

score 5 · Answer 2 · answered Jun 20 '13 at 16:36

5

In mathematics numbers are infinite. However in computers they are not. There is MAX_VALUE for each int-like type: int, short, long. For example Integer.MAX_VALUE. When you try to increase number more than this value the number becomes negative. This way the internal binary representation of numbers work.

int i = Integer.MAX_VALUE;
i++; // i becomes negative.

answered Jun 20 '13 at 16:36

AlexR

114,158
16
130
208

2

More specifically, it becomes `Integer.MIN_VALUE`. – Boris the Spider Jun 20 '13 at 16:40
Just let me verify this - the next number after max_value is -1? (I mean (int)2^31+1 =-1? – user2435678 Jun 20 '13 at 16:43
No, the next value after `Integer.MAX_VALUE` is `Integer.MIN_VALUE` as it was mentioned by @Boris the Spider – AlexR Jun 21 '13 at 05:21

Elazar · Answer 3 · 2013-09-19T17:34:37.530

4

Here's a two's complement representation for 2-bit integer: (U means Unsigned, S means Signed)

 U | bits |  S
---------------
 0 |  00  |  0 
 1 |  01  |  1 \ overflow here:
 2 |  10  | -2 /   1 + 1 = -2
 3 |  11  | -1

Arithmetic is done mostly like in the unsigned case, modulo max(U) (4 in our case).

The logic is the same for bigger types. int in Java is 32 bit. Use long for 64 bits.

edited Sep 19 '13 at 17:34

answered Jun 20 '13 at 16:46

Elazar

20,415
4
46
67

score 2 · Answer 4 · answered Jun 20 '13 at 16:38

You are probably overflowing the size of your data type, since the most significant bit is the sign bit. I don't think that Java has unsigned data types, so you may try using a larger data type such as long if you want to hold bigger numbers than int. If you are still overflowing a long though, you're pretty much stuck with BigInteger.

Often big numbers become negative

4 Answers4

Linked

Related