标签: ieee-754

我实现了W3s推荐的算法,用于将SVG路径弧从端点弧转换为中心弧并返回 Haskell.

type EndpointArc = ( Double, Double, Double, Double
                   , Bool, Bool, Double, Double, Double )

type CenterArc = ( Double, Double, Double, Double
                 , Double, Double, Double )

endpointToCenter :: EndpointArc -> CenterArc

centerToEndpoint :: CenterArc -> EndpointArc

请在此处查看完整实施和测试代码.

但我无法通过这个属性:

import Test.QuickCheck
import Data.AEq ((~==))

instance Arbitrary EndpointArc where
    arbitrary = do
        ((x1,y1),(x2,y2)) <- arbitrary `suchThat` (\(u,v) -> u /= v)
        rx                <- arbitrary `suchThat` (>0)
        ry                <- arbitrary `suchThat` (>0)
        phi               <- choose (0,2*pi)
        (fA,fS) …

假设我执行此操作:

(X / const) * const

使用双精度参数定义IEEE 754-2008,首先划分,然后乘法.

const在范围内0 < ABS(const) < 1.

假设操作成功(没有溢出),X这个操作的不同参数是否保证返回不同的结果？

换句话说,还有什么X1,X2并0 < ABS(const) < 1让X1 <> X2,但(X1 / const) * const = (X2 / const) * const？

我正在重新审视一个问题(如何测试数字转换是否会改变值？),就我所关注的问题而言,我已经完全解决了.问题是检测特定数值何时会溢出JavaScript的IEEE-754数字类型.之前的问题是使用C#,标记的答案完美无缺.

现在我正在执行完全相同的任务,但这次是在Java中,它不起作用.AFAIK,Java使用IEEE-754作为其双数据类型.所以我应该能够来回摆动它以强制失去精确度,但它往返.对此感到困惑,我开始深入研究Java,现在我真的很困惑.

在C#和Java中,long的最小值和最大值都是相同的:

long MIN_VALUE = -9223372036854775808L;
long MAX_VALUE = 9223372036854775807L;

AFAIK,这些值超出了IEEE-754中可表示的数字,因为为指数和符号保留了固定位.

// this fails in browsers that have stuck with the pure ECMAScript Number format
var str = Number(-9223372036854775808).toFixed();
if ("-9223372036854775808" !== str) { throw new Error("Overflow!"); }

这将false在Java中返回(value = -9223372036854775808L):

boolean invalidIEEE754(long value) {
    try {
        return ((long)((double)value)) != value;
    } catch (Exception ex) {
        return true;
    }
}

这将false在Java中返回(value = -9223372036854775808L):

boolean invalidIEEE754(long value) {
    // trying to get closer to …

我正在python中读取二进制文件,如下所示:

from struct import unpack

ns = 1000
f = open("binary_file", 'rb')

while True:
    data = f.read(ns * 4)
    if data == '':
        break
    unpacked = unpack(">%sf" % ns, data)
    print str(unpacked)

当我意识到unpack(">f", str)要解压缩IEEE浮点数时,我的数据是IBM的32位浮点数

我的问题是:我如何能够unpack解压缩IBM 32位浮点型数字？

我不介意使用ctypes扩展python来获得更好的性能.

编辑:我做了一些搜索:http: //mail.scipy.org/pipermail/scipy-user/2009-January/019392.html

这看起来非常有希望,但我希望提高效率:潜在的成千上万的循环.

编辑:发布以下答案.谢谢你的提示.

我最近一直致力于一个需要存储和加载大量数据的系统,包括单精度浮点值.我决定对整数的网络字节顺序进行标准化,并决定以big-endian格式存储浮点值,即:

  |-- Byte 0 --| |-- Byte 1 -|  Byte 2   Byte 3
  #      ####### #     ####### ######## ########
Sign     Exponent          Mantissa
 1b    8b, MSB first    23b, MSB first

理想情况下,我想提供类似的功能htonl()和ntohl(),因为我已经使用这些用于擦拭整数,我也希望有尽可能多的平台独立性尽可能的方式来实现这一点(而假设float类型对应于IEEE754 32位浮点值).有没有办法,可能使用ieee754.h,这样做？

我有一个答案似乎有效,我将在下面发布,但它似乎非常缓慢和低效,我会感谢有关如何使其更快和/或更可靠的任何建议.

大多数浮点数都没有精确存储(使用IEEE-754格式时),这是一种常见的知识.所以不应该这样做:

0.3 - 0.2 === 0.1; // very wrong

......因为它会导致false,除非使用一些特定的任意精度的类型/类(BigDecimal的中的Java/Ruby的,bcmath时在PHP中,数学:: BigInt有/数学:: BigFloat在Perl,仅举几例)来代替.

但我想知道为什么当一个人尝试打印这个表达式的结果时0.3 - 0.2,脚本语言(Perl和PHP)给出了0.1,但是"虚拟机"(Java,JavaScript和Erlang)提供了更类似的东西0.09999999999999998呢？

为什么它在Ruby中也不一致？版本1.8.6(键盘)给出0.1,版本1.9.3(ideone)给出了0.0999...

IEEE 754标准将负零的平方根定义为负零.这种选择很容易合理化,但其他选择(如定义sqrt(-0.0)为NaN)也可以合理化,并且更容易在硬件中实现.如果担心程序员会编写if (x >= 0.0) then sqrt(x) else 0.0并被这个表达式判断为何NaN时x被评估-0.0,那么sqrt(-0.0)就可以将其定义为+0.0(实际上,对于这个特定的表达式,结果会更加一致).

是否存在特定的数值算法,其中sqrt(-0.0)定义为-0.0简化算法本身的逻辑？

是否有更快的替代以下表达式:

Math.pow(2,Math.floor(Math.log(x)/Math.log(2)))

也就是说,取最接近(较小)的2的整数倍？我在内循环中有这样的表达.我怀疑它可能会快得多,考虑到可以从双尾的IEEE 754表示中获取尾数.

我很惊讶

>>> import math
>>> 1**math.nan
1.0

虽然我们也是这样,但也是如此

>>> 0j**math.nan
0j

我没有找到任何其他例子.是否有一个我错过的理由或逻辑使得这个选择成为正确的选择？或者这是一个滑倒？

我在期待nan.至于除了1或之外的其他所有数字0j.

编辑1:感谢jedwards的评论,我有一个参考.但我仍然不明白为什么.为什么这个决定作为标准？另外,找不到参考0j**mat.nan......

编辑2:所以按照下面的答案和其他一些东西,逻辑可能是这样的:任何涉及的计算都nan应该返回,nan除非计算总是返回相同的答案而不管参数.在这种情况下,我们nan作为论据的事实不应该影响结果,我们仍然应该得到固定的答案.

这当然解释1**math.nan和math.nan**0.这也解释了为什么0**math.nan给nan,而不是0(因为0**n是0为所有,但,当n=0它与结果1),并可能被展宽到为什么math.nan*0是nan如果我们同意该说法不一定是有限的.

但如果这是现场背后的逻辑,那么0j**math.nan应该是nan,因为0j**n是0对所有n除的n=0地方0j**0是1.所以...确实0j**math.nan有不同的推理？或者是实施中的问题？

In JavaScript, the NaN value can be represented by a wide range of 64-bit doubles internally. Specifically, any double with the following bitwise representation:

x111 1111 1111 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx

Is interpreted as a NaN. My question is: suppose I cast two 32-bit uints to a JS Number using ArrayBuffers, pass it around, then cast it back to two 32-bit uints. Will the recovered bits be the same as the …