CODEWITHSUNDEEP
javabigdecimallogarithmapfloat
Piyush Chandra
Piyush Chandra

Reputation: 7

ApfloatMath.pow taking a lot of time

I have to find log and later after few computations antilog of many big decimal numbers. Since log and antilog are not supported for BigDecimal numbers, for this I used Apfloat library and use its pow method which can take both arguments as Apfloat values like below:

ApfloatMath.pow(Constants.BASE_OF_LOG, apFloatNum);

The problem is I am using it in a loop and the loop is big. Apfloat pow takes a lot of time to find power which is more than an hour. To avoid this, I thought of converting Apfloat into double and then using Math.pow which runs fast but gives me infinite for few values.

What should I do? Does anyone know ApfloatMath.pow alternative?

Upvotes: 0

Views: 115

Answers (1)

Rudy Velthuis
Rudy Velthuis

Reputation: 28806

You said you are using Math.pow() now and that some of the calls return an infinite value.

If you can live with using (far less accurate) doubles instead of BigDecimals, then you should think of the fact that mathematically,

x = Math.pow(a, x);

is equivalent to

x = Math.pow(a, x - y) * Math.pow(a, y);

Say you have a big value, let's call it big, then instead of doing:

// pow(a, big) may return infinite
BigDecimal n = BigDecimal.valueOf(Math.pow(a, big));

you can just as well do:

// do this once, outside the loop
BigDecimal large = BigDecimal.valueOf(a).pow(100);

...

    // do this inside the loop
    // pow(a, big - 100) should not return infinite
    BigDecimal n = BigDecimal.valueOf(Math.pow(a, big - 100)).multiply(large);

Instead of 100, you may want to pick another constant that better suits the values you are using. But something like the above could be a simple solution, and much faster than what you describe.

Note

Perhaps ApfloatMath.pow() is only slow for large values. If that is the case, you may be able to apply the principle above to Apfloat.pow() as well. You would only have to do the following only once, outside the loop:

Apfloat large = ApfloatMath.pow(Constants.BASE_OF_LOG, 100);

and then you could use the following inside the loop:

x = ApfloatMath.pow(Constants.BASE_OF_LOG, big - 100).multiply(large);

inside the loop.

But you'll have to test if that makes things faster. I could imagine that ApfloatMath.pow() can be much faster for an integer exponent.

Since I don't know more about your data, and because I don't have Apfloat installed, I can't test this, so you should see if the above solution is good enough for you (especially if it is accurate enough for you), and if it is actually better/faster than what you have.

Upvotes: 0

Related Questions