Java中BigDecimal的BigInteger幂

我试图获得指数非常大的

double

值的幂（Java

biginger

可以包含它（指数），例如：10^30）

也就是说，我想找到类似1.75^（10^30）或1.23^（342345345222）的东西。如果输出太大，则通过10^9+7这样的素数获得模来修改它

如果我想找到一个

整数的幂

，我可以使用

biginger.modPow（）

方法，该方法采用

biginger

参数：

( BigInteger modPow(BigInteger exponent, BigInteger m) )

就我所能做的而言，这就是我在Java中得到的

new BigDecimal("1.5").pow(1000); // .pow() can get only integers as a parameter , but i want to pass a big number like a BigInteger 

我在java中找不到与之等价的（biginger.modPow（））用于

BigDecimal

，否则我就错过了

有什么方法可以做到这一点吗？计算浮点数的大幂（十进制）

输入和输出示例：

输入：num//或1.5或任何十进制数字。也可以是整数

指数：exp//大整数或长值

输出：num^exp/num-to-ther-power exp

i、 e喜欢计算1.23^（34234534534222）

如果输出太大，通过10^9+7这样的素数获得模数来修改它，有一个：

static java.math.BigDecimal powRound(java.math.BigDecimal x, java.math.BigInteger n) 
          Raise to an integer power and round.

这正是你需要的。它有一个外部库这一事实表明在

java.Math

中没有这样的方法的核心实现

作为一个旁注，我可以说，如果你的输入是相当小的小数位数（因此没有无理），就像1.5，你可以把它转换成15/10，然后做

(15^BigInteger)/(10^BigInteger)

---

使用

biginger

的

modPow（biginger指数，biginger m）

。这显然增加了计算的复杂性和数量。

有几个注意事项。正如Gábor Bakos指出的那样，结果值很可能包含太多的数字，甚至无法表示为

BigDecimal

此外，这些数字的数量增长很快，因此计算2.034234534222之类的数据在存储方面完全超出了范围（并且，正如我所假设的，在所需时间方面）

您提到，当值变得“太大”时，它可能会以大素数的模计算。虽然您没有明确说明这意味着什么，但这在这里并不一定对您有所帮助，因为使用模运算不会截断小数点。您将不得不以某种方式限制计算的精度

但是，使用最简单的实现大致如下所示：

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigDecimalPow {
    public static void main(String[] args) {
        BigDecimal b = new BigDecimal(1.5);
        BigInteger e = new BigInteger("325322");
        BigDecimal result = pow(b, e);
        System.out.println("Done "+result.scale());
        System.out.println(result);
    }


    /**
     * Computes d to the power of e
     * @param b The value
     * @param e The exponent
     * @return The power
     */
    private static BigDecimal pow(BigDecimal b, BigInteger e) {
        BigDecimal result = BigDecimal.ONE;
        BigDecimal p = b;
        int skipped = 0;
        while (e.compareTo(BigInteger.ZERO) > 0) {
            if (e.and(BigInteger.ONE).equals(BigInteger.ONE)) {
                if (skipped > 0) {

                    if (skipped > 29) {
                        p = pow(p, BigInteger.ONE.shiftLeft(skipped));
                    } else {
                        p = p.pow(1 << skipped);
                    }
                    skipped = 0;
                }
                result = result.multiply(p);
            }
            skipped++;
            e = e.shiftRight(1);
            System.out.println(e);
        }
        return result;
    }

}

import java.math.BigDecimal；
导入java.math.biginger；
公共类BigDecimalPow{
公共静态void main（字符串[]args）{
BigDecimal b=新的BigDecimal（1.5）；
BigInteger e=新的BigInteger（“325322”）；
BigDecimal结果=功率（b，e）；
System.out.println（“完成”+结果.scale（））；
系统输出打印项次（结果）；
}
/**
*将d计算为e的幂
*@param b值
*@param e指数
*@返回电源
*/
私有静态BigDecimal pow（BigDecimal b，BigInteger e）{
BigDecimal结果=BigDecimal.1；
大十进制p=b；
int=0；
而（例如，compareTo（BigInteger.ZERO）>0）{
if（e.and（biginger.ONE）.equals（biginger.ONE））{
如果（跳过>0）{
如果（跳过>29）{
p=pow（p，BigInteger.ONE.shiftLeft（跳过））；
}否则{
p=p.pow（1我认为您可能会得到一个意外的结果-因为BigDecimals scale只支持32位整数-，但您仍然可以通过快速求幂（）自行实现。可能的重复是“输出太大”？@Marco13当输出是一个数字且太大时，它包含太多的数字。通过获取mod，我们可以将其保持在一个较低的限制。在这里，正如我所说的，输出不会大于10^9+7。情况并非如此。当你有一个类似于
0.145345234626591590485
的值并将其模化为整数时，它仍然是
0.14534523462656491590485
。只有当数字太大时，才能减少位数，但这样做并不能消除小数位数。在这方面，您能帮我解决类似的问题吗