相关疑难解决方法(0)

我有一个 20 位数字的 ID 变量。一旦我读取 R 中的数据，它就会更改为科学记数法，然后如果我将相同的 id 写入 csv 文件，ID 的值就会更改。

例如，运行下面的代码应该将 x 的值打印为“ 12345678912345678912 ”，但它打印“ 12345678912345679872 ”：

代码：

options(scipen=999)

x <- 12345678912345678912

打印（x）

输出：

[1] 12345678912345679872

我的问题是：

1）为什么会发生这种情况？

2）如何解决这个问题？

我知道这与 R 中数据类型的存储有关，但我仍然认为应该有某种方法来处理这个问题。我希望我对这个问题很清楚。

我不知道是否有人问过这个问题，所以请给我一个链接（如果它是重复的）。我将删除这篇文章

我已经经历过这个，所以我可以解决我的问题，但我无法解决它。

任何帮助将不胜感激。谢谢

我知道以前有人问过类似的问题，但是我找不到一种方法可以将因子转换为数字而不丢失任何小数。

这里有一个简单的例子：

我的向量是这样的：

january$pickup_latitude[1] = 40.751231

做完之后：

as.numeric(as.character(january$pickup_latitude))

结果是：

january$pickup_latitude[1] = 40.75123

即使每种情况都有不同的长度，有什么方法可以保留所有小数？

我创建了函数dyst和dystryb:

dyst<- function(t,x)
{
  f<-1
  return(f)
}
dystryb<- function(x)
{
  x<-sort(x)
  s<- numeric(101)
  u<-seq(0,1, by = 0.01)
  for (t in u)
  {
    s[t*100+1]<-dyst(t,x)
  }
  return(s)
}

调用函数后dystryb我得到了这个:

> x<-c(1,2,3,4,5,6,7)
> dystryb(x)
  [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 …

如果这是一个幼稚的问题，请原谅我，我的测试代码是这样的：

import torch
from torch.nn.modules.distance import PairwiseDistance

list_1 = [[1., 1.,],[1., 1.]]
list_2 = [[1., 1.,],[2., 1.]]

mtrxA=torch.tensor(list_1)
mtrxB=torch.tensor(list_2)

print "A-B distance     :",PairwiseDistance(2).forward(mtrxA, mtrxB)
print "A 'self' distance:",PairwiseDistance(2).forward(mtrxA, mtrxA)
print "B 'self' distance:",PairwiseDistance(2).forward(mtrxB, mtrxB)

结果：

A-B distance     : tensor([1.4142e-06, 1.0000e+00])
A 'self' distance: tensor([1.4142e-06, 1.4142e-06])
B 'self' distance: tensor([1.4142e-06, 1.4142e-06])

问题是：

1. pytorch 如何计算成对距离？是计算行向量距离吗？

2. 为什么“自我”距离不是 0？

更新

将 list_1 和 list_2 更改为以下内容后：

list_1 = [[1., 1.,1.,],[1., 1.,1.,]]
list_2 = [[1., 1.,1.,],[2., 1.,1.,]]

结果变成：

A-B distance     : tensor([1.7321e-06, 1.0000e+00])
A 'self' distance: …

所以我对 R 还很陌生，我正在阅读 R for Data Science(2e) 这本书。

我从书中复制了下面所示的代码，它返回了不同的输出。我不知道为什么

书上的代码

x <- c(1 / 49 * 49, sqrt(2) ^ 2)
x
#> [1] 1 2

print(x, digits = 16)
#> [1] 0.9999999999999999 2.0000000000000004

我的代码

print(sqrt(2)^2, digits = 16)
#[1] 2

#then tried saving it to an object, same output
sq_2 <- sqrt(2)^2
print(sq_2, digits = 16)
#[1] 2

我还尝试将其保存为向量（单个项目），相同的输出

注意：问题是与类似代码的近似值不同。

可能重复:
为什么这些数字不相等？

下面的表达式(评估为0.1)被认为大于0.1.

> round(1740/600,0) - 1740/600
[1] 0.1
> (round(1740/600,0) - 1740/600) <= 0.1
[1] FALSE //???!!???
> (round(1740/600,0) - 1740/600) <= 0.1000000000000000000000000000000000000001
[1] TRUE

认为问题可能是由于四舍五入,我尝试了同样的结果:

> 3 - 2.9
[1] 0.1
> (3 - 2.9) <=0.1
[1] FALSE

那么,给出了什么以及如何在不捏造截止值的情况下修复它？

我正在使用ggplot 2.1.0来绘制直方图,并且我对直方图箱有意想不到的行为.我在这里给出了一个左闭合箱的例子(即[0,0.1 [],其宽度为0.1).

mydf <- data.frame(myvar=c(-1,-0.5,-0.4,-0.1,-0.1,0.05,0.1,0.1,0.25,0.5,1))
myplot <- ggplot(mydf, aes(myvar)) + geom_histogram(aes(y=..count..),binwidth = 0.1, boundary=0.1,closed="left")
myplot
ggplot_build(myplot)$data[[1]]

在这个例子中,人们可能期望值-0.4在bin [-0.4,-0.3 [,但它在([神秘地)在bin [-0.5,-0.4 [.值-0.1的值相同,它落在[-0.2,-0.1 [而不是[-0.1,0 [...等].

这里有什么东西我不完全理解(特别是新的"中心"和"边界"参数)？或者是ggplot2在那里做奇怪的事情？

在此先感谢,最好的问候,Arnaud

PS:还问这里:https://github.com/hadley/ggplot2/issues/1651

核心R引擎有一个严重的缺陷,它表达了Modulus操作的输出:

ceiling((1.99 %% 1) * 100)

返回:99(正确)

ceiling((2.99 %% 1) * 100)

返回:100(不正确)

该行为将显示在任何整数值N + 2.99(例如3.99等)中.如果这与浮点表示相关联,则系统不会表达差异的完整细节.这尤其令人不安,因为:

两者(1.99 %% 1)并且(2.99 %% 1) 似乎返回0.99.

两者((1.99 %% 1) * 100)并且((2.99 %% 1) * 100) 似乎返回99.

但是,如果进行任何舍入或类似的数学运算,则2.99 的不可见残值会以意外的方式翻转.

虽然为我当前的应用程序解决这个问题是微不足道的:

floor((2.99 - floor(2.99)) * 100)

返回:99(正确)

sprintf("%.22f", floor((2.99 - floor(2.99)) * 100))

返回:99.0000000000000000000000(正确)

...我想知道有多少其他实例Modulus返回坏值而没有底层细节来显示浮点delta.有没有办法揭露模数似乎附加的基础残值？它是不可见的.

编辑:根据下面的andrew.punnett的慷慨示例,print(1.99, digits = 22)返回1.99(没有浮动扩展),而print(1.99 %% 1, digits = 22)返回0.98999999999999999.根据Aaron的敏锐眼光,这似乎与版本和/或系统有关.

谢谢!

下面是我的实验：

> xx = 293.62882204364098
> yy = 0.086783439604999998
> print(xx + yy, 20)
[1] 293.71560548324595175
> print(sum(c(xx,yy)), 20)
[1] 293.71560548324600859

对我来说很奇怪的是，sum()当+两者应用于相同的数字时，会给出不同的结果。

这个结果是预期的吗？

我怎样才能得到相同的结果？

哪一种最有效率？

我编写了以下代码来从向量中删除零。我使用erase(i)Rcpp 库中的函数。

#include <Rcpp.h>
using namespace Rcpp;
// [[Rcpp::export]]
NumericVector erase_zero(NumericVector x) {
  for (int i = 0; i < x.size(); i++) {
    if (x[i] == 0) {
      x.erase(i);
    }
  }
  return x;
}

一切都很好，现在问题是函数的输出，即

> erase_zero(c(0,1,2,3,0))
[1] 1 2 3
> erase_zero(c(0,0,1,2,3,0,0))
[1] 0 1 2 3 0
> erase_zero(c(0,0,0,1,2,3,0,0,0))
[1] 0 1 2 3 0
> erase_zero(c(0,0,0,0,1,2,3,0,0,0,0))
[1] 0 0 1 2 3 0 0

我不知道为什么会发生这种情况。

阅读下面的所有答案后，我只是尝试了速度测试

> microbenchmark(erase_zero(s), erase_zero1(s), erase_zero_sugar(s))
Unit: microseconds
                expr    min      lq …