我不断得到浮点数(即float,, double或long double)是否只有一个精度值,或者具有可以变化的精度值的混合答案.
一个名为float vs. double precision的主题似乎暗示浮点精度是绝对的.
然而,另一个叫做float和double之间差异的话题说,
通常,double具有15到16个十进制数字的精度
另一位消息人士称
float类型的变量通常具有大约 7位有效数字的精度
double类型的变量通常具有大约 16位有效数字的精度
如果我正在使用敏感代码,当我的值不准确时,我不喜欢引用上面的近似值.所以让我们记录下来吧.浮点精度是可变的还是不变的,为什么？
floating-point binary decimal significant-digits floating-point-precision
如果您在编译器中放入以下代码,结果有点奇怪:
decimal x = (276/304)*304;
double y = (276/304)*304;
Console.WriteLine("decimal x = " + x);
Console.WriteLine("double y = " + y);
结果:
十进制x = 275.99999999999999999999999
双y = 276.0
谁可以给我解释一下这个？我不明白这是怎么回事.
我正在32位cortex m4微控制器上编写函数.该函数必须能够乘以不同大小的矩阵,这是我无法预测的.所以我必须使用malloc ......
但我不明白为什么我的mc在执行以下行时总是进入默认处理程序中断:
double *output2=NULL;
output2 = malloc(3 *1* sizeof(double *));
这个mc是不是能够处理这种类型的操作？虽然这在我的笔记本电脑上工作得很好!
**编辑*
这里有一些更多的代码(仍然需要修改......):好吧所有的malocs都失败了.我无法为"malloced"数组赋值.
int main (void)
{
/*some stuff*/
float transFRotMatrix[3][3]={0}; //array gets modified by other functions
float sunMeasurements[3][1] = {{1},{2},{3}}; //test values
multiplyMatrices( &transFRotMatrix[0][0],3, 3, &sunMeasurements[0][0], 3, 1, *orbitalSunVector);
/*some stuff*/
}
void multiplyMatrices(float *transposedMatrix, int height1, int width1, float *iSunVector,int height2, int width2, float *orbitalSunVector)
{
int y=0;
int x = 0;
int row=0;
int column =0;
int k=0;
int k2 = 0;
float result = …奇怪的情况,当执行以下代码行时:
const float a = 47.848711;
const float b = 47.862952;
float result = b - a;
我得到一个(NSLog%.10f)结果= 0.0142440796.
我预计会得到0.0142410000.
这是怎么回事？
int main() {
float a = 20000000;
float b = 1;
float c = a+b;
if (c==a) { printf("equal"); }
else { printf("not equal");}
return 0;
}
当我跑这个时,它说"平等".但当我将a的值更改为2000000(少一个零)时答案是否定的.为什么？
可能重复:
浮点精度
double a=0.000001,b=50000;
b=a*b;
System.out.println("double:"+b); // -> double:0.049999999999999996
float a=0.000001f,b=50000;
b=a*b;
System.out.println("float"+b); // -> float0.05
我在代码的大部分时间里使用了double,今天我发现了这个问题.我该怎么处理？
语境:
double []refValues= {100,75,50,25,15,5,1};
double bInMilliGram=b*1000;
double pickedVal=0;
for(double ref:refValues)
if(ref<=bInMilliGram) {
pickedVal=ref;
break;
}
System.out.println("bInMilliGram:"+bInMilliGram+", pickedVal:"+pickedVal);
o/p: - > bInMilliGram:49.99999999999999,pickedVal:25.0
首先，请允许我承认我是一名经验丰富的程序员，拥有超过 10 年的编程经验。然而，我在这里问的问题是自从大约十年前我第一次拿起一本关于 C 的书以来一直困扰着我的问题。
\n\n下面是一本关于Python的书的摘录，解释了Python的浮动类型。
\n\n\n\n\n浮点数使用机器上浮点数的本机双精度（64 位）表示形式来表示。通常这是 IEEE 754，它提供大约 17 位精度和范围在 \xe2\x80\x93308 到 \n 308 的指数。这与 C 中的 double 类型相同。
\n
我一直不明白这句话的含义
\n\n\n\n\n“...提供大约 17 位精度和 \n 指数，范围为 \xe2\x80\x93308 到 308 ...”
\n
我的直觉在这里误入歧途，因为我可以理解精度的含义，但范围怎么可能与此不同。我的意思是，如果一个浮点数可以表示最多 17 位的值（即最多 1,000,000,000,000,000,00 - 1），那么指数怎么可能是 +308。如果指数为 10，这不会产生 308 位数字；如果指数为 2，这不会产生大约 100 位数字。
\n\n我希望我能够表达我的困惑。
\n\n问候\nVaid，阿布舍克
\n你知道如何解决数学精度的以下问题吗？
p RUBY_VERSION # => "1.9.1"
p 0.1%1 # => 0.1
p 1.1%1 # => 0.1
p 90.0%1 # => 0.0
p 90.1%1 # => 0.0999999999999943
p 900.1%1 # => 0.100000000000023
p RUBY_VERSION # => "1.9.2"
p 0.1%1 # => 0.1
p 1.1%1 # => 0.10000000000000009
p 90.0%1 # => 0.0
p 90.1%1 # => 0.09999999999999432
p 900.1%1 # => 0.10000000000002274
为什么要减去时,我得到了奇怪的结果2.99999...从3？
scala> math.sqrt(3)
res0: Double = 1.7320508075688772
scala> math.pow(res0, 2)
res1: Double = 2.9999999999999996
scala> 3 - res1
res2: Double = 4.440892098500626E-16