Now, your question is ambiguous. I can put 1e100 in a scalar variable, and it will hold this. However, if I put 0 in a scalar, and repeatedly increment that by 1, I will never reach 1e100 because of loss of significancy.

But even if your question is "what is the largest integer a scalar can hold without losing significancy?", then the answer is "it depends". It depends on whether your perl uses 64 bit integers, or 32 bit integers. In the former case, the answer is 2**63-1, or 9223372036854775807. If you have 32 bit integers, the answer is not 2**31-1, but much higher. perl then uses a double to store the integer, but a double has enough bits to not lose precision for a while. I don't know where exactly the cutoff is, but I recall it's around 2**53.

For 32-bit version of Perl, the maximum integer (without using bigint or similar) that can be stored precisely is -2⁵³ on the negative side and 2⁵³ on the positive side.

>perl -e"printf qq{%.f\n}, 2**53+$_ for +1,0,-1"
9007199254740992
9007199254740992
9007199254740991

>perl -e"printf qq{%.f\n}, -2**53+$_ for +1,0,-1"
-9007199254740991
-9007199254740992
-9007199254740992
[download]

Some operators (notably the bit operators) won't work with every number in that range.
Some C extensions won't work with every number in that range.

I'm trying to compile for quadruple floats, and it's not obvious to me what the parameter is during configure. Suggestions? Thanks, Scott

I'm trying to compile for quadruple floats

What is your compiler's C data type for these "quadruple floats" ? I had assumed that, if a C compiler could handle "quadruple floats", it would be handling them as "long doubles" - in which case building with -Duselongdouble might do the trick.

Cheers,
Rob

Sorry, none. I have no knowledge on the topic.

Without moving to using Math::BigInt and the like, the largest integer perl can hold in a scalar is 9,007,199,254,740,992. Albeit that it is actually held as a double (8-byte floating point) internally.

You might find the answer to your question in http://perldoc.perl.org/perlnumber.html.

As a reult of how Perl handles numbers, the answer to your question is somewhat complex and dependent on how your perl was compiled. Small integer numbers may be stored internally as integers or floating point numbers with no loss of information, but integers exceeding the limits of the internal integer representation can only be stored as floating point numbers. Floating point numbers have limited precision and for sufficiently large values the difference between one number and the next larger number that can be represented is greater than 1. At this limit, the numbers stop behaving as integers, at least for some operations. This is because, while larger integer values are possible, not all larger integer values are possible. For example, adding 1 to such a large value may not result in any change.

ccn@laptop:~$ perl -MPOSIX -le 'print LONG_MAX'
2147483647
ccn@laptop:~$
[download]

If that's not enough, you can always use Modules like Math::BigInt to use integers as large as you want (or at least up to the size of your computers memory).

you can always use Modules like Math::BigInt

Excellent observation - and such large numbers are, after all, stored in scalars - as per the OP's requirement.

The one limitation of Math::BigInt is that it's pure perl and can therefore be a little slow when it comes to manipulating those numeric values. As an alternative one could look at modules like Math::GMP, Math::Pari and Math::MPFR. These modules, like Math::BigInt, all store their values in sclarars and they still suffer from the "available memory" limitation - and, unlike Math::BigInt, they all depend upon external C libraries. The one big difference in their favour is that they provide much faster arithmetic manipulation of the bignum values than Math::BigInt.

Cheers,
Rob

That's wrong. LONG_MAX is a C constant, made available to you. It may say something about the maximum signed integer perl uses internally, but it's not the same maximum integer Perl can use. (Note the significant capitalization of the italic words).