我是偏执狂,其中一个函数可能会给出一个不正确的结果:

std::floor(2000.0 / 1000.0) --> std::floor(1.999999999999) --> 1
or
std::ceil(18 / 3) --> std::ceil(6.000000000001) --> 7

可以这样的事情发生吗？如果确实存在这样的风险,我打算使用以下功能以便安全地工作.但是,这真的有必要吗？

constexpr long double EPSILON = 1e-10;

intmax_t GuaranteedFloor(const long double & Number)
{
    if (Number > 0)
    {
        return static_cast<intmax_t>(std::floor(Number) + EPSILON);
    }
    else
    {
        return static_cast<intmax_t>(std::floor(Number) - EPSILON);
    }
}

intmax_t GuaranteedCeil(const long double & Number)
{
    if (Number > 0)
    {
        return static_cast<intmax_t>(std::ceil(Number) + EPSILON);
    }
    else
    {
        return static_cast<intmax_t>(std::ceil(Number) - EPSILON);
    }
}

(注意:我假设给定的'long double'参数适合'intmax_t'返回类型.)

有没有办法设置Perl脚本的浮点精度(3位数),而不必专门为每个变量更改它？

类似于TCL的东西:

global tcl_precision
set tcl_precision 3

为什么添加相同数字时输出会有所不同？

public class Test {

    public static void main(String a[]) {

        double[] x = new double[]{3.9, 4.3, 3.6, 1.3, 2.6};
        System.out.println(">>>>>>> " + sum(x));
    }

    public static double sum(double[] d) {

        double sum = 0;
        for (int i = 0; i < d.length; i++) {
            sum += d[i];
        }
        return sum;
    }
}

输出是: 15.7

如果我交换价值观

double[] x = new double[] {2.6, 3.9, 4.3, 3.6, 1.3};

我得到输出为: 15.700000000000001

如何获得相同的输出？

有人能给我一个浮点数(双精度)的例子,需要超过16个有效十进制数来表示它吗？

我在这个帖子中发现,有时候你需要多达17位,但我无法找到这样一个数字的例子(16对我来说似乎足够了).

有人可以澄清一下吗？

非常感谢!

我注意到如果A是NxN矩阵并且它具有逆矩阵.但是inv()和pinv()函数输出是不同的. - 我的环境是Win7x64 SP1,Matlab R2012a,Cygwin Octave 3.6.4,FreeMat 4.2

看看Octave的例子:

A = rand(3,3)
A =
0.185987   0.192125   0.046346
0.140710   0.351007   0.236889
0.155899   0.107302   0.300623

pinv(A) == inv(A)
ans =
0 0 0
0 0 0
0 0 0

• 这一切都同ans通过上面运行在Matlab同一命令的结果.

• 我计算inv(A)*A或A*inv(A),结果是Octave和Matlab中的身份3x3矩阵.
• 结果A*pinv(A)和pinv(A)*A在Matlab和FreeMat身份3x3矩阵.
• 的结果 A*pinv(A)是Octave中的身份3x3矩阵.
• 结果pinv(A)*A是不是在倍频身份3x3矩阵.

我不知道原因 inv(A) != pinv(A),我已经考虑了矩阵中元素的细节.这似乎是导致这个问题的浮动精度问题.

点点后10位数可能不同,如下所示:

• 6.65858991579923298331777914427220821380615200000000inv(A)(1,1)反对的元素

• 6.65858991579923209513935944414697587490081800000000 元素 pinv(A)(1,1)

在Java中,将倍数乘以0.0000001,将其除以10000000？我的直觉是可能存在差异,因为0.0000001不能完全用双精度表示.

我试图在swift中分隔double的十进制和整数部分.我尝试了很多方法,但它们都遇到了同样的问题......

let x:Double = 1234.5678
let n1:Double = x % 1.0           // n1 = 0.567800000000034
let n2:Double = x - 1234.0        // same result
let n3:Double = modf(x, &integer) // same result

有没有办法获得0.5678而不是0.567800000000034而无需将数字转换为字符串？

执行此浮点计算时boost::thread,它会产生与std::thread在主线程中或主线程中执行时不同的结果.

void print_number()
{
    double a = 5.66;
    double b = 0.0000001;
    double c = 500.4444;
    double d = 0.13423;
    double v = std::sin(d) * std::exp(0.4 * a + b) / std::pow(c, 2.3);

    printf("%llX\n%0.25f\n", *reinterpret_cast<unsigned long long*>(&v), v);
}

这似乎是因为boost::thread默认情况下使用53位内部精度进行浮点数学运算,而主线程使用的是64位精度.如果在创建_fpreset()后重置FPU单元的状态boost::thread,则结果与主线程中的结果相同.

我正在使用Embarcadero C++ Builder 10.1(编译器bcc32c版本3.3.1)和Boost 1.55.0.我的环境是Windows 7,我正在构建32位Windows目标.

工作范例:

#include <tchar.h>
#include <thread>
#include <boost/thread.hpp>
#include <cstdio>
#include <cmath>
#include <cfloat>

namespace boost { void tss_cleanup_implemented() {} }

void print_number()
{
    double …

我知道big-endian机器和little-endian机器之间的整数格式会有所不同,浮点格式(IEEE 754)是否相同？

" Python中"round"函数的行为 "观察到Python循环浮动如下:

>>> round(0.45, 1)
0.5
>>> round(1.45, 1)
1.4
>>> round(2.45, 1)
2.5
>>> round(3.45, 1)
3.5
>>> round(4.45, 1)
4.5
>>> round(5.45, 1)
5.5
>>> round(6.45, 1)
6.5
>>> round(7.45, 1)
7.5
>>> round(8.45, 1)
8.4
>>> round(9.45, 1)
9.4

接受的答案证实这是由于浮点数的二进制表示不准确引起的,这都是合乎逻辑的.

假设Ruby浮点数和Python一样不准确,那么Ruby如何像人类一样漂浮？Ruby欺骗了吗？

1.9.3p194 :009 > 0.upto(9) do |n|
1.9.3p194 :010 >     puts (n+0.45).round(1)
1.9.3p194 :011?>   end
0.5
1.5
2.5
3.5
4.5
5.5
6.5
7.5
8.5
9.5