标签: numerical-stability

对于一些实际价值b和cin [-1, 1]，我需要计算

sqrt( (b²*c²) / (1-c²) ) = (|b|*|c|) / sqrt((1-c)*(1+c))

当c接近 1 或 -1时，分母中出现灾难性抵消。平方根可能也无济于事。

我想知道是否有一个聪明的技巧可以在这里应用来避免 c=1 和 c=-1 周围的困难区域？

我有一个用Python编程的贝叶斯分类器,问题是当我乘以特征概率时,我得到非常小的浮点值,如2.5e-320或类似的东西,突然变成0.0.0.0显然对我没用,因为我必须根据哪个类返回MAX值(更大的值)找到"最佳"类.

处理这个问题的最佳方法是什么？我想找到数字的指数部分(-320),如果它太低,则将该值乘以1e20或某个值.但也许有更好的方法？

我理解,由于数值误差(例如,以不同的顺序求和浮点数),数学上等效的算术运算会如何导致不同的结果.

但是,添加零sum可以改变结果让我感到惊讶.无论如何,我认为这总是适用于花车:x + 0. == x.

这是一个例子.我预计所有的线都是零.任何人都可以解释为什么会这样吗？

M = 4  # number of random values
Z = 4  # number of additional zeros
for i in range(20):
    a = np.random.rand(M)
    b = np.zeros(M+Z)
    b[:M] = a
    print a.sum() - b.sum()

-4.4408920985e-16
0.0
0.0
0.0
4.4408920985e-16
0.0
-4.4408920985e-16
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
2.22044604925e-16
0.0
4.4408920985e-16
4.4408920985e-16
0.0

对于较小的M和,似乎不会发生Z.

我也确定了a.dtype==b.dtype.

这是另一个例子,它还演示了python的内置sum行为符合预期:

a = np.array([0.1,      1.0/3,      1.0/7, …

为什么chisq.testR 中的函数在求和之前按降序对数据进行排序？

有问题的代码是:

STATISTIC <- sum(sort((x - E)^2/E, decreasing = TRUE))

如果由于使用浮点运算而担心数值稳定性并希望使用一些易于部署的hack,我会在求和之前按递增顺序对数据进行排序,以避免在累加器中将较小的值添加到大值(以避免尽可能多地修剪结果中的最低有效位.

我看着的源代码总和,但它没有解释为什么在传递数据下降为sum().我错过了什么？

一个例子:

x = matrix(1.1, 10001, 1)
x[1] = 10^16   # We have a vector with 10000*1.1 and 1*10^16
c(sum(sort(x, decreasing = TRUE)), sum(sort(x, decreasing = FALSE)))

结果:

10000000000010996 10000000000011000

当我们按升序对数据进行排序时,我们得到了正确的结果.如果我们按降序对数据进行排序,我们得到的结果是4.

在GLSL(特别是我正在使用的3.00)中,有两个版本 atan():atan(y_over_x)只能返回-PI/2,PI/2之间的角度,同时atan(y/x)可以考虑所有4个象限,因此角度范围涵盖-PI, PI,就像atan2()在C++中一样.

我想用第二个atan将XY坐标转换为角度.但是,atan()在GLSL中,除了不能处理的时候x = 0,还不是很稳定.特别是在x接近零的地方,除法会溢出,导致相反的结果角度(你得到的东西接近-PI/2,你可以得到大约PI/2).

什么是一个好的,简单的实现,我们可以在GLSL之上构建,atan(y,x)使其更强大？

任何人都可以推荐任何包含维护各种浮点运算稳定性的策略的C++库/例程/包吗？

示例:假设您希望long double在单位间隔(0,1)中对一百万个向量/数组求和,并且每个数字的大小大致相同.天真的求和for (int i=0;i<1000000;++i) sum += array[i]; 是不可靠的 - 足够大i,sum将会比一个更大的数量级array[i],因此sum += array[i]相当于sum += 0.00.(注意:此示例的解决方案是二进制求和策略.)

我处理数千/数百万微小概率的总和和产品.我使用MPFRC++具有2048位有效数的任意精度库,但仍然适用相同的问题.

我主要关心的是:

1. 准确汇总许多数字的策略(例如上面的例子).
2. 乘法和除法何时可能不稳定？(如果我想规范化大量数字,我的归一化常数应该是多少？最小值？最大？中位数？)

我有一些数学(在C++中)似乎产生了一些非常小的,接近于零的数字(我怀疑trig函数调用是我真正的问题),但是我想检测这些情况以便我可以在更多详情.

我目前正在尝试以下内容,这是正确的吗？

if ( std::abs(x) < DBL_MIN ) {
     log_debug("detected small num, %Le, %Le", x, y);
}

其次,数学的本质是三角函数(也就是使用很多弧度/度数转换和sin/ cos/ tan调用等),我可以做些什么样的转换来避免数学错误？

显然,对于乘法我可以使用对数变换 - 还有什么？

我正在尝试用Java 实现Fuzzy C-Means算法的一个版本,我试图通过计算一次只能计算一次的所有内容来进行一些优化.

这是一个迭代算法,关于矩阵的更新,像素x簇成员矩阵U(行中值的总和必须为1.0),这是我想要优化的更新规则:

其中x是矩阵的元素X(像素x特征),v属于矩阵V (簇x特征).并且m是一个参数,范围从1.1to infinity和c是簇的数量.使用的距离是欧几里德范数.

如果我必须以平庸的方式实施这个公式,我会这样做:

    for(int i = 0; i < X.length; i++)
    {
        int count = 0;
        for(int j = 0; j < V.length; j++)
        {
                double num = D[i][j];
                double sumTerms = 0;
                for(int k = 0; k < V.length; k++)
                {
                     double thisDistance = D[i][k];
                     sumTerms += Math.pow(num / thisDistance, (1.0 / (m - …

我正在学习单位四元数以及如何使用它们来表示和组合旋转.维基百科称它们在数值上比矩阵表示更稳定,但没有给出参考.任何人都可以向我解释(最好用一些数学推理)为什么使用单位四元数来处理旋转(例如对于OpenGL应用程序而不是旋转矩阵)在数值上更稳定？是因为避免了万向节锁？

什么是数值最稳定的计算方法:

log[(wx * exp(x) + wy * exp_y)/(wx + wy)]

重量在哪里wx, wy > 0？

如果没有权重,这个函数logaddexp可以在Python中用NumPy实现,如下所示:

tmp = x - y
return np.where(tmp > 0,
                x + np.log1p(np.exp(-tmp)),
                y + np.log1p(np.exp(tmp)))

我应该如何将其推广到加权版本？