There is no _theoretical_ limit. The `BigInteger` class allocates as much memory as it needs for all the bits of data it is asked to hold.

There are, however, some practical limits, dictated by the memory available. And there are further technical limits, although you&#39;re very unlikely to be affected: some methods assume that the bits are addressable by `int` indexes, so things will start to break when you go above `Integer.MAX_VALUE` bits. 

Graham gave great answer to this question. I would like only to add that you have to be carefull with `valueOf` method because it is created using `long` parameter so the maximum value is `Long.MAX_VALUE`.

Yes its used when we need very big numbers with arbitrary precision. It&#39;s important to note that &quot;arbitrary&quot; precision or number of digits does not mean &quot;unlimited&quot;: it means that the number of digits in a number or number of digits of precision in a calculation is limited by memory and/or defined limits to precision that we specify.

Look at the BigInteger class source code, you will see (it can be done with NetBean). A number will be represented as an int arrays. Example, 10113 will be [1, 0, 1, 1, 3] (this is not exactly what the BigInteger class does, just an example how big number module work). So, technically, its only limit will be your memory.

I am learning about AngularJS and see it adds some of its own attributes that nor start with data neither are standard html tags attributes, like this:

    &lt;html ng-app&gt;

or this:

    &lt;body ng-controller=&quot;PhoneListCtrl&quot;&gt;

Where from do these ng-* attributes come and is that a valid HTML? Where can I read more about this?

AngularJS tags attributes

How do you declare and initialize a variable to be used locally in a Play2 Scala template?

I have this:

    @var title : String = &quot;Home&quot;

declared at the top of the template, but it gives me this error:


    illegal start of simple expression &quot;&quot;&quot;),_display_(Seq[Any](/*3.2*/var)),format.raw/*3.5*/(&quot;&quot;&quot; title : String = &quot;Home&quot;


Declare variable in a Play2 scala template

I looked into this [stackoverflow question relating to Big Integer][1] and specifically I do not understand this line (the words in italics):

&gt; In the BigInteger class, *I have no limits* and there are some helpful
&gt; functions there but it is pretty depressing to convert your beautiful
&gt; code to work with the BigInteger class, specially when primitive
&gt; operators don&#39;t work there and you must use functions from this class.

I don&#39;t know what I am missing but to represent something that has no limit you would require infinite memory ? Whats is the trick here ?

[1]:https://stackoverflow.com/questions/2776400/biginteger-or-not-biginteger

What does BigInteger having no limit mean?

I looked into this <a href="https://stackoverflow.com/questions/2776400/biginteger-or-not-biginteger" target="_blank" rel="noopener noreferrer">stackoverflow question relating to Big Integer</a> and specifically I do not understand this line (the words in italics):
> In the BigInteger class, I have no limits and there are some helpful
> functions there but it is pretty depressing to convert your beautiful
> code to work with the BigInteger class, specially when primitive
> operators don't work there and you must use functions from this class.
I don't know what I am missing but to represent something that has no limit you would require infinite memory ? Whats is the trick here ?

I&#39;ve heard very contradictory things on how to best handle this, and am stuck with the following dilemma:

 * an OOME brings down a thread, but not the whole application
 * and I need to bring down the whole application but can&#39;t because the thread doesn&#39;t have any memory left

I&#39;ve always understood best practice is let them go so the JVM can die because the JVM is in an inconsistent state at that point, but that doesn&#39;t seem to be working here.

Java - shutting down on Out of Memory Error

I have a JSF page which displays list of Glassfish log files. I use lazy loading for pagination. I keep the list of the log files names into Java `List`.

    private List&lt;directoryListObj&gt; dataList = new ArrayList&lt;&gt;();
    
    dataList = dataList.subList(firstRow, lastRow);


And here is the problem. For example I have 35 files into the directory. When I do this 

    dataList = dataList.subList(5, 15);

It works fine. But when I do this:

    dataList = dataList.subList(30, 38);

I get error wrong index because I want to get index outside of the List. How I can for example return List elements from 30 to 35? I want if I want to get index from 30 to 40 but if there only 35 indexes to get only 5.

How to use subList()

I have an activity that is using the Theme.Dialog style such that it is a floating window over another activity. However, when I click outside the dialog window (on the background activity), the dialog closes. How can I stop this behaviour?

Prevent Android activity dialog from closing on outside touch

How do I find out which version of Eclipse is currently installed on my system?

How to see my Eclipse version?

Specifically, why would it help to fix a PermGen OutOfMemoryError issue?

Also, bonus points for an answer that points me to the documentation on JVM arguments...

What does -XX:MaxPermSize do?

&gt; **Possible Duplicate:**  
&gt; [What does BigInteger having no limit mean?](https://stackoverflow.com/questions/12088436/what-does-biginteger-having-no-limit-mean)  

&lt;!-- End of automatically inserted text --&gt;

The Javadoc for `BigInteger` does not define any maximum or minimum.  However, it does say:

(emphasis added)
&gt; Immutable **arbitrary-precision** integers

Is there such a maximum, even in theory?  Or is the way `BigInteger` operates fundamentally different, such that there is in reality *no* maximum except for the amount of memory available on the computer?

Is there an upper bound to BigInteger?

I&#39;m trying to read some really big numbers from standard input and add them together.

However, to add to BigInteger, I need to use `BigInteger.valueOf(long);`:

    private BigInteger sum = BigInteger.valueOf(0);

    private void sum(String newNumber) {
        // BigInteger is immutable, reassign the variable:
        sum = sum.add(BigInteger.valueOf(Long.parseLong(newNumber)));
    }

That works fine, but as the `BigInteger.valueOf()` only takes a `long`, I cannot add numbers greater than `long`&#39;s max value (9223372036854775807).

Whenever I try to add 9223372036854775808 or more, I get a NumberFormatException (which is completely expected).

Is there something like `BigInteger.parseBigInteger(String)`?


How do I convert a String to a BigInteger?

I understand that both `java.lang.Long` and `java.math.BigInteger `can hold very large natural numbers.

I also know Long&#39;s max value, but what is the max value for BigInteger?

And aside from capacity, would BigInteger ever perform better when working with generally large integers that still fall in Long&#39;s range?

Question
--------

Is the only consideration: is my value too large for Long?

Long vs BigInteger

I want to define a function that takes an `unsigned int` as argument and returns an `int` congruent modulo UINT_MAX+1 to the argument.

A first attempt might look like this:

    int unsigned_to_signed(unsigned n)
    {
        return static_cast&lt;int&gt;(n);
    }

But as any language lawyer knows, casting from unsigned to signed for values larger than INT_MAX is implementation-defined.

I want to implement this such that (a) it only relies on behavior mandated by the spec; and (b) it compiles into a no-op on any modern machine and optimizing compiler.

As for bizarre machines...  If there is no signed int congruent modulo UINT_MAX+1 to the unsigned int, let&#39;s say I want to throw an exception.  If there is more than one (I am not sure this is possible), let&#39;s say I want the largest one.

OK, second attempt:

    int unsigned_to_signed(unsigned n)
    {
        int int_n = static_cast&lt;int&gt;(n);

        if (n == static_cast&lt;unsigned&gt;(int_n))
            return int_n;

        // else do something long and complicated
    }

I do not much care about the efficiency when I am not on a typical twos-complement system, since in my humble opinion that is unlikely.  And if my code becomes a bottleneck on the omnipresent sign-magnitude systems of 2050, well, I bet someone can figure that out and optimize it then.

Now, this second attempt is pretty close to what I want.  Although the cast to `int` is implementation-defined for some inputs, the cast back to `unsigned` is guaranteed by the standard to preserve the value modulo UINT_MAX+1.  So the conditional does check exactly what I want, and it will compile into nothing on any system I am likely to encounter.

However...  I am still casting to `int` without first checking whether it will invoke implementation-defined behavior.  On some hypothetical system in 2050 it could do who-knows-what.  So let&#39;s say I want to avoid that.

Question:  What should my &quot;third attempt&quot; look like?

To recap, I want to:

 - Cast from unsigned int to signed int
 - Preserve the value mod UINT_MAX+1
 - Invoke only standard-mandated behavior
 - Compile into a no-op on a typical twos-complement machine with optimizing compiler

[Update]

Let me give an example to show why this is not a trivial question.

Consider a hypothetical C++ implementation with the following properties:

 - `sizeof(int)` equals 4
 - `sizeof(unsigned)` equals 4
 - `INT_MAX` equals 32767
 - `INT_MIN` equals -2&lt;sup&gt;32&lt;/sup&gt; + 32768
 - `UINT_MAX` equals 2&lt;sup&gt;32&lt;/sup&gt; - 1
 -  Arithmetic on `int` is modulo 2&lt;sup&gt;32&lt;/sup&gt; (into the range `INT_MIN` through `INT_MAX`)
 - `std::numeric_limits&lt;int&gt;::is_modulo` is true
 - Casting unsigned `n` to int preserves the value for 0 &lt;= n &lt;= 32767 and yields _zero_ otherwise

On this hypothetical implementation, there is exactly one `int` value congruent (mod UINT_MAX+1) to each `unsigned` value.  So my question would be well-defined.

I claim that this hypothetical C++ implementation fully conforms to the C++98, C++03, and C++11 specifications.  I admit I have not memorized every word of all of them...  But I believe I have read the relevant sections carefully.  So if you want me to accept your answer, you either must (a) cite a spec that rules out this hypothetical implementation or (b) handle it correctly.

Indeed, a correct answer must handle _every_ hypothetical implementation permitted by the standard. That is what &quot;invoke only standard-mandated behavior&quot; means, by definition.

Incidentally, note that `std::numeric_limits&lt;int&gt;::is_modulo` is utterly useless here for multiple reasons.  For one thing, it can be `true` even if unsigned-to-signed casts do not work for large unsigned values.  For another, it can be `true` even on one&#39;s-complement or sign-magnitude systems, if arithmetic is simply modulo the entire integer range.  And so on.  If your answer depends on `is_modulo`, it&#39;s wrong.

[Update 2]

[hvd&#39;s answer][1] taught me something:  My hypothetical C++ implementation for integers is _not_ permitted by modern C.  The C99 and C11 standards are very specific about the representation of signed integers; indeed, they only permit twos-complement, ones-complement, and sign-magnitude (section 6.2.6.2 paragraph (2); ).

But C++ is not C.  As it turns out, this fact lies at the very heart of my question.

The original C++98 standard was based on the much older C89, which says (section 3.1.2.5):

&gt; For each of the signed integer types, there is a corresponding (but
&gt; different) unsigned integer type (designated with the keyword
&gt; unsigned)  that uses the same amount of storage (including sign
&gt; information) and has the same alignment requirements.  The range of
&gt; nonnegative values of a signed integer type is a subrange of the
&gt; corresponding unsigned integer type, and the representation of the
&gt; same value in each type is the same.

C89 says nothing about only having one sign bit or only allowing twos-complement/ones-complement/sign-magnitude.

The C++98 standard adopted this language nearly verbatim (section 3.9.1 paragraph (3)):

&gt; For each of the signed integer types, there exists a corresponding
&gt; (but different) *unsigned integer type*: &quot;`unsigned char`&quot;, &quot;`unsigned
&gt; short int`&quot;, &quot;`unsigned int`&quot;, and &quot;`unsigned long int`&quot;, each of
&gt; which occupies the same amount of storage and has the same alignment
&gt; requirements (3.9) as the corresponding signed integer type ; that
&gt; is, each *signed integer* type has the same object representation as
&gt; its corresponding *unsigned integer* type. The range of nonnegative
&gt; values of a signed integer type is a subrange of the corresponding
&gt; unsigned integer type, and the value representation of each
&gt; corresponding signed/unsigned type shall be the same.

The C++03 standard uses essentially identical language, as does C++11.

No standard C++ spec constrains its signed integer representations to any C spec, as far as I can tell.  And there is nothing mandating a single sign bit or anything of the kind.  All it says is that _non-negative_ signed integers must be a subrange of the corresponding unsigned.

So, again I claim that INT_MAX=32767 with INT_MIN=-2&lt;sup&gt;32&lt;/sup&gt;+32768 is permitted.  If your answer assumes otherwise, it is incorrect unless you cite a **C++** standard proving me wrong.

  [1]: https://stackoverflow.com/a/13208789/768469

Efficient unsigned-to-signed cast avoiding implementation-defined behavior

I need to compute an expression which looks like:
`A*B - C*D`, where their types are: `signed long long int A, B, C, D;`
Each number can be really big (not overflowing its type). While `A*B` could cause overflow, at same time expression `A*B - C*D` can be really small. How can I compute it correctly?

For example: `MAX * MAX - (MAX - 1) * (MAX + 1) == 1`, where `MAX = LLONG_MAX - n` and n - some natural number.

How to avoid overflow in expr. A * B - C * D

-2147483648 is the smallest integer for integer type with 32 bits, but it seems that it will overflow in the `if(...)` sentence:

    if (-2147483648 &gt; 0)
        std::cout &lt;&lt; &quot;true&quot;;
    else
        std::cout &lt;&lt; &quot;false&quot;;

This will print `true` in my testing. However, if we cast -2147483648 to integer, the result will be different:

    if (int(-2147483648) &gt; 0)
        std::cout &lt;&lt; &quot;true&quot;;
    else
        std::cout &lt;&lt; &quot;false&quot;;

This will print `false`.

I&#39;m confused. Can anyone give an explanation on this?


----------


Update 02-05-2012:

Thanks for your comments, in my compiler, the size of int is 4 bytes. I&#39;m using VC for some simple testing. I&#39;ve changed the description in my question.

That&#39;s a lot of very good replys in this post, [AndreyT][1] gave a very detailed explanation on how the compiler will behave on such input, and how this minimum integer was implemented. [qPCR4vir][2] on the other hand gave some related &quot;curiosities&quot; and how integers are represented. So impressive!


  [1]: https://stackoverflow.com/a/14695202/2040924
  [2]: https://stackoverflow.com/a/14695400/2040924

(-2147483648&gt; 0) returns true in C++?

As we know, [signed integer overflow is undefined behavior](https://stackoverflow.com/questions/4240748/allowing-signed-integer-overflows-in-c-c). But there is something interesting in C++11 `cstdint` documentation:

&gt; signed integer type with width of exactly 8, 16, 32 and 64 bits respectively with no padding bits and **using 2&#39;s complement for negative values** (provided only if the implementation directly supports the type)

&lt;sub&gt;[See link](http://en.cppreference.com/w/cpp/types/integer)&lt;/sub&gt;

And here is my question: since the standard says explicitly that for `int8_t`, `int16_t`, `int32_t` and `int64_t` negative numbers are 2&#39;s complement, is still overflow of these types an undefined behavior?

**Edit** I checked C++11 and C11 Standards and here is what I found:

C++11, &#167;18.4.1:
&gt; The header defines all functions, types, and macros the same as 7.20 in the C standard.

C11, &#167;7.20.1.1:
&gt;  The typedef name `intN_t` designates a signed integer type with width N, no padding bits, and a two’s complement representation. Thus, `int8_t` denotes such a signed integer type with a width of exactly 8 bits.

Is signed integer overflow still undefined behavior in C++?

I am trying to get the sum of `1 + 2 + ... + 1000000000`, but I&#39;m getting funny results in PHP and [Node.js][1].

**PHP**

    $sum = 0;
    for($i = 0; $i &lt;= 1000000000 ; $i++) {
        $sum += $i;
    }
    printf(&quot;%s&quot;, number_format($sum, 0, &quot;&quot;, &quot;&quot;));   // 500000000067108992

**Node.js**

    var sum = 0;
    for (i = 0; i &lt;= 1000000000; i++) {
        sum += i ;
    }
    console.log(sum); // 500000000067109000

The correct answer can be calculated using

    1 + 2 + ... + n = n(n+1)/2

Correct answer = **500000000500000000**, so I decided to try another language.

**GO**

    var sum , i int64
    for i = 0 ; i &lt;= 1000000000; i++ {
        sum += i
    }
    fmt.Println(sum) // 500000000500000000

But it works fine! So what is wrong with my PHP and Node.js code?

Perhaps this a problem of interpreted languages, and that&#39;s why it works in a compiled language like Go? If so, would other interpreted languages such as Python and Perl have the same problem?

  [1]: http://en.wikipedia.org/wiki/Node.js
  [2]: http://en.wikipedia.org/wiki/Python_%28programming_language%29
  [3]: http://en.wikipedia.org/wiki/Perl


Content Type	Original Author	Original Content on Stackoverflow
Question	Geek	View Question on Stackoverflow
Solution 1 - Java	Graham Borland	View Answer on Stackoverflow
Solution 2 - Java	Adam Sznajder	View Answer on Stackoverflow
Solution 3 - Java	Eduard	View Answer on Stackoverflow
Solution 4 - Java	Vũ Mạnh Cường	View Answer on Stackoverflow

What does BigInteger having no limit mean?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Solution 4 - Java

Declare variable in a Play2 scala template

AngularJS tags attributes

Attributions