Wie um zu überprüfen, ob jedes element in einem Vektor von integer-oder nicht R?

Sagen, ich habe einen Vektor y, und ich möchte, um zu überprüfen, ob jedes element in y ist integer oder nicht, und wenn nicht, beenden mit einer Fehlermeldung. Ich habe versucht ist.integer(y), aber es funktioniert nicht.

Es ist irgendwie eine schwere Frage, zu definieren, was genau eine "integer" ist oder nicht-Sie müssen klären, integer im Sinne von "ganze Zahl" vs integer-Datentyp. Sie befassen sich kaum mit dem Datentyp integer direkt in R (aber das ist, was ist.integer-tests für) -- werfen Sie einen Blick auf ist.die ganze ( ... ) zur Verfügung gestellt von Martin Maechler hier: stat.ethz.ch/pipermail/r-help/2003-April/032471.html
Wenn Sie aufhören möchten Sie wissen, wo Sie aufgehört haben... also das man nicht eine ganze Zahl zuerst? Ein Vektor enthält nur einen Datentyp. Man kann also nicht bedeuten, dass integer der Typ, der nur Ganzzahl als in eine ganze Zahl. Auch das ist ein bisschen problematisch, weil nicht alle ganze zahlen sind ganze zahlen genau. Sie müssen auch eine Toleranz von Abweichung von genau einer ganzen Zahl. Fügen Sie die Antworten auf jene Dinge zu Ihrer Frage.

InformationsquelleAutor zca0 | 2012-04-11

integer r vector

16

Die einfachste (und Schnellste!) was ist wohl dieses:
```
stopifnot( all(y == floor(y)) )
```
...Also probieren wir es aus:
```
y <- c(3,4,9)
stopifnot( all(y == floor(y)) ) # OK

y <- c(3,4.01,9)
stopifnot( all(y == floor(y)) ) # ERROR!
```
Wenn Sie wollen eine bessere Fehlermeldung:
```
y <- c(3, 9, NaN)
if (!isTRUE(all(y == floor(y)))) stop("'y' must only contain integer values")
```
- Aktualisiert benutzerdefinierte Fehlermeldung-version zu handhaben NA/NaN...
- Was der Fall ist, wo der Eingang, hier y ist c('A', 2, 3, 4)?
InformationsquelleAutor Tommy
9

könnten Sie tun:
```
   y <- c(3,3.1,1,2.3)
   (y - floor(y)) == 0
    [1]  TRUE FALSE  TRUE FALSE
```
oder
```
   (y - round(y)) == 0
```
und wenn Sie möchten, eine einzelne TRUE oder FALSE für die ganze Sache, legen Sie Sie in all(), z.B.:
```
   all((y - round(y)) == 0)
    [1] FALSE
```
- Gut, eine TRUE/FALSE-Wert für jedes element, denn R ist ein Vektorgrafik-Sprache.
InformationsquelleAutor tim riffe

Hier ist eine andere Weise (mit dem gleichen trick, wie Justin zu vergleichen jede Zahl an, die Zahl gezwungen, sich in die "integer" - Typ):

R> v1 = c(1,2,3)
R> v2 = c(1,2,3.5)
R> sapply(v1, function(i) i == as.integer(i))
[1] TRUE TRUE TRUE
R> sapply(v2, function(i) i == as.integer(i))
[1]  TRUE  TRUE FALSE

Machen Sie Ihren test:

R> all(sapply(v2, function(i) i == as.integer(i)))
[1] FALSE

InformationsquelleAutor Michael Dunn

4

Nicht wissen, welche schneller ist Tim ' s Weg oder so, aber:
```
> x <- 1:5
> y <- c(x, 2.0)
> z <- c(y, 4.5)
> all.equal(x, as.integer(x))
[1] TRUE
> all.equal(y, as.integer(y))
[1] TRUE
> all.equal(z, as.integer(z))
[1] "Mean relative difference: 0.1111111"
> 
```
oder:
```
all((z - as.integer(z))==0)
```
- Könnten Sie identical() statt all.equal(), da all.equal(3.00000001,3L) ist nicht wirklich TRUE.
- als.integer(y)) zurück FALSE für mich, aber ja, Sie sind richtig. Die Subtraktion-Technik ist wahrscheinlich ein wenig mehr narrensicher...
- Ich denke, @mweylandt und @John ' s Anmerkungen über die Mehrdeutigkeit der Frage sind die Rechte auf (und das ist, was ich versucht habe zu erhalten). is.integer(2.0) ist FALSE als R sieht es, aber für andere Absichten und Zwecke, es ist eine schöne ganze Zahl.
- Stimmt auch wieder, mehr detail von dem Fragesteller helfen würde, zu bestimmen, was der richtige Ansatz(es) ist/sind.
InformationsquelleAutor Justin
2

Ging ich in eine komplett andere Richtung, dann Tim (ich mag seine besser obwohl mein Ansatz funktioniert auf einer gemischten vector-das ist ein Charakter-Vektor mit ganzen zahlen etc.):
```
int.check <- function(vect) {
    vect <- as.character(vect)
    sapply(vect, function(x) all(unlist(strsplit(x, ""))%in% 0:9))
}

x <- c(2.0, 1111,"x", 2.4)
int.check(x)
```
BEARBEITEN: verändert die Funktion, wie es funktioniert nur auf character-Vektoren.

Dies funktioniert auf Vektoren der Klasse character als auch für den Fall, Sie haben einen Charakter-Vektor mit verschiedener Anzahl miteinander vermischt, sondern wurden dazu gezwungen Charakter.
- ...es ist allerdings sehr langsam. y<-1:1e5; system.time( int.check(y) ) dauert etwa 1,8 Sekunden. Meine version dauert 0,01 oder weniger 😉
- Oh ja, es ist definitiv nicht der Weg zu gehen, wenn Sie einen numerischen Vektor, einfach eine andere nehmen, Aber zu sehen, wie dein Ansatz funktioniert auf y<-c(1:1e5, "x") ; )
- PS ich bekomme 4.12 Sekunden nicht allzu schlimm.
- BTW, sollte nicht "1e6" werden als integer? int.check("1e6") gibt FALSE zurück.
- touche : ) Wenn int.check(1e6) funktioniert
InformationsquelleAutor Tyler Rinker
1

überprüfung der folgenden Punkte hilft mit einer knackigen, wenn die Bedingung, die wir verwenden können, die auf scripting.
```
sff <- 5

if(!(is.integer(sff) == is.character(sff))){ 
  sff
} else {
  "hello"
}
```
gibt
```
hello
```
sff <- 'a' gibt 'a' als das Ergebnis.
- Können Sie erklären, was die Bedingung ist zu tun? Ich kann nicht.
InformationsquelleAutor yogi
0

Wenn du floating-point-Darstellung-Fehler, versuchen Sie:
```
round( y, TOLERANCE.DIGITS ) %% 1 == 0
```
In meiner Anwendung, ich hatte ernsthaft brutalen floating-point-Darstellung-Fehler, so dass gilt:
```
> dictionary$beta[3]
[1] 89
> floor(dictionary$beta[3])
[1] 88
> as.integer( dictionary$beta )[3]
[1] 88
> dictionary$beta[3] %% 1
[1] 1
```
den Rest geteilt durch war man. Ich fand, dass musste ich Runde, bevor ich nahm die ganze Zahl ist. Ich denke alle dieser tests Versagen, in dem Fall, wo Sie wollte, die vor 89 zu zählen als eine ganze Zahl. Die "alle.gleich" - Funktion ist dazu gedacht, den besten Weg zur Verwaltung von floating-point-Darstellung-Fehler, aber:
```
all.equal( 88, 89 );
```
wie in meinem Fall, hätte (und hat) bei einer falsch-negativ-für einen integer-Wert überprüfen.

EDIT: benchmarking, fand ich, dass:
```
(x == as.integer(x)) 
```
war überall der besten Darsteller.
```
(x == floor(x))
((x - as.integer(x)) == 0)
```
in der Regel gut funktioniert, oft genauso schnell.
```
(x %% 1 <= tolerance)
```
funktioniert, aber nicht so schnell wie die anderen
```
!(is.character(all.equal(x, as.integer(x)))) 
```
wenn der Vektor nicht zahlen, hatte schrecklichen Leistung (Sicherheit, weil es geht um die Mühe, die Schätzung der Differenz).
```
identical(x, as.integer(x)) 
```
wenn der Vektor wurde alle integer-Werte zurückgegeben, die den falsche Ergebnis (vorausgesetzt, die Frage wurde gemeint, um zu überprüfen, für integer-Werte integer-Typen).

InformationsquelleAutor woodvi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.