标签: numerical-computing

我正在开发一个需要浮点确定性的C应用程序.我还希望浮点运算相当快.这包括IEEE754未指定的标准超越函数,如正弦和对数.与硬件浮点相比,我考虑的软件浮点实现相对较慢,所以我考虑简单地从每个答案中舍去一个或两个最低有效位.精度的损失对我的应用程序来说是一个充分的妥协,但这是否足以确保跨平台的确定性结果？所有浮点值都将是双倍的.

我意识到操作顺序是浮点结果差异的另一个潜在来源.我有办法解决这个问题.

如果今天使用的主要浮点硬件实现的软件实现将是非常好的,所以我可以直接测试这样的假设.

与数值计算相比,符号数学计算(特别是对于求解非线性多项式系统)会导致巨大的性能(计算速度)劣势吗？有没有关于此的基准/数据？

发现了一个相关的问题:https://scicomp.stackexchange.com/questions/21754/symbolic-computation-vs-numerical-computation

另一个:正向模式自动与数字与符号分化的计算效率

在下面的代码中。我得到了 x1 的预期结果

import numpy as np 
x1 = np.arange(0.5, 10.4, 0.8)
print(x1)
[ 0.5  1.3  2.1  2.9  3.7  4.5  5.3  6.1  6.9  7.7  8.5  9.3 10.1]

但在下面的代码中，当我设置 dtype=int 时，为什么 x2 的结果不是[ 0 1 2 2 3 4 5 6 6 7 8 9 10]，而是我得到 x2 的值，因为[ 0 1 2 3 4 5 6 7 8 9 10 11 12]最后一个值 12 超过了 10.4 的最终值。请澄清我对此的概念。

import numpy as np 
x2 = np.arange(0.5, 10.4, 0.8, dtype=int)
print(x2)
[ …

寻找IndexedSeq[Double]在设计特定于域的数值计算库时使用的正确数据类型(例如).对于这个问题,我将范围限制在使用1维数组Double.该库将定义通常应用于1D阵列中每个元素的数字函数.

注意事项:

• 首选不可变数据类型,例如Vector或IndexedSeq
• 希望最大限度地减少数据转换
• 在空间和时间上合理有效
• 对使用该库的其他人友好
• 优雅而干净的API

我应该在集合层次结构中使用更高的东西,例如Seq？

或者仅仅定义单元素函数并将映射/迭代留给最终用户更好？

这似乎效率较低(因为一些计算可以在每组调用中完成一次),但同时也是一个更灵活的API,因为它适用于任何类型的集合.

有什么建议？

我有两个函数,它们是纯函数的组合.第一个功能需要一个包裹,在其上建一个房子,然后拍照以在杂志上刊登广告:

let buildAndAdvertiseHouse parcel = 
    parcel
    |> inspect
    |> buildWalls
    |> buildRoof
    |> takePhoto
    |> advertise

第二个功能还包括一个包裹,在它上面建一个房子,并为它添加一个画龙点睛:

let buildAndCompleteHouse parcel = 
    parcel
    |> inspect
    |> buildWalls
    |> buildRoof
    |> paintWalls
    |> addFurniture

很明显,这两个函数也是纯粹的,因为它们是纯函数的组合.现在我有一个包裹,让我们说niceParcel,我想将两个功能应用于它.但是,我想避免前三个子函数计算两次,因为它们需要花费大量时间进行计算,并且它们在两个函数之间共享.

我如何重构我的代码,以避免这些不必要的计算,同时保留这些具有明确含义的纯函数？

我需要打印20个有效数字的程序结果,但我不知道如何打印超过15个数字(格式长).有没有办法实现这个目标？

我只是想评估一个输入是否是一个数字,并认为isNaN这是最好的方法.但是,这会导致不可靠的结果.例如,使用以下方法:

function isNumerical(value) {
    var isNum = !isNaN(value);
    return isNum ? "<mark>numerical</mark>" : "not numerical";
}

在这些价值观上:

isNumerical(123));     // => numerical
isNumerical("123"));   // => numerical
isNumerical(null));    // => numerical
isNumerical(false));   // => numerical
isNumerical(true));    // => numerical
isNumerical());        // => not numerical

在这个小提琴中显示:http://jsfiddle.net/4nm7r/1

为什么不isNaN总是对我有用？

我在python中写了一个脚本,这让我感到惊讶.基本上,它需要五个20位数字,然后将它们相乘,然后将它们提升到3000的幂.时间模块用于查找计算计算所需的时间.好吧,当我运行这个脚本时,它说需要3*10 ^ -7秒来计算它.然后它生成一个文件output.txt,但脚本直到大约15秒后才会结束.

import timeit
outputFile = open("output.txt", "w")
start = timeit.default_timer()
x = (87459837581209463928*23745987364728194857*27385647593847564738*10293769154925693856*12345678901234567891)**3000
stop = timeit.default_timer()
time = stop-start
print "Time taken for the calculation was {} seconds".format(time)
outputFile.writelines(str(x))
outputFile.close()
y = raw_input("Press enter to exit.")

这是否意味着打印280kb文件实际上需要花费更长的时间而不是执行计算？(我发现它不太可能.)

如果不是这样,那么python是否在调用变量x时执行计算？它是在每次计算变量时执行计算,还是将实际值存储在变量中？

我刚刚编写了另一个脚本,它确认将结果写入.txt文件需要python 0.03秒.那么,为什么python稍后会执行计算呢？

我有一个 (960,960) 数组，我试图找到临界点，以便找到局部极值。

我曾尝试使用 np.diff 和 np.gradient，但遇到了一些麻烦，我不确定要使用哪个函数。

np.diff 提供了计算二阶差异的选项，但梯度没有。

我应该如何获得临界点？

我试过了

diff = np.diff(storm, n=2)                    

dxx = diff[0]                                                                                                                                  
dyy = diff[1]                                                                                                                                  

derivative = dyy/dxx 

我在这里遇到了问题，因为 dxx 上的一些值等于零。

然后有一个选项

gradient = np.gradient(storm)
g2 = np.gradient(gradient)

但这会给我我正在寻找的东西吗？

我必须应用一些我在python中编写的数学公式:

    for s in range(tdim):
        sum1 = 0.0
        for i in range(dim):
            for j in range(dim):
                sum1+=0.5*np.cos(theta[s]*(i-j))*
                eig1[i]*eig1[j]+eig2[i]+eig2[j])-0.5*np.sin(theta[s]*(i-j))*eig1[j]*eig2[i]-eig1[i]*eig2[j])

        PHi2.append(sum1)

现在,这是正确的,但显然效率低下,另一种方法是:

for i in range(dim):
            for j in range(dim):
                PHi2 = 0.5*np.cos(theta*(i-j))*(eig1[i]*eig1[j]+eig2[i]+eig2[j])-0.5*np.sin(theta*(i-j))*(eig1[j]*eig2[i]-eig1[i]*eig2[j])

但是,第二个例子在PHi2的所有元素中给出了相同的数字,所以这个更快但答案是错误的.你怎么能正确而有效地做到这一点？

注意:eig1和eig2具有相同的尺寸d,θ和PHi2的尺寸D相同,但是d!= D.