# 6.3. Logical Indexing¶

## 6.3.1. Introduction to Logical indexing¶

As an alternative to indexing an array by x[idx] where idx is an array of integers, logical indexing allows for the syntax x[choose] where choose is an array of booleans. The size of choose must be the length of the array (or more generally, the dimension it indexes into). Note that the result is identical to x[findall(choose)], but shorter to write and likely more efficient.

x = -11:11
y = sin.(x)
x = x[y .> 0]          # Only keep values of x where y=sin x is positive

11-element Vector{Int64}:
-11
-10
-6
-5
-4
1
2
3
7
8
9

# Example: Consider the matrix
A = rand(-10:10, 3, 10)

3×10 Matrix{Int64}:
8  0   9  -3  4   4   4   3  -2  -2
-4  0  -5  10  9  -4  -3  -2   4  -8
-8  6   2   7  5   1  10   8  -9   4

# Compute a boolean array with true if the column sums are >=0
pick = sum(A, dims=1) .≥ 0

1×10 BitMatrix:
0  1  1  1  1  1  1  1  0  0

# Create a new vector with only the columns of A given by the pick variable
# Note that since pick is a 2D vector (row vector), we use [:] before indexing
B = A[:, pick[:]]

3×7 Matrix{Int64}:
0   9  -3  4   4   4   3
0  -5  10  9  -4  -3  -2
6   2   7  5   1  10   8


## 6.3.2. Examples: Simplifying the Sieve of Eratosthenes function¶

In our previous implementation, we used the code below to collect all the prime numbers:

    ...
# Return an array with all prime numbers
primes = Int64[]
for i = 2:n
if prime[i]
push!(primes, i)
end
end
primes
...


Using array comprehensions, we can replace this entire part of the code by a single line:

    primes = [ i for i = 2:n if prime[i] ]


or even simpler, since the list of primes is simply the indices of the true values in the array prime, we can use the findall function. However in our original implementation, prime was set to true (since it was not used) so we have to first make sure the number 1 is not considered a prime. Then the code can be written as:

    prime = false
primes = findall(prime)


## 6.3.3. Example: Simplifying the dart-throwing function¶

We previously used the following code to count the number of “hits”, that is, how many points in the vectors x,y are inside the unit circle:

# Determine if points are inside the circle (a "hit")
hits = 0
for i = 1:n
if x[i]^2 + y[i]^2 ≤ 1
hits += 1
end
end


Using the count function, this can be written as a single line of code:

hits = count(@. x^2 + y^2 ≤ 1)


## 6.3.4. Example: Simplifying the poker hand flush code¶

When simulating the poker hands, we used the following code to determine if all cards were of the same suit:

    same_suit = true
for i = 2:5
if suits[i] ≠ suits
same_suit = false
break
end
end


Using the all function, this can be simplified to a single line of code:

    same_suit = all(suits[2:5] .== suits)