10

我必须存储几个非常低的概率值的乘积（例如，1E-80）。由于下溢，使用原始 java double 将导致零。我不希望该值变为零，因为稍后会有一个更大的数字（例如，1E100）将使值在双精度可以处理的范围内。

因此，我自己创建了一个不同的类（MyDouble），用于保存基础部分和指数部分。在进行计算时，例如乘法，我将基本部分相乘，然后加上指数。

该程序使用原始的 double 类型速度很快。但是，当我使用自己的课程（MyDouble）时，程序真的很慢。我认为这是因为我每次都必须创建新对象来创建简单的操作，而当不再需要这些对象时，垃圾收集器必须做很多工作。

我的问题是，您认为有没有更好的方法可以解决这个问题？如果没有，有没有办法让我可以用我自己的课程（MyDouble）加速程序？

[注意：取日志然后取指数并不能解决我的问题]

MyDouble 类：

public class MyDouble {
    public MyDouble(double base, int power){
    this.base = base;
    this.power = power;
    }

    public static MyDouble multiply(double... values) {
    MyDouble returnMyDouble = new MyDouble(0);
    double prodBase = 1;
    int prodPower = 0;
    for( double val : values) {
            MyDouble ad = new MyDouble(val);
            prodBase *= ad.base;
            prodPower += ad.power;
        }   
        String newBaseString = "" + prodBase;
        String[] splitted = newBaseString.split("E");   
        double newBase = 0; int newPower = 0;
        if(splitted.length == 2) {
            newBase = Double.parseDouble(splitted[0]);
            newPower = Integer.parseInt(splitted[1]);
        } else {
            newBase = Double.parseDouble(splitted[0]);
            newPower = 0;
        }
        returnMyDouble.base = newBase;
        returnMyDouble.power = newPower + prodPower;        
        return returnMyDouble;
    }
}
4

6 回答 6

5

解决这个问题的方法是在日志空间中工作——它使问题变得微不足道。当您说它不起作用时，您能否详细说明原因？概率下溢是概率模型中的一个常见问题，我认为我不知道它以任何其他方式解决了问题。

回想一下 log(a*b) 就是 log(a) + log(b)。类似地，log(a/b) 是 log(a) - log(b)。我假设因为您正在处理导致下溢问题的乘法和除法概率；日志空间的缺点是您需要使用特殊的例程来计算 log(a+b)，如果这是您的问题，我可以指导您。

所以简单的答案是，在日志空间中工作，并在最后重新取幂以获得人类可读的数字。

于 2012-10-16T10:21:30.247 回答
2

每次进行乘法运算时，您都试图解析字符串。您为什么不将所有值计算为某种结构，例如实数和指数部分作为预计算步骤，然后为乘法、加法、细分、幂等创建算法。

您也可以为大/小数字添加标志。我认为你不会在一次计算中同时使用 1e100 和 1e-100（这样你可以简化一些计算），你可以改善不同对（大，大），（小，小），（大，小）的计算时间。

于 2012-10-10T04:40:22.860 回答
2

您可以使用

BigDecimal bd = BigDecimal.ONE.scaleByPowerOfTen(-309)
        .multiply(BigDecimal.ONE.scaleByPowerOfTen(-300))
        .multiply(BigDecimal.ONE.scaleByPowerOfTen(300));
System.out.println(bd);

印刷

1E-309

或者，如果您使用 log10 比例

double d = -309 + -300 + 300;
System.out.println("1E"+d);

印刷

1E-309.0
于 2012-10-10T05:42:05.177 回答
1

我确信这会比双倍慢很多，但可能一个很大的影响因素是字符串操作。你能摆脱它并通过算术计算功率吗？即使是递归或迭代算术也可能比转换为 String 来获取数字位更快。

于 2012-10-10T04:29:30.643 回答
1

在性能要求很高的应用程序中，您希望找到一种将基本信息存储在原语中的方法。在这种情况下，也许您可​​以拆分 long 或其他变量的字节，以便固定部分是基数。

然后，您可以创建自定义方法乘长或长，就好像它们是双精度。您抓取代表基数和 exp 的位，并相应地截断。

从某种意义上说，您在这里重新发明了轮子，因为您需要能够有效执行您正在寻找的操作的字节码。

编辑：

如果你想坚持使用两个变量，你可以修改你的代码来简单地接受一个数组，这将比对象轻得多。此外，您需要删除对任何字符串解析函数的调用。那些非常慢。

于 2012-10-10T04:29:50.627 回答
1

缓慢可能是因为在拆分和字符串连接中创建的中间字符串对象。

试试这个：

/**
 * value = base * 10 ^ power.
 */

public class MyDouble {

    // Threshold values to determine whether given double is too small or not. 
private static final double SMALL_EPSILON = 1e-8;
private static final double SMALL_EPSILON_MULTIPLIER = 1e8;
private static final int    SMALL_EPSILON_POWER = 8;

private double myBase;
private int    myPower;

public MyDouble(double base, int power){
    myBase  = base;
    myPower = power;
}

public MyDouble(double base) 
{
    myBase  = base;
    myPower = 0;
    adjustPower();
}

/**
 * If base value is too small, increase the base by multiplying with some number and 
 * decrease the power accordingly. 
 * <p> E.g 0.000 000 000 001 * 10^1  => 0.0001 * 10^8  
 */
private void adjustPower()
{
    // Increase the base & decrease the power 
    // if given double value is less than threshold.
    if (myBase < SMALL_EPSILON) {
        myBase = myBase * SMALL_EPSILON_MULTIPLIER;
        myPower -= SMALL_EPSILON_POWER;
    }
}

/**
 * This method multiplies given double and updates this object.
 */
public void multiply(MyDouble d)
{
    myBase  *= d.myBase;
    myPower += d.myPower;
    adjustPower();
}

/**
 * This method multiplies given primitive double value with this object and update the 
 * base and power.
 */
public void multiply(double d)
{
    multiply(new MyDouble(d));
}

@Override
public String toString()
{
    return "Base:" + myBase + ", Power=" + myPower;
}

/**
 * This method multiplies given double values and returns MyDouble object.
 * It make sure that too small double values do not zero out the multiplication result. 
 */
public static MyDouble multiply(double...values) 
{
    MyDouble result = new MyDouble(1);
    for (int i=0; i<values.length; i++) {
        result.multiply(values[i]);
    }
    return result;
}

public static void main(String[] args) {
    MyDouble r = MyDouble.multiply(1e-80, 1e100);
    System.out.println(r);
}

}

如果这对于您的目的仍然很慢，您可以修改 multiply() 方法以直接对原始 double 进行操作，而不是创建 MyDouble 对象。

于 2012-10-10T05:04:36.957 回答