我float和之间的区别感到困惑double.我读过这篇文章.我认为差异只在于精确度.所以我期望如果0.1 + 0.2 == 0.3返回false那么0.1f + 0.2f == 0.3f.
但实际上是0.1f + 0.2f == 0.3f回归true.为什么？
这是纯粹的Java问题还是什么？
某些浮点数具有二进制浮点表示的固有不准确性:
> puts "%.50f" % (0.5) # cleanly representable
0.50000000000000000000000000000000000000000000000000
> puts "%.50f" % (0.1) # not cleanly representable
0.10000000000000000555111512312578270211815834045410
这不是什么 新鲜事.但为什么红宝石BigDecimal也表现出这种行为呢？
> puts "%.50f" % ("0.1".to_d)
0.10000000000000000555111512312578270211815834045410
(我正在使用rails速记.to_d而BigDecimal.new不仅仅是为了简洁,这不是特定于rails的问题.)
问题:为什么"0.1".to_d仍然会出现10 -17的错误？我认为目的BigDecimal明确是为了避免这样的不准确？
起初我认为这是因为我将一个已经不准确的浮点转换0.1为BigDecimal,并且BigDecimal只是无损地表示不准确.但我确保我使用的是字符串构造函数(如上面的代码片段所示),这应该可以避免这个问题.
编辑:
更多的调查表明,BigDecimal内部仍然干净利落.(很明显,因为否则这将是一个非常广泛使用的系统中的一个巨大的错误.)这是一个仍然显示错误的操作示例:
> puts "%.50f" % ("0.1".to_d * "10".to_d)
1.00000000000000000000000000000000000000000000000000
如果表示是有损的,那将显示与上面相同的误差,只是移动了一个数量级.这里发生了什么？
当我执行以下代码时,它有一个问题:
float number = 999999999;
printf("%lf", number);
结果是10000000000而不是999999999.
为什么不呢999999999？
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
int main() {
float x = 3.8, y = 5.2;
int a, b, c;
float d = x + y;
a = d;
b = (int)(x + y);
c = (int)(3.8 + 5.2);
printf("a=%d,b=%d,c=%d\n", a, b, c);
return 0;
}
结果是
Run Code Online (Sandbox Code Playgroud)9,8,9
我认为9,9,9是正确的输出,请告诉我,为什么.
我试图满足这个问题：编写一个函数 print_dig_float(float f) 来打印浮点数 f 的每个数字的值。例如，如果 f 是 2345.1234，则 print_dig_float(f) 将连续打印数字 2、3、4、5、1、2、3 和 4 的整数值。
我所做的是：给定一个带小数的数字，我尝试将数字向左移动（例如：3.45 -> 345），将其乘以 10。之后，我通过取余数将每个数字存储在一个数组中，然后把它放在一个元素中。然后，我将它们打印出来。
所以我的程序是这样的：
#include <stdio.h>
void print_dig_float(float f);
int main(int argc, char const *argv[]) {
print_dig_float(23432.214122);
return 0;
}
void print_dig_float(float f) {
printf("%f\n", f);
int i = 0, arr[50], conv;
//move digits to the left
do {
f = f * 10;
conv = f;
printf("%i\n", conv);
} while (conv % 10 != 0);
conv = f / 10;
//store digits in …我尝试了下面的代码，我为变量分配了一个浮点值，并将它与浮点值进行了比较，但它没有给出所需的输出。这里a==13.30是真的，我认为它会打印“a” 而不是它打印“ 5 ”
#include<iostream>
using namespace std;
int main()
{
float a=13.30;
if(a==13.30)
cout<<a;
else
cout<<"5";
}
输出是“ 5 ”而不是“a”
在Java中,如果你这样做0.2 + 0.01,你会得到0.21000000000000002
这是由于IEEE 754.
但是,在OCaml中,如果这样做0.2 +. 0.01,那么您将获得正确的结果0.21.
我认为OCaml也遵循IEEE 754 for floats,为什么OCaml可以提供正确的结果而Java不能？
在a与b如下所示是相同的量,但是在河两种不同的方式进行计算,他们大多是相同的,但有几个大的差异.我无法弄清楚为什么会这样.
theta0 <- c(-0.4, 10)
OS.mean <- function(shape, rank, n=100){
term1 <- factorial(n)/(factorial(rank-1)*factorial(n-rank))
term2 <- beta(n-rank+1, rank) - beta(n-rank+shape+1, rank)
term1*term2/shape
}
OS.mean.theta0.100 <- OS.mean(theta0[1], rank=seq(1, 100, by=1))
Bias.MOP <- function(shape, scale, alpha){
scale*shape*OS.mean.theta0.100[alpha*100]/(1-(1-alpha)^shape) - scale
}
a <- rep(0, 98)
for(i in 2:99){
a[i-1] <- Bias.MOP(theta0[1], theta0[2], i/100)
}
plot(a)
b <- Bias.MOP(theta0[1], theta0[2], seq(0.02, 0.99, by=0.01))
plot(b)
a-b
另一件奇怪的事情如下.
b[13] # -0.8185083
Bias.MOP(theta0[1], theta0[2], 0.14) # -0.03333929
他们应该是一样的.但他们显然不是.为什么？
我需要在 Go 中对 int64 的大值执行取幂和除法等操作，但我遇到了溢出问题。我尝试将它们转换为 float64，但后来遇到了其他问题。这是我尝试过的。
我有一个整数变量，我必须将其转换为 float64 才能使用方便的数学包 ( https://golang.org/pkg/math )。
但是，当整数变量太大时，它不会正确转换。我假设这是因为大小大于 float64。前任：
fmt.Printf("%f",float64(111111111111111110)) //Outputs 111111111111111104.000000
我正在尝试使用 math.Mod、math.Pow10 和 math.Log10。我如何才能执行以下逻辑，但上面显示的数字很大？
int(math.Mod(float64(123) / math.Pow10(1),10))) // Gets the second digit
我用c语言编写了一个程序来四舍五入浮点数，但程序的输出不遵循任何逻辑。代码是-->
#include<stdio.h>
int main(){
float a=2.435000;
float b=2.535000;
float c=2.635000;
float d=2.735000;
float e=2.835000;
//Rounding off the floating point numbers to 2 decimal places
printf("%f %.2f\n",a,a);
printf("%f %.2f\n",b,b);
printf("%f %.2f\n",c,c);
printf("%f %.2f\n",d,d);
printf("%f %.2f\n",e,e);
return 0;
}
输出：
2.435000 2.43
2.535000 2.54
2.635000 2.63
2.735000 2.73
2.835000 2.84
所有的浮点数都具有相同的数字模式，即它们是 2.x35000 的形式，其中 x 在不同的数字中是不同的。我不明白为什么他们在四舍五入时表现出不同的行为，他们应该给出 2.x3 或 2.x4，但对于不同的 x，它给出不同的值。
这背后的逻辑是什么？