在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 math.Big库.在这个问题中,我使用了库,但不幸的是效果不大.
我正在尝试使用Binet公式来计算fib(100).我正在使用Go的Big.Float但没有成功.我精确到小数点后10位.请指教.
我试图避免循环/递归,因为我认为这些方法不能很好地扩展.因此,我试图利用比奈的公式
//当前输入增加时会产生不准确的结果.
package main
import (
"fmt"
"math/big"
"math"
"strconv"
)
func fib(n int) float64 {
var sroot5 = new(big.Float).SetPrec(200).SetFloat64(2.236067977499789696409173668731276235440618359611525724270897)
var phi = new(big.Float).SetPrec(200).SetFloat64(1.61803398874989484820458683436563811772030917980576286213544862)
var minusPhi = new(big.Float).SetPrec(200).SetFloat64(-0.61803398874989484820458683436563811772030917980576)
var fltP float64;
fltP, _ = phi.Float64()
var fltN float64;
fltN, _ = minusPhi.Float64()
var denom float64
denom, _ = sroot5.Float64()
// Magic fib formula (Binet) is:
// (Phi ^ n - (-phi ^ n)) / sqrt(5)
z := (math.Pow(fltP, float64(n)) - math.Pow(fltN, …我的BinvA矩阵的(1,1)条目得到一个非常奇怪的值我
只是试图反转B矩阵并做一个(B ^ -1)A乘法.
我明白,当我手工计算时,我的(1,1)应该是0,但我得到的是1.11022302e-16.我该如何解决？我知道浮点数不能完全准确地表示,但为什么这给我这样一个不准确的响应而不是四舍五入到有没有办法让它更精确？
她是我的代码:
import numpy as np
A = np.array([[2,2],[4,-1]],np.int)
A = A.transpose()
B = np.array([[1,3],[-1,-1]],np.int)
B = B.transpose()
Binv = np.linalg.inv(B) #calculate the inverse
BinvA = np.dot(Binv,A)
print(BinvA)
我的打印声明:
[[ 1.11022302e-16 -2.50000000e+00]
[ -2.00000000e+00 -6.50000000e+00]]
python floating-point numpy matrix-multiplication floating-point-precision
注意: 任何解决方案或解决此问题的方法都需要在MATLAB中进行,它是出现问题的代码.使fortran与MATLAB匹配是适得其反的,因为这两段代码都不会起作用......我理解差异是因为fortran编译器的方式和MATLAB所做的不同代替编译单个与双精度的解释漂浮,但我希望有人可以帮我提出解决方案来解决这个问题.
我正在调试一些我从Fortran转换成MATLAB的代码,并且遇到了令我难过的东西.在fortran和MATLAB中,我有以下几行
pcnt = 0.9999*(-0.5+z2)
哪里z2 = 0.51482129528868548.我遇到的问题是2.4594e-10在MATLAB中计算的pcnt和在fortran中计算的pcnt 有所不同.我已经确认z2完全相同(即z2_matlab-z2_fortran=0),所以我很难过.real*8在Fortran和MATLAB中,z2和pcnt都是双精度(对于fortran),所以就我而言,它们应该具有完全相同的精度(因为它在同一台机器上运行).
通常情况下我不会关心这个小的差异,但是z2最终会得到一个大数字,然后用于计算一个索引,稍后差异最后是数组索引后差为2,在算法的后期导致巨大的错误(对于最多只有1e7的数字,大约为1e6).
有谁知道为什么会出现这个问题以及某种方法来解决它？我正在MATLAB R2011a上执行这项工作,并使用gfortran编译器在64位MacBook pro上使用I5(我认为的第三代)处理器编译fortran.
如果有人有任何建议请告诉我,因为如果我找不到解决方案,那么过去两周我执行的大约5000行代码的翻译将毫无价值.
此外,任何解决方案都必须是MATLAB代码,因为Fortran代码是当前可用的代码.
提前致谢,
安德鲁
我对在各种类型之间在Swift中执行数字操作时返回的内容感到困惑.考虑以下:
var castedFoo = Float(7.0/5.0) // returns 1.39999997...
var specifiedTypeFoo:Float = 7/5.0 //returns 1.39999997...
var foo = (7/5.0) //returns 1.4
前两个与最后两个分开的是什么？它们都是返回的浮点数,那么为什么最后一个的值是四舍五入的呢？我知道第一个是铸造的,第二个明确指定为Float,但最后一个也返回Float值.那么是什么让这里与众不同？
以下是if和else的程序
#include<stdio.h>
#include<conio.h>
int main()
{
float a = 0.7; //a declared as float variable
if(a == 0.7) //why it takes only integral part of 0.7
{
printf("Hi");
}
else
{
printf("hello");
}
return 0;
}
这个程序不应该显示Hi而不是hello0.7等于0.7吗？
(我是C编程的新手)
我有一个函数做一些数学计算并返回一个double.由于std::exp实现方式不同,它在Windows和Android下会得到不同的结果(为什么我得到std :: exp的特定于平台的结果？).e-17舍入差异得到了传播,最终它不仅仅是我得到的舍入差异(结果最终可以改变2.36到2.47).当我将结果与某些预期值进行比较时,我希望此函数在所有平台上返回相同的结果.
所以我需要围绕我的结果.这样做的最简单的解决方案显然是(据我在网上找到)std::ceil(d*std::pow<double>(10,precision))/std::pow<double>(10,precision).但是,根据平台的不同,我觉得这仍然会得到不同的结果(此外,很难确定precision应该是什么).
我想知道是否硬编码最不重要的字节double可能是一个很好的舍入策略.
这个快速测试似乎表明"是":
#include <iostream>
#include <iomanip>
double roundByCast( double d )
{
double rounded = d;
unsigned char* temp = (unsigned char*) &rounded;
// changing least significant byte to be always the same
temp[0] = 128;
return rounded;
}
void showRoundInfo( double d, double rounded )
{
double diff = std::abs(d-rounded);
std::cout << "cast: " << d << " rounded to " << rounded …单精度浮点： 符号位：1 指数：8位 尾数：23位 双精度浮点： 符号位：1 指数：11位 尾数：52位
这个信息是什么意思？我不太了解英语术语。
#include <stdio.h>
void main() {
float num = 546.327;
printf("the number is %f\n",num);
enter code here
}
输出为546.327026.当我尝试不同的数字时,它总是在点后打印6个数字,而后3个是随机的.