javascript

java

python

c#

android

c++

node.js

php

html

jquery

ios

reactjs

css

.net

git

ruby-on-rails

sql

c

ruby

string

从int到float和b时符号更改

考虑以下代码,这是我的实际问题的SSCCE:

#include <iostream>

int roundtrip(int x)
{
    return int(float(x));
}

int main()
{
    int a = 2147483583;
    int b = 2147483584;
    std::cout << a << " -> " << roundtrip(a) << '\n';
    std::cout << b << " -> " << roundtrip(b) << '\n';
}

我的计算机(Xubuntu 12.04.3 LTS)上的输出是:

2147483583 -> 2147483520
2147483584 -> -2147483648

请注意,正数b在往返之后如何以负数结束。 这种行为是否有明确规定? 我本来希望从int到float的往返至少能够正确保留符号...

嗯,在ideone上,输出是不同的:

2147483583 -> 2147483520
2147483584 -> 2147483647

g ++小组是在同时修复了一个错误,还是两个输出都完全有效?

trans by 2020-08-12T04:59:33Z

浮点-Haskell范围和浮点数

为什么float的Haskell范围符号的行为与整数和char的行为不同?

Prelude> [1, 3 .. 10] :: [Int]
[1,3,5,7,9] 
Prelude> [1, 3 .. 10] :: [Float]
[1.0,3.0,5.0,7.0,9.0,11.0]
Prelude> ['a', 'c' .. 'f']
"ace"

如果最后一个元素接近上限,我会理解的,但这显然不是一个四舍五入的问题。

trans by 2020-08-11T05:37:56Z

c ++-用二进制表示法,小数点“。”之后的数字是什么意思?

我有一个有关如何从基数10转换为IEEE 754浮点表示的示例

Number: 45.25 (base 10) = 101101.01 (base 2) Sign: 0
Normalized form N = 1.0110101 * 2^5
Exponent esp = 5  E = 5 + 127 = 132 (base 10) = 10000100 (base 2)
IEEE 754: 0 10000100 01101010000000000000000

这对我来说很有意义,只有一段内容:

45.25 (base 10) = 101101.01 (base 2)

45是101101的二进制文件,这没关系..但是他们是如何获得0.25的.01呢?

trans by 2020-08-08T18:20:20Z

c-pow()似乎快了一个小时

这里发生了什么:

#include <stdio.h>
#include <math.h>
int main(void) {
    printf("17^12 = %lf\n", pow(17, 12));
    printf("17^13 = %lf\n", pow(17, 13));
    printf("17^14 = %lf\n", pow(17, 14));
}

我得到以下输出:

17^12 = 582622237229761.000000
17^13 = 9904578032905936.000000
17^14 = 168377826559400928.000000

13和14与Wolfram alpha cf不匹配:

12: 582622237229761.000000
    582622237229761

13: 9904578032905936.000000
    9904578032905937

14: 168377826559400928.000000
    168377826559400929

而且,这在某种程度上没有错-错在一个!

如果这取决于我,达到了pow()可以为我做的极限,是否有替代方法可以计算出此结果? 我需要一个可以计算x^y的函数,其中x^y始终小于ULLONG_MAX。

trans by 2020-08-07T02:20:33Z

java-一个实际示例,其中使用BigDecimal货币比使用doub严格更好

我们知道,使用double作为货币容易出错,因此不建议使用。 但是,我还没有看到一个实际的示例,其中double可以工作,而BigDecimal306会失败,并且不能通过一些舍入简单地解决。


注意琐碎的问题

double total = 0.0;
for (int i = 0; i < 10; i++) total += 0.1;
for (int i = 0; i < 10; i++) total -= 0.1;
assertTrue(total == 0.0);

不计入,因为它们通过四舍五入得到了平凡的解决(在此示例中,从零到小数点后十六位都可以)。


涉及累加大值的计算可能需要一些中间步骤,但考虑到流通的总货币为double,Java double(即标准IEEE双精度)及其15位十进制数字仍然足以作为美分。


即使使用double304,涉及除法的计算也通常是不精确的。我可以构造一个不能用doubles执行的计算,但是可以使用100的比例来使用BigDecimal306进行计算,但是实际上这不是您可以遇到的。


我并不是说这样一个现实的例子不存在,只是我还没有看到它。

我也肯定同意,使用double更容易出错。

我正在寻找的是类似以下的方法(基于Roland Illig的回答)

/** 
  * Given an input which has three decimal places,
  * round it to two decimal places using HALF_EVEN.
*/
BigDecimal roundToTwoPlaces(BigDecimal n) {
    // To make sure, that the input has three decimal places.
    checkArgument(n.scale() == 3);
    return n.round(new MathContext(2, RoundingMode.HALF_EVEN));
}

加上类似的测试

public void testRoundToTwoPlaces() {
    final BigDecimal n = new BigDecimal("0.615");
    final BigDecimal expected = new BigDecimal("0.62");
    final BigDecimal actual = roundToTwoPlaces(n);
    Assert.assertEquals(expected, actual);
}

如果使用double天真地重写了此代码,则测试可能会失败(不是针对给定的输入,而是针对其他输入)。 但是,它可以正确完成:

static double roundToTwoPlaces(double n) {
    final long m = Math.round(1000.0 * n);
    final double x = 0.1 * m;
    final long r = (long) Math.rint(x);
    return r / 100.0;
}

它很丑陋,而且容易出错(可能可以简化),但是可以很容易地封装在某个地方。 这就是为什么我在寻找更多答案。

trans by 2020-08-05T18:37:48Z

c-浮点乘法与重复加法

N为编译时无符号整数。

GCC可以优化

unsigned sum = 0;
for(unsigned i=0; i<N; i++) sum += a; // a is an unsigned integer   

可以简单地理解为O(N)。这是可以理解的,因为模数算法说O(Log(N))

但是,GCC不会进行优化

float sum = 0;
for(unsigned i=0; i<N; i++) sum += a;  // a is a float

O(N)

但是通过将关联数学与 O(N)我发现GCC可以按O(Log(N))的步长减少此值。 例如O(1),它可以用三个加法求和。

sum = a + a
sum = sum + sum // (a + a) + (a + a)
sum = sum + sum // ((a + a) + (a + a)) + ((a + a) + (a + a))

尽管在O(N)之后的某个时刻,GCC可以返回进行O(Log(N))总和。

我的问题是,为什么GCC在O(N)O(Log(N))之间不做?

而不是O(N)O(1)可能只是O(1)。由于在编译时已知61848396.000000 52707136.000000 52707136.000000,因此可以确定N是否适合浮点数。 即使N对于浮子而言太大了,它也可以sum =a*(float)(N & 0x0000ffff) + a*(float)(N & ffff0000)。实际上,我做了一点测试以检查准确性,而a*(float)N还是更准确(请参见下面的代码和结果)。

//gcc -O3 foo.c
//don't use -Ofast or -ffast-math or -fassociative-math
#include <stdio.h>   
float sumf(float a, int n)
{
  float sum = 0;
  for(int i=0; i<n; i++) sum += a;
  return sum;
}

float sumf_kahan(float a, int n)
{
  float sum = 0;
  float c = 0;
  for(int i=0; i<n; i++) {
    float y = a - c;
    float t = sum + y;
    c = (t -sum) - y;
    sum = t;
  }
  return sum;
}  

float mulf(float a, int n)
{
  return a*n;
}  

int main(void)
{
  int n = 1<<24;
  float a = 3.14159;
  float t1 = sumf(a,n);
  float t2 = sumf_kahan(a,n);
  float t3 = mulf(a,n);
  printf("%f %f %f\n",t1,t2,t3);
}

结果是61848396.000000 52707136.000000 52707136.000000,这表明乘法和Kahan求和具有相同的结果,我认为这表明乘法比简单和更准确。

trans by 2020-08-05T05:24:02Z

python-将timedelta转换为浮点数

我从两个日期时间中减去了一个timedelta对象。 我需要将此值作为浮点进行进一步的计算。我发现的所有内容都可以使用浮点数进行计算,但是结果仍然是一个timedelta对象。

time_d = datetime_1 - datetime_2
time_d_float = float(time_d)

不起作用。

trans by 2020-08-03T09:43:11Z

java-将double乘以100,然后强制转换为long给出错误的值

我有以下代码:

Double i=17.31;
long j=(long) (i*100);
System.out.println(j);

O / P:1533 //Expected:1533{as Expected}

Double i=17.33;
long j=(long) (i*100);
System.out.println(j);

O/P : 1533 //Expected:1533{as Expected}

Double i=17.32;
long j=(long) (i*100);
System.out.println(j);

O/P : 1533 //Expected:1533{as Expected}

Double i=15.33;
long j=(long) (i*100);
System.out.println(j);

O/P : 1533 //Expected:1533{as Expected}

我已经尝试过使用Google,但找不到原因。如果问题很简单,我们感到抱歉。

trans by 2020-08-01T12:45:04Z

算法-“近似”最大公约数

假设您有一个浮点数列表,它们大约是一个公共数量的倍数,例如

2.468, 3.700, 6.1699

大约是1.234的所有倍数。 您将如何表征此“近似gcd”,又将如何进行计算或估算?

与我对这个问题的回答密切相关。

trans by 2020-07-31T03:46:39Z

c-printf和co如何区分float和double

因为它不是强类型的,所以我认为它只是选择了正确的内存大小并根据参数的类型对其进行了解释。 但是float和double都使用%f,并且它们的大小不同。

附言我可以看到通过将值复制到临时表和强制转换(这对吗?)进行促销的方式但是它对scanfs / sscanf如何工作?

trans by 2020-07-30T20:39:07Z

转换-Scala将两个整数相除并得到一个浮点数resu

如果我执行以下操作

 println(3/4)
 >0

我想得到一个十进制的答案,而不是一个整数。 由于我在实际代码中进行打印的方式,如果可能的话,我希望在println中进行强制转换。

trans by 2020-07-28T13:20:33Z

OCam中的80位扩展精度浮点

是否有OCaml库可以利用IA-32和x86-64体系结构上的80位扩展精度浮点类型?

我知道MPFR绑定,但是我理想的库会更轻量。 利用历史浮点指令将是理想的。

trans by 2020-07-18T22:07:50Z

jQuery-获取元素的实际浮点宽度

我正在使用jQuery(v1.7.1),我需要获取元素的绝对浮点宽度,但是jQuery的所有width方法似乎都是舍入width的值。

例如,如果元素的实际宽度为20.333333px,则jQuery的width方法返回20,即忽略十进制值。

您可以在这个jsFiddle上看到我的意思

因此,我的问题是:如何获取元素宽度的浮点值?

trans by 2020-07-18T03:12:24Z

将浮点数四舍五入到j中的下一个整数值

我如何将浮点数四舍五入为Java中的下一个整数值? 假设

2.1 -->3

3.001 -->4

4.5 -->5

7.9 -->8

trans by 2020-07-13T18:10:55Z

用pow(x,2)代替x * x和x double有什么好处吗?

使用此代码有什么好处

double x;
double square = pow(x,2);

而不是这个?

double x;
double square = x*x;

我更喜欢x * x并查看我的实现(Microsoft),在pow中没有发现任何优势,因为对于特定的方形情况,x * x比pow更简单。

在某些情况下战俘是优越的吗?

trans by 2020-07-13T10:44:02Z

c-具有恒定整数除数的有效浮点除法

最近的一个问题,即是否允许编译器用浮点乘法代替浮点除法,启发了我提出这个问题。

在严格的要求下,代码转换后的结果应与实际的除法运算按位相同,显而易见,对于二进制IEEE-754算术,除数为2的幂是可能的。 只要互惠除数的乘积可表示,乘以除数的倒数可得出与除法相同的结果。 例如,乘以x可以替换除以y

然后,一个人想知道这样的除法运算还有其他除数,假设我们允许任何简短的指令序列来代替除法运算,但运行速度明显加快,同时又能产生位相同的结果。 特别是除了普通乘法之外,还允许融合乘法加法运算。在评论中,我指出了以下相关论文:

Nicolas Brisebarre,Jean-Michel Muller和Saurabh Kumar Raina。 预先知道除数时,可以加速正确舍入的浮点除法。 IEEE计算机事务,卷。 53,2004年8月,第8卷,第1069-1072页。

本文作者提倡的技术将除数y的倒数预先计算为归一化的头尾对zh:zl,如下所示:zh = 1 / y,zl = fma(-y,zh,1)/ y。 然后,除法q = x / y然后计算为q = fma(zh,x,zl * x)。 本文推导了除数y才能使该算法起作用的各种条件。 正如人们容易观察到的那样,当头尾符号不同时,该算法存在无限性和零的问题。 更重要的是,由于商尾zl * x的计算会出现下溢,因此对于数量非常小的分红x,它将无法提供正确的结果。

本文还为Peter Markstein在IBM任职时提出的基于FMA的替代除法算法提供了参考。 相关参考是:

P. W. Markstein。 IBM RISC System / 6000处理器上的基本功能的计算。 IBM研究与发展杂志,第1卷。 1990年1月34日第1期,第111-119页

在马克斯坦算法中,首先计算一个倒数rc,由此形成初始商q = x * rc。 然后,使用FMA准确地计算除法的余数,即r = fma(-y,q,x),最后将改进的更精确的商计算为q = fma(r,rc,q)。

该算法还存在x为零或无穷大的问题(可以通过适当的条件执行轻松解决),但是使用IEEE-754单精度2962651399022183483424数据进行的详尽测试表明,它对所有除数y的所有可能性红利x均提供了正确的商 ,其中有许多小整数。 此C代码实现了它:

/* precompute reciprocal */
rc = 1.0f / y;

/* compute quotient q=x/y */
q = x * rc;
if ((x != 0) && (!isinf(x))) {
    r = fmaf (-y, q, x);
    q = fmaf (r, rc, q);
}

在大多数处理器体系结构上,这应该使用谓词,条件移动或选择类型的指令转换为无分支指令序列。 举一个具体的例子:为了除以29626513990221834834,CUDA 7.5的y编译器为开普勒级GPU生成以下机器代码:

    LDG.E R5, [R2];                        // load x
    FSETP.NEU.AND P0, PT, |R5|, +INF , PT; // pred0 = fabsf(x) != INF
    FMUL32I R2, R5, 0.3333333432674408;    // q = x * (1.0f/3.0f)
    FSETP.NEU.AND P0, PT, R5, RZ, P0;      // pred0 = (x != 0.0f) && (fabsf(x) != INF)
    FMA R5, R2, -3, R5;                    // r = fmaf (q, -3.0f, x);
    MOV R4, R2                             // q
@P0 FFMA R4, R5, c[0x2][0x0], R2;          // if (pred0) q = fmaf (r, (1.0f/3.0f), q)
    ST.E [R6], R4;                         // store q

对于我的实验,我编写了下面显示的微型C测试程序,该程序以递增的顺序逐步通过整数除数,并且对于每个除数,都针对适当的除法详尽测试了上述代码序列。 它打印通过此详尽测试的除数的列表。 部分输出如下所示:

PASS: 1, 2, 3, 4, 5, 7, 8, 9, 11, 13, 15, 16, 17, 19, 21, 23, 25, 27, 29, 31, 32, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 64, 65, 67, 69,

为了将替换算法作为优化合并到编译器中,可以安全地应用上述代码转换的除数白名单是不切实际的。 到目前为止,该程序的输出(每分钟大约一个结果的速率)表明,对于那些除数为2962651399022183483425的奇数整数或为2的幂的整数,快速代码可以在所有x的可能编码中正确工作。 传闻证据当然不是证据。

哪些数学条件集可以先验地确定将除法转换为上述代码序列是否安全? 答案可以假定所有浮点运算都是在默认舍入模式“四舍五入到最接近或偶数”下执行的。

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int main (void)
{
    float r, q, x, y, rc;
    volatile union {
        float f;
        unsigned int i;
    } arg, res, ref;
    int err;

    y = 1.0f;
    printf ("PASS: ");
    while (1) {
        /* precompute reciprocal */
        rc = 1.0f / y;

        arg.i = 0x80000000;
        err = 0;
        do {
            /* do the division, fast */
            x = arg.f;
            q = x * rc;
            if ((x != 0) && (!isinf(x))) {
                r = fmaf (-y, q, x);
                q = fmaf (r, rc, q);
            }
            res.f = q;
            /* compute the reference, slowly */
            ref.f = x / y;

            if (res.i != ref.i) {
                err = 1;
                break;
            }
            arg.i--;
        } while (arg.i != 0x80000000);

        if (!err) printf ("%g, ", y);
        y += 1.0f;
    }
    return EXIT_SUCCESS;
}
trans by 2020-07-12T03:45:48Z

循环中使用“ double”作为计数器变量

在我目前正在阅读的书中,有以下摘录:

您也可以使用浮点数 值作为循环计数器。 这是一个 这种类型的x循环的示例 柜台:

x

此代码段计算 0.0的值x1.00.2,步长为 x; 但是,您需要保重 在使用浮点计数器时 一个循环。 许多十进制值不能是 准确地以二进制表示 浮点数形式,因此存在差异 可以累积值。 这意味着您不应编写 for循环,以便结束循环 取决于浮点循环 计数器达到精确值。 对于 例如,以下设计不良 循环永无止境:

x

这个循环的目的是 输出随其变化的x的值 从0.01.0; 但是,0.2 没有确切的表示为 二进制浮点值,所以 x的值永远不会完全是1。 这样,第二个循环控制 表达式始终为假,并且 循环无限期地继续。

有人可以解释第一个代码块如何运行而第二个代码块不运行吗?

trans by 2020-07-09T23:05:04Z

如何在Python中正确舍入半浮点数?

我面临着fractions函数的奇怪行为:

for i in range(1, 15, 2):
    n = i / 2
    print(n, "=>", round(n))

此代码打印:

0.5 => 0
1.5 => 2
2.5 => 2
3.5 => 4
4.5 => 4
5.5 => 6
6.5 => 6

我希望浮点值总是四舍五入,但是取整到最接近的偶数。

为什么会出现这种行为?获得正确结果的最佳方法是什么?

我尝试使用fractions,但结果是相同的。

trans by 2020-07-09T14:34:45Z

c + +乘以1.0和int到float转换的精度

可以安全地假设条件(int)(i * 1.0f) == i对任何整数i是正确的吗?

trans by 2020-07-08T13:07:40Z

数学-在JavaScript中,为什么零除以零会返回NaN,而其他零除会返回Infinity?

在我看来,代码

console.log(1 / 0)

应该返回NaN,但返回x / 0。但是,此代码:

console.log(0 / 0)

返回NaN。有人可以帮助我了解此功能的原因吗? 在x / 0的情况下,不仅看起来不一致,而且似乎也错了,其中x !== 0

trans by 2020-07-08T03:02:48Z

1 2 3 4 5 6 7 8 9 10 11 下一页 共11页