Wie man WAHRE Werte in einem logischen Vektor zählt

Was ist in R die effizienteste / idiomatischste Methode, um die Anzahl der TRUEWerte in einem logischen Vektor zu zählen? Ich kann mir zwei Möglichkeiten vorstellen:

z <- sample(c(TRUE, FALSE), 1000, rep = TRUE)
sum(z)
# [1] 498

table(z)["TRUE"]
# TRUE 
#  498 

Was bevorzugen Sie? Gibt es noch etwas besseres?

Es gibt einige Probleme, wenn der logische Vektor NAWerte enthält .
Siehe zum Beispiel:

z <- c(TRUE, FALSE, NA)
sum(z) # gives you NA
table(z)["TRUE"] # gives you 1
length(z[z == TRUE]) # f3lix answer, gives you 2 (because NA indexing returns values)

Daher denke ich, dass es am sichersten ist, Folgendes zu verwenden na.rm = TRUE:

sum(z, na.rm = TRUE) # best way to count TRUE values

(was 1 ergibt). Ich denke, dass die tableLösung weniger effizient ist (siehe tableFunktionscode).

Sie sollten auch mit der "Tabellen" -Lösung vorsichtig sein, falls der logische Vektor keine TRUE-Werte enthält. Angenommen z <- c(NA, FALSE, NA)oder einfach z <- c(FALSE, FALSE), dann table(z)["TRUE"]gibt es Sie NAfür beide Fälle.

Eine andere Option, die nicht erwähnt wurde, ist die Verwendung von which:

length(which(z))

Nur um tatsächlich einen Kontext für die "was schneller ist" -Frage bereitzustellen, ist es immer am einfachsten, sich selbst zu testen. Ich habe den Vektor zum Vergleich viel größer gemacht:

z <- sample(c(TRUE,FALSE),1000000,rep=TRUE)
system.time(sum(z))
   user  system elapsed 
   0.03    0.00    0.03
system.time(length(z[z==TRUE]))
   user  system elapsed 
   0.75    0.07    0.83 
system.time(length(which(z)))
   user  system elapsed 
   1.34    0.28    1.64 
system.time(table(z)["TRUE"])
   user  system elapsed 
  10.62    0.52   11.19 

sumIn diesem Fall ist die Verwendung eindeutig der beste Ansatz. Möglicherweise möchten Sie auch nach NAWerten suchen, wie von Marek vorgeschlagen.

Nur um einen Hinweis zu den NA-Werten und der whichFunktion hinzuzufügen :

> which(c(T, F, NA, NULL, T, F))
[1] 1 4
> which(!c(T, F, NA, NULL, T, F))
[1] 2 5

Beachten Sie, dass nur TRUElogische Werte überprüft werden , sodass nicht logische Werte im Wesentlichen ignoriert werden.

Ein anderer Weg ist

> length(z[z==TRUE])
[1] 498

Während sum(z) es nett und kurz ist, ist es für mich length(z[z==TRUE])selbsterklärender. Ich denke jedoch, dass es bei einer einfachen Aufgabe wie dieser keinen wirklichen Unterschied macht ...

Wenn es sich um einen großen Vektor handelt, sollten Sie sich wahrscheinlich für die schnellste Lösung entscheiden sum(z). length(z[z==TRUE])ist ungefähr 10x langsamer und table(z)[TRUE]ist ungefähr 200x langsamer als sum(z).

Zusammenfassend sum(z)ist es am schnellsten zu tippen und auszuführen.

whichist eine gute Alternative, insbesondere wenn Sie mit Matrizen arbeiten (überprüfen ?whichund beachten Sie das arr.indArgument). Aber ich schlage vor, dass Sie bei bleiben sum, wegen na.rmArgumenten, die NAin logischen Vektoren behandeln können. Zum Beispiel:

# create dummy variable
set.seed(100)
x <- round(runif(100, 0, 1))
x <- x == 1
# create NA's
x[seq(1, length(x), 7)] <- NA

Wenn Sie in geben sum(x)Sie erhalten NAals Ergebnis, aber wenn Sie passieren na.rm = TRUEin sumFunktion, werden Sie das Ergebnis erhalten , die Sie wollen.

> sum(x)
[1] NA
> sum(x, na.rm=TRUE)
[1] 43

Ist Ihre Frage streng theoretisch oder haben Sie ein praktisches Problem mit logischen Vektoren?

Eine weitere Option ist die Verwendung der Zusammenfassungsfunktion. Es gibt eine Zusammenfassung der Ts, Fs und NAs.

> summary(hival)
   Mode   FALSE    TRUE    NA's 
logical    4367      53    2076 
> 

Ich habe vor ein paar Wochen etwas Ähnliches gemacht. Hier ist eine mögliche Lösung, die von Grund auf neu geschrieben wurde. Es handelt sich also um eine Art Beta-Version oder ähnliches. Ich werde versuchen, es zu verbessern, indem ich Schleifen aus dem Code entferne ...

Die Hauptidee besteht darin, eine Funktion zu schreiben, die 2 (oder 3) Argumente akzeptiert. Die erste ist eine data.frame, die die aus dem Fragebogen gesammelten Daten enthält, und die zweite ist ein numerischer Vektor mit korrekten Antworten (dies gilt nur für Single-Choice-Fragebogen). Alternativ können Sie ein drittes Argument hinzufügen, das einen numerischen Vektor mit der endgültigen Bewertung oder data.frame mit der eingebetteten Bewertung zurückgibt.

fscore <- function(x, sol, output = 'numeric') {
    if (ncol(x) != length(sol)) {
        stop('Number of items differs from length of correct answers!')
    } else {
        inc <- matrix(ncol=ncol(x), nrow=nrow(x))
        for (i in 1:ncol(x)) {
            inc[,i] <- x[,i] == sol[i]
        }
        if (output == 'numeric') {
            res <- rowSums(inc)
        } else if (output == 'data.frame') {
            res <- data.frame(x, result = rowSums(inc))
        } else {
            stop('Type not supported!')
        }
    }
    return(res)
}

Ich werde versuchen, dies auf elegantere Weise mit einer * Ply-Funktion zu tun. Beachten Sie, dass ich kein na.rmArgument vorgebracht habe ... Ich werde das tun

# create dummy data frame - values from 1 to 5
set.seed(100)
d <- as.data.frame(matrix(round(runif(200,1,5)), 10))
# create solution vector
sol <- round(runif(20, 1, 5))

Wenden Sie nun eine Funktion an:

> fscore(d, sol)
 [1] 6 4 2 4 4 3 3 6 2 6

Wenn Sie das Argument data.frame übergeben, wird das geänderte data.frame zurückgegeben. Ich werde versuchen, dieses Problem zu beheben ... Hoffe, es hilft!

Ich hatte gerade ein bestimmtes Problem, bei dem ich die Anzahl der wahren Aussagen aus einem logischen Vektor zählen musste, und das funktionierte am besten für mich ...

length(grep(TRUE, (gene.rep.matrix[i,1:6] > 1))) > 5

Dies nimmt also eine Teilmenge des Objekts gene.rep.matrix und wendet einen logischen Test an, der einen logischen Vektor zurückgibt. Dieser Vektor wird als Argument für grep verwendet, das die Positionen aller TRUE-Einträge zurückgibt. Die Länge berechnet dann, wie viele Einträge grep findet, und gibt so die Anzahl der WAHREN Einträge an.

Es gibt auch ein Paket namens bit, das speziell für schnelle boolesche Operationen entwickelt wurde. Dies ist besonders nützlich, wenn Sie große Vektoren haben oder viele boolesche Operationen ausführen müssen.

z <- sample(c(TRUE, FALSE), 1e8, rep = TRUE)

system.time({
  sum(z) # 0.170s
})

system.time({
  bit::sum.bit(z) # 0.021s, ~10x improvement in speed
})