compute 2^1023 = (okay) -> 2^1024 = (problems)

My machine (or, perhaps the Java Math Library) is unable to calculate 2^1024(+), it can however, calculate up to 2^1023.

If I wanted to calculate a higher value, such as 2^1024, then how would I go about doing this? It can be in standard form if required.

I'm happy to implement C++ for this, but would prefer pure Java.

Any ideas? Is there some sort of algorithm I could use to allow larger operations? Could I some how split the calculation into several individual calculations, run them seperately, and then somehow combine the answers?

(I doubt I need to remind you that these are EXTREMELY large numbers; i.e:

2^1023 = 8.98846567431158e+307

Which is something like:

898846567431158000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000

So, storing the results in a variable isn't my ultimate goal, I just need to output the solutions...

Thanks! :)
LVL 25
Who is Participating?
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

Commented:
try this, (save a .htm and open in a browser)

<script>
function power2(maxpower){
var pow =new Array()
digits=Math.round(4*(maxpower/130))
len=0
for (i=0;i<=digits;i++)
{pow[i]=0}
pow[0]=1.0
for (power=0;power<=maxpower-1;power++)
{
for (i=0;i<=len;i++)
pow[i]+=pow[i]
lentemp=len
for (i=0;i<=lentemp-1;i++)
if (pow[i] >= 10000000000000)
{pow[i+1]+=1
pow[i]=pow[i]-10000000000000

}
if (pow[lentemp] >= 10000000000000)
{pow[lentemp+1]+=1

pow[lentemp]=pow[lentemp]-10000000000000
len+=1
}
}
document.f1.txt.value=""
digits=len
document.f1.txt.value=document.f1.txt.value
for (i=0;i<=len;i++)
{l=Math.floor(Math.LOG10E*Math.log(pow[len-i])+1)

if ((i!=0) && (l!=13))
{for (j=1;j<=13-l;j++)
document.f1.txt.value+="0"}
document.f1.txt.value+=pow[len-i]}

}
</script>

<body>
<p>Enter value of power and click </p>
<form name="f1">
<p><input type="text" name="power" size="20">
<input type="button" value="calculate" onclick="power2(1.0*document.f1.power.value)"> <br>
<textarea name="txt" rows="20" cols="60"></textarea> </p>
</form>
</body>

Experts Exchange Solution brought to you by

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Commented:
...it manipulates the digits in blocks of 13, it is really fast. The function power2(exponent) returns 2^exponent
Author Commented:
That's fantastic, Gwyn! Thank you very much! :-)
Commented:
Commented:
Hi!~GwynforWeb, you have done a nice job:)
but I have two problems after viewing your code..
May I know what is the use of
digits=Math.round(4*(maxpower/130))?
and also
is there any advantage to manipulates in blocks of 13, but not 12 or 14?
Commented:
...it is to do with integer representation of the Javascript interpreter.The larger the chunks the quicker the algorithm but integers   overflow at about 10^15 so I choose 13, since I will be adding values to and multiplying  each chunk this assures no overflow. The 13 value could be optimsed a bit Im not sure,  I was just being safe.

digits=Math.round(4*(maxpower/130)) is an upper bound on the number of chunks I will need for the final answer.
Commented:
May I know how digits=Math.round(4*(maxpower/130)) get the upper bound on the number of chunks?
Commented:
2^10 = 1024 < 10^4

so if maxpower=1000

2^1000 = (2^10)^100 < (10^4)^100 =10^(4*100)

ie 2^1000 has less than 400 digits

chunks are of length 13

hence #chunks  < 400/13 = 4*1000/130 = 4*maxpower/130

(not a great upper bound but good enough, it could be improved but this is not a time intensive part of the code)
Commented: