blocks|key|1340027|text|另一种方式是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340028|>+length(z[z==TRUE])
[1]+498|code-block|syntax|javascript|1340029|虽然sum(z)短小精悍，但对我来说，length(z[z==TRUE])更多的是自我解释。不过，我认为像这样一个简单的任务并没有真正的不同……|offset|length|style|CODE|1340030|如果它是一个大的向量，你可能应该使用最快的解决方案，那就是sum(z)。length(z[z==TRUE])大约比sum(z)慢10倍，table(z)[TRUE]大约比sum(z)慢200倍。|1340031|总而言之，sum(z)是输入和执行速度最快的。|1340032|entityMap^0|0|0|2|6|J|I|0|T|6|10|I|1L|6|1W|E|2D|6|0|5|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$I|10|J|11|K|L]|$I|12|J|13|K|L]|$I|14|J|15|K|L]|$I|16|J|17|K|L]|$I|18|J|19|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$I|1B|J|1C|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|R|$]]

Another way is 

<pre><code>&gt; length(z[z==TRUE])
[1] 498
</code></pre>

While <code>sum(z)</code> is nice and short, for me <code>length(z[z==TRUE])</code> is more self explaining. Though, I think with a simple task like this it does not really make a difference...

If it is a large vector, you probably should go with the fastest solution, which is <code>sum(z)</code>. <code>length(z[z==TRUE])</code> is about 10x slower and <code>table(z)[TRUE]</code> is about 200x slower than <code>sum(z)</code>.

Summing up, <code>sum(z)</code> is the fastest to type and to execute.

blocks|key|1340100|text|最安全的方法是在na.rm+=+TRUE中使用sum|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1340101|sum(z,+na.rm+=+TRUE)+#+best+way+to+count+TRUE+values|code-block|syntax|javascript|1340102|结果是1。|1340103|当逻辑向量包含NA值时，其他解决方案存在一些问题。|1340104|例如，请参阅：|1340105|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)|1340106|此外，table解决方案效率较低(请查看table函数的代码)。|1340107|此外，您应该小心使用“表”解决方案，以防逻辑向量中没有真值。例如，请参阅：|1340108|z+<-+c(FALSE,+FALSE)
table(z)["TRUE"]+#+gives+you+`NA`|1340109|或|1340110|z+<-+c(NA,+FALSE)
table(z)["TRUE"]+#+gives+you+`NA`|1340111|entityMap^0|8|C|N|3|0|0|0|7|2|0|0|0|3|5|K|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1L|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1N|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|12|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|13|$]]

The safest way is to use <code>sum</code> with <code>na.rm = TRUE</code>:
<pre><code>sum(z, na.rm = TRUE) # best way to count TRUE values
</code></pre>
which gives 1.
There are some problems with other solutions when logical vector contains <code>NA</code> values.
See for example:
<pre><code>z &lt;- c(TRUE, FALSE, NA)

sum(z) # gives you NA
table(z)[&quot;TRUE&quot;] # gives you 1
length(z[z == TRUE]) # f3lix answer, gives you 2 (because NA indexing returns values)
</code></pre>
Additionally <code>table</code> solution is less efficient (look at the code of <code>table</code> function).
Also, you should be careful with the &quot;table&quot; solution, in case there are no TRUE values in the logical vector. See for example:
<pre><code>z &lt;- c(FALSE, FALSE)
table(z)[&quot;TRUE&quot;] # gives you `NA`
</code></pre>
or
<pre><code>z &lt;- c(NA, FALSE)
table(z)[&quot;TRUE&quot;] # gives you `NA`
</code></pre>

blocks|key|1340183|text|另一种没有提到的选择是使用which|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1340184|length(which(z))|code-block|syntax|javascript|1340185|只是提供一些关于“哪个是更快的问题”的上下文，测试自己总是最简单的。为了进行比较，我将向量做得更大：|1340186|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+|1340187|显然，在这种情况下，使用sum是最好的方法。您可能还希望按照马雷克的建议检查NA的值。|1340188|只需添加一条关于NA值和which函数的注释：|1340189|>+which(c(T,+F,+NA,+NULL,+T,+F))
[1]+1+4
>+which(!c(T,+F,+NA,+NULL,+T,+F))
[1]+2+5|1340190|请注意，它只检查逻辑TRUE，因此它基本上忽略了非逻辑值。|1340191|entityMap^0|D|5|0|0|0|0|C|3|12|2|0|C|5|0|0|A|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|X|$]]

Another option which hasn't been mentioned is to use <code>which</code>:

<pre><code>length(which(z))
</code></pre>

Just to actually provide some context on the "which is faster question", it's always easiest just to test yourself. I made the vector much larger for comparison:

<pre><code>z &lt;- 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 
</code></pre>

So clearly using <code>sum</code> is the best approach in this case. You may also want to check for <code>NA</code> values as Marek suggested.

Just to add a note regarding NA values and the <code>which</code> function:

<pre><code>&gt; which(c(T, F, NA, NULL, T, F))
[1] 1 4
&gt; which(!c(T, F, NA, NULL, T, F))
[1] 2 5
</code></pre>

Note that which only checks for logical <code>TRUE</code>, so it essentially ignores non-logical values.

blocks|key|1125178|text|which是一个很好的选择，特别是当您对矩阵进行操作时(查看?which并注意arr.ind参数)。但我建议您坚持使用sum，因为na.rm参数可以处理逻辑向量中的NA。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1125179|#+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|code-block|syntax|javascript|1125180|如果你输入sum(x)，你会得到NA，但是如果你在sum函数中传递na.rm+=+TRUE，你会得到你想要的结果。|1125181|>+sum(x)
[1]+NA
>+sum(x,+na.rm=TRUE)
[1]+43|1125182|你的问题是严格的理论问题，还是关于逻辑向量的实际问题？|1125183|entityMap^0|0|5|U|6|13|7|1N|3|1T|5|2A|2|0|0|5|6|G|2|P|3|X|C|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|R|$]]

<code>which</code> is good alternative, especially when you operate on matrices (check <code>?which</code> and notice the <code>arr.ind</code> argument). But I suggest that you stick with <code>sum</code>, because of <code>na.rm</code> argument that can handle <code>NA</code>'s in logical vector.
For instance:

<pre><code># create dummy variable
set.seed(100)
x &lt;- round(runif(100, 0, 1))
x &lt;- x == 1
# create NA's
x[seq(1, length(x), 7)] &lt;- NA
</code></pre>

If you type in <code>sum(x)</code> you'll get <code>NA</code> as a result, but if you pass <code>na.rm = TRUE</code> in <code>sum</code> function, you'll get the result that you want.

<pre><code>&gt; sum(x)
[1] NA
&gt; sum(x, na.rm=TRUE)
[1] 43
</code></pre>

Is your question strictly theoretical, or you have some practical problem concerning logical vectors?

blocks|key|1125233|text|几周前，我一直在做类似的事情。这是一个可能的解决方案，它是从头开始编写的，所以它是一种测试版或类似的东西。我将尝试通过从代码中删除循环来改进它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125234|其主要思想是编写一个接受2个(或3个)参数的函数。第一个是保存从调查问卷收集的数据的data.frame，第二个是具有正确答案的数字向量(这只适用于单选问卷)。或者，您可以添加第三个参数，该参数将返回具有最终分数的数值向量，或者返回具有嵌入分数的data.frame。|offset|length|style|CODE|1125235|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)
}|code-block|syntax|javascript|1125236|我将尝试用一些*ply函数以一种更优雅的方式来做这件事。请注意，我没有将na.rm参数...将会这样做|1125237|#+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))|1125238|现在应用一个函数：|1125239|>+fscore(d,+sol)
+[1]+6+4+2+4+4+3+3+6+2+6|1125240|如果传入data.frame参数，则返回修改后的data.frame。我会试着解决这个问题..。希望它能帮上忙！|1125241|entityMap^0|0|16|A|0|0|10|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

I've been doing something similar a few weeks ago. Here's a possible solution, it's written from scratch, so it's kind of beta-release or something like that. I'll try to improve it by removing loops from code...

The main idea is to write a function that will take 2 (or 3) arguments. First one is a <code>data.frame</code> which holds the data gathered from questionnaire, and the second one is a numeric vector with correct answers (this is only applicable for single choice questionnaire). Alternatively, you can add third argument that will return numeric vector with final score, or data.frame with embedded score.

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

I'll try to do this in a more elegant manner with some *ply function. Notice that I didn't put <code>na.rm</code> argument... Will do that

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

Now apply a function:

<pre><code>&gt; fscore(d, sol)
 [1] 6 4 2 4 4 3 3 6 2 6
</code></pre>

If you pass data.frame argument, it will return modified data.frame.
I'll try to fix this one... Hope it helps!

blocks|key|1125271|text|我刚刚遇到了一个特殊的问题，我必须计算逻辑向量中真语句的数量，这对我来说是最好的……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125272|length(grep(TRUE,+(gene.rep.matrix[i,1:6]+>+1)))+>+5|code-block|syntax|javascript|1125273|因此，这将获取gene.rep.matrix对象的子集，并应用逻辑测试，返回一个逻辑向量。该向量作为grep的参数，grep返回所有TRUE条目的位置。然后，Length计算grep找到的条目数，从而给出TRUE条目的数量。|1125274|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I've just had a particular problem where I had to count the number of true statements from a logical vector and this worked best for me...

<pre><code>length(grep(TRUE, (gene.rep.matrix[i,1:6] &gt; 1))) &gt; 5
</code></pre>

So This takes a subset of the gene.rep.matrix object, and applies a logical test, returning a logical vector. This vector is put as an argument to grep, which returns the locations of any TRUE entries. Length then calculates how many entries grep finds, thus giving the number of TRUE entries.

blocks|key|1125318|text|另一种选择是使用汇总函数。它给出了Ts、Fs和NAs的摘要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125319|>+summary(hival)
+++Mode+++FALSE++++TRUE++++NA's+
logical++++4367++++++53++++2076+
>+|code-block|syntax|javascript|1125320|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another option is to use summary function. It gives a summary of the Ts, Fs and NAs.

<pre><code>&gt; summary(hival)
 Mode FALSE TRUE NA's 
logical 4367 53 2076 
&gt; 
</code></pre>

blocks|key|1340472|text|还有一个名为bit的包，它是专门为快速布尔运算设计的。如果你有很大的向量或者需要做很多布尔运算，它特别有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1340473|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
})|code-block|syntax|javascript|1340474|entityMap^0|6|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

There's also a package called <code>bit</code> that is specifically designed for fast boolean operations. It's especially useful if you have large vectors or need to do many boolean operations.

<pre><code>z &lt;- 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
})
</code></pre>

In R, what is the most efficient/idiomatic way to count the number of <code>TRUE</code> values in a logical vector? I can think of two ways:

<pre><code>z &lt;- sample(c(TRUE, FALSE), 1000, rep = TRUE)
sum(z)
# [1] 498

table(z)["TRUE"]
# TRUE 
# 498 
</code></pre>

Which do you prefer? Is there anything even better?

How to count TRUE values in a logical vector

在R中，计算逻辑向量中TRUE值的数量的最有效/惯用的方法是什么？我可以想到两种方法：z <- sample(c(TRUE, FALSE), 1000, rep = TRUE)sum(z)# [1] 498table(z)["TRUE"]# TRUE # 498 你更喜欢哪一个？还有比这更好的吗？

问如何计算逻辑向量中的真值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算逻辑向量中的真值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算逻辑向量中的真值
EN