主页 / 问题 / 1573104
Accepted
BHms game Java
Asked:2024-03-25 06:38:25 +0000 UTC2024-03-25 06:38:25 +0000 UTC

如何计算小数的分数次方？J2ME

  • 772

J2ME中没有这样的方法Math.pow(double,double)。有分数幂的计算公式吗？至少对于 MIDP-2.0 来说是这样。

是的，J2ME 也没有Math.log(double)and Math.exp(double)，所以在我之前提出的其他问题和答案对我没有帮助......

java

2 个回答

  1. Best Answer

    为了解决这个问题，可以使用2007年文章Optimized approximation for Java, C/C++, and C#中给出的近似计算：pow()

    • 初始版本
    public static double pow(final double a, final double b) {
    final int x = (int) (Double.doubleToLongBits(a) >> 32);
    final int y = (int) (b * (x - 1072632447) + 1072632447);
    return Double.longBitsToDouble(((long) y) << 32);
}
    • 改进版（2011）
    public static double pow(final double a, final double b) {
    final long tmp = Double.doubleToLongBits(a);
    final long tmp2 = (long)(b * (tmp - 4606921280493453312L)) + 4606921280493453312L;
    return Double.longBitsToDouble(tmp2);
}

    实现函数计算的其他示例pow在另一篇 2007 年的文章中给出，现在仅在“时间机器”/webarchive 中提供：WebArchive:: 创建 Java ME Math.pow() 方法，作者：Lawrence Fulton、Daniel Williams。

    它讨论了以下选项：

    • 使用常规循环和乘法的简单整数解决方案。
    • 使用几何衰减算法求解
    • 使用平方根函数求解Math.sqrt
    • 使用泰勒级数近似计算自然对数和指数

    另一个来源，关于 Habré 2021 的文章：加速pow

    • 2

  2. 乙。​ 如果b < 0，则执行变换a b = (1/a) -b。接下来我们假设b是正数。

    让我们将b展开为 2 的幂和：b = Σ2 p i，其中p i是整数。那么a b = a Σ2 p i = ∏a 2 p i。

    如果p i > 0，则a 2 p i = (a 2 ) 2 p i -1 = ((a 2 ) 2 ) 2 p i -2 = ... = ((...((a 2 ) 2 )...) 2 ) 2 . 在最后一个表达式中，平方重复pi次。

    如果p i < 0，则a 2 p i = (√a) 2 p i +1 = (√√a) 2 p i +2 = ... = √√...√√a。在最后一个表达式中，根被提取-p i次。

    如果p i = 0，则a 2 p i = a。

    如果我们将b展开为 2 的幂，那么要计算a b我们只需要相乘并取平方根。两者都可以在 J2ME 中使用。不需要将b展开为幂；该格式double已经将实数存储为此类展开式，并且 Java 提供了用于访问展开式的工具。

    该方法相当准确（理论上是准确的，只有乘法舍入和取根干扰），对于真正大的幂会出现明显的相对误差。例如如果|b| <10 9，误差不超过10 -9。

        public static double pow(double a, double b) {
        if (b < 0) {
            return pow_impl(1 / a, -b);
        }
        if (b == 0) {
            return 1;
        }
        return pow_impl(a, b);
    }

    private static double pow_impl(double a, double b) {
        long bits = Double.doubleToRawLongBits(b);
        int exponent = (int)((bits & 0x7ff0000000000000L) >> 52) - 1023;
        long mantissa = bits & 0x000fffffffffffffL | 0x0010000000000000L;

        int max_j = 52;
        int min_j = Long.numberOfTrailingZeros(mantissa);
        int j0 = 52 - exponent;

        double pow = 1;
        if (min_j <= j0 && j0 <= max_j) {
            if ((mantissa & (1L << j0)) != 0) {
                pow = a;
            }
        }
        {
            double f = a;
            int first_j = Math.max(j0 + 1, min_j);
            for (int j = j0 + 1; j < first_j; ++j) {
                f *= f;
            }
            for (int j = first_j; j <= max_j; ++j) {
                f *= f;
                if ((mantissa & (1L << j)) != 0) {
                    pow *= f;
                }
            }
        }

        {
            double f = a;
            int first_j = Math.min(j0 - 1, max_j);
            for (int j = j0 - 1; j > first_j; --j) {
                f = Math.sqrt(f);
            }
            for (int j = first_j; j >= min_j; --j) {
                f = Math.sqrt(f);
                if ((mantissa & (1L << j)) != 0) {
                    pow *= f;
                }
            }
        }
        return pow;
    }

    PS如果有这么一个相对简单且准确的计算度数的方法，那为什么J2ME中没有呢？因为Java对pow精度要求很高：

    计算结果与准确结果的误差必须在 1 ulp 以内。结果必须是半单调的。

    这意味着整个参数范围的准确性pow应该只比格式本身表示的数字的准确性差两倍double。如果处理器不支持硬件计算pow，那么达到所需精度的仿真将会非常慢。单调的要求使任务变得更加困难。但你不能偏离标准的要求，Java必须在任何地方都工作得一样（几乎一样），这是创建该语言的目标之一。出路何在？从规范中删除一些功能。结果，我们遇到了一个有趣的问题，也让开发人员头疼。

    • 1

相关问题