对于数学分析的大学课程,我们正在从Maple过渡到Numpy和Sympy的组合,以获得课程材料的各种插图.这是因为学生们之前已经学习过Python.

我们遇到的困难之一是在Python中模拟固定精度.Maple允许用户指定小数精度(比如10或20位),然后在每次计算时都使用该精度,这样您就可以看到舍入误差的影响.在Python中,我们尝试了一些方法来实现这一点:

• Sympy具有指定位数的舍入函数.
• Mpmath支持自定义精度.

然而,这不是我们想要的.这些选项计算确切结果并将精确结果四舍五入到指定的位数.我们正在寻找一种能够以指定精度进行每次中间计算的解决方案.例如,可以显示分割两个非常小的数字时可能发生的舍入误差的东西.

到目前为止,最好的解决方案似乎是Numpy中的自定义数据类型.使用float16,float32和float64,我们至少能够指出可能出现的问题.这里的问题是我们总是需要使用一个元素的数组,并且我们仅限于这三种数据类型.

为了我们的目的,还有更灵活的东西吗？或者我们正在寻找隐藏在mpmath文档中某处的东西？当然,通过在舍入函数中包装计算的每个元素有一些变通方法,但这会使代码模糊到学生.

我正在尝试编写一个计算十进制数字的程序？到1000位数或更多。

为了有趣地进行低级编程，最终程序将以汇编形式编写在没有乘法或除法且仅执行16位加法的8位CPU上。为了简化实现，希望只能使用16位无符号整数运算，并使用迭代算法。速度不是主要问题。快速乘法和除法不在此问题的范围内，因此也不要考虑这些问题。

在进行汇编之前，我仍在尝试在台式计算机上的C语言中找到可用的算法。到目前为止，我发现以下系列相当有效并且相对容易实现。

该公式是使用收敛加速技术从Leibniz系列推导而来的，要推导该公式，请参见Carl D.Offner撰写的《计算？中的数字》（https://cs.umb.edu/~offner/files/pi.pdf） ，第19-26页。最终公式显示在第26页。我编写的初始公式有错别字，请刷新页面以查看固定公式。2第54页中解释了最大术语中的常数项。该白皮书还介绍了一种高级迭代算法，但是我在这里没有使用它。

如果一个人使用许多（例如5000）项来评估该系列，则有可能获得千位数的？。容易，并且我发现使用此算法，该系列也易于迭代评估：

算法

1. 首先，重新排列公式以从数组中获取其常数项。

2. 用2填充数组以开始第一次迭代，因此新公式类似于原始公式。

3. 让carry = 0。

4. 从最伟大的任期开始。从数组中获得一项（2），将其乘以PRECISION对进行定点除法2 * i + 1，然后将提示作为新项保存到数组中。然后添加下一项。现在递减i，转到下一学期，重复直到i == 1。最后加上最后一项x_0。

5. 由于使用的PRECISION是16位整数10，因此，将获得2个十进制数字，但只有第一个数字有效。将第二个数字另存为进位。显示第一个数字加进位。

6. x_0 是整数2，不应为后续迭代添加整数，将其清除。

7. 转到第4步，计算下一个十进制数字，直到获得所需的所有数字为止。

实施1

将此算法转换为C：

#include <stdio.h>
#include <stdint.h>

#define N 2160
#define PRECISION 10

uint16_t terms[N + 1] = {0};

int main(void)
{
    /* initialize the initial terms */
    for (size_t i = 0; i < N …

我在Oracles文档中看到了相互矛盾的引用.FLOAT中的小数与数据库中的NUMBER类型之间的存储方式有何不同？

正如我从C等人那里回忆的那样,浮点数具有int没有的精度限制.Rg,对于'浮点数,0.1(基数10)近似为0.110011001100110011001101(基数2),其等于0.100000001490116119384765625(基数10).但是,对于'int',5(Base 10)正好是101(Base 2).

这就是为什么以下内容不会像C中预期的那样终止:

float i;
i = 0;
for (i=0; i != 10; )
{
    i += 0.1
}

但是我在Oracle文档的其他地方看到FLOAT已被定义为NUMBER.据我所知,Oracle的NUMBER类型的实现并没有遇到与C的浮点相同的问题.

那么,这里的真实故事是什么？Oracle是否偏离了我对浮动/ FLOATs的期望？

(我确信这对于我将要使用它们的方式来说是一个惊人的屁股,但我知道如果0.1*10出现在1.00000000000000001,我将会有问题)

我有一个16位定点处理器,我想用它进行定点处理.我正在寻找用于无符号16位整数的正确数据类型.

我的问题是:a uint16_t和uint_fast16_t？有什么区别？(这些都包含在stdint.h.)uint_fast16_t更好,因为它更快？

谢谢!!

如何将"32位有符号定点数(16.16)"转换为浮点数？

是否(fixed >> 16) + (fixed & 0xffff) / 65536.0确定？-2.5怎么样？和-0.5？

还是fixed / 65536.0正确的方法？

(PS:无论如何,签名定点"-0.5"在内存中是怎样的？)

我想反转一个4x4矩阵.我的数字以定点格式存储(准确地说是1.15.16).

使用浮点运算,我通常只需构建伴随矩阵并除以行列式(例如强力解决方案).到目前为止,这对我有用,但在处理定点数时,由于使用了所有乘法,我得到了不可接受的精度损失.

注意:在定点运算中,我总是丢弃一些立即结果的最低有效位.

那么 - 反转矩阵的数值最稳定的方法是什么？我不太关心性能,但简单地说浮点就是放慢我的目标架构.

我有一个使用双打的C代码.我希望能够在DSP(TMS320)上运行代码.但DSP不支持双精度数,只支持定点数.将代码转换为定点的最佳方法是什么？是否有一个很好的C库用于定点数(实现为整数)？

我已经达到了一个项目的重点,开始为向量和misc三角函数构建一些支持类比继续使用ad-hoc函数更有意义.我希望有很多C++库,但我不想牺牲我习惯的速度和功能.

具体来说,我希望能够使用整数角度,我想保持这样的近似值提供的超快速度:

static inline int32_t sin_approx(int32_t angle)
//Angle is -32768 to 32767: Return -32768 to 32767
{
    return (angle<<1) - ((angle*abs(angle))>>14);
}

所以,在我不必要地推出自己的之前,是否有任何真正快速的c ++定点库,其中包含模板类,例如向量,我可以指定所用整数的宽度,并且具有快速近似值,例如上面的那个,我应该看一下？

BigDecimal.add当一个参数具有大指数(9位数)时,方法需要很长时间,而第二个参数具有不同长度的指数.我已经等了5分钟以上,而且还在继续.

这是代码:

@Test
public void testAddBig() throws Exception {
    MathContext mc = new MathContext(10, RoundingMode.HALF_UP);
    BigDecimal v1 = new BigDecimal("1E+100000000", mc);
    BigDecimal v2 = new BigDecimal("1", mc);
    System.out.println(v1.add(v2));
}

这是线程转储的一部分:

at java.math.BigInteger.square(BigInteger.java:1884)
at java.math.BigInteger.squareKaratsuba(BigInteger.java:1975)
at java.math.BigInteger.square(BigInteger.java:1888)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2011)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2006)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2012)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2010)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2006)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2012)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.squareToomCook3(BigInteger.java:2011)
at java.math.BigInteger.square(BigInteger.java:1890)
at java.math.BigInteger.pow(BigInteger.java:2263)
at java.math.BigDecimal.bigTenToThe(BigDecimal.java:3543)
at java.math.BigDecimal.bigMultiplyPowerTen(BigDecimal.java:4508)
at java.math.BigDecimal.add(BigDecimal.java:4443)
at java.math.BigDecimal.add(BigDecimal.java:1289)

到底是怎么回事？这是一个错误吗？

我正在研究一种应该实时运行的流体动力学Navier-Stokes求解器.因此,表现很重要.

现在,我正在研究一些紧密的循环,每个循环占执行时间的很大一部分:没有单一的瓶颈.这些循环中的大多数都进行了一些浮点运算,但是它们之间存在很多分支.

浮点运算主要限于加法,减法,乘法,除法和比较.所有这些都是使用32位浮点数完成的.我的目标平台是x86,至少有SSE1指令.(我在汇编器输出中验证了编译器确实生成了SSE指令.)

我正在使用的大多数浮点值具有相当小的上限,而接近零值的精度并不是非常重要.所以我想到了这样的想法:也许转换到定点算法会加快速度？我知道唯一可以确定的方法是测量它,可能需要数天,所以我想事先了解成功的可能性.

在Doom的时代,定点已经风靡一时,但我不确定它在2010年的位置.考虑到现在有多少芯片被用于浮点性能,是否有可能定点运算仍然存在给我一个显着的速度提升？有没有人有任何可能适用于我的情况的实际经验？