Boolean masking

Author: pubudu

content/0.Numpy_for_bioinformatics.md

@@ -1,4 +1,4 @@
-# Numpy for Bioinformatics
+# Lesson plan: Numpy for Bioinformatics
 
 ## Overall objectives
 

content/3.Indexing_and_Slicing.md

@@ -339,6 +339,7 @@ gene_expr = np.array([
 ```
 
 **Tasks:**
+
 1. Find all expression values greater than 30
 2. Identify which genes have at least one expression value greater than 30
 3. Create a boolean mask showing positions where expression is between 15 and 25

content/4.Advance_indexing_filtering.md

@@ -62,12 +62,13 @@ print("Boolean mask (data > 3):", mask)
 selected_data = data[mask]
 print("Selected elements:", selected_data)
 # This produces: [4, 5]
+
+## Elegant approach -  mask array has the exact same shape as data array
+## Each position containing information about whether that element meets our criteria
 ```
 
 :::
 
-Notice how elegant this approach is: the mask array has the exact same shape as our data array, with each position containing information about whether that element meets our criteria.
-
 ## Combining Multiple Conditions
 
 We can combine multiple conditions using logical operators:
@@ -222,3 +223,126 @@ For large datasets, these techniques are drastically faster than traditional ite
 * `np.isin()` lets us filter based on membership in a set of values
 
 :::
+
+## Exercises: NumPy Boolean Masking and Advanced Filtering
+
+:::{exercise}
+
+**Exercise 1 - Basic Boolean Masking:**
+
+Create a NumPy array of 20 random integers between 0 and 100. Then:
+
+* Create a boolean mask to identify all numbers divisible by 7
+* Use the mask to extract these numbers
+* Count how many numbers are divisible by 7
+
+:::
+
+:::{solution}
+
+```python
+import numpy as np
+
+# Create an array of 20 random integers between 0 and 100
+np.random.seed(42)  # for reproducibility
+numbers = np.random.randint(0, 101, 20)
+print("Original array:", numbers)
+
+# Create a boolean mask for numbers divisible by 7
+mask = numbers % 7 == 0
+print("Boolean mask:", mask)
+
+# Extract numbers divisible by 7
+divisible_by_7 = numbers[mask]
+print("Numbers divisible by 7:", divisible_by_7)
+
+# Count how many numbers are divisible by 7
+count = np.sum(mask)  # True values are treated as 1, False as 0
+print(f"Count of numbers divisible by 7: {count}")
+```
+
+:::
+
+:::{exercise}
+
+**Exercise 2 - Combined Conditions:**
+
+Generate a NumPy array of 30 random integers between -50 and 50. Then:
+
+Create a mask to find all numbers that are both positive and even
+Create another mask to find all numbers that are either negative or divisible by 5
+Apply both masks to the array and display the results
+
+:::
+
+:::{solution}
+
+:::
+
+:::{exercise}
+**Exercise 3 - np.where() for Conditional Assignment:**
+
+Create a 4x4 matrix of random integers between 1 and 20. Then:
+
+* Use np.where() to replace all odd numbers with -1 while keeping even numbers unchanged
+* Use np.where() again to create a new matrix where:
+  * Numbers less than 10 remain the same
+  * Numbers between 10 and 15 are replaced with 100
+  * Numbers greater than 15 are replaced with 200
+:::
+
+:::{solution}
+
+```python
+# Create a 4x4 matrix of random integers between 1 and 20
+np.random.seed(42)
+matrix = np.random.randint(1, 21, (4, 4))
+print("Original matrix:")
+print(matrix)
+
+# Replace odd numbers with -1, keep even numbers
+odd_replaced = np.where(matrix % 2 == 0, matrix, -1)
+print("\nMatrix with odd numbers replaced by -1:")
+print(odd_replaced)
+
+# Replace based on value ranges
+transformed = np.where(matrix < 10, matrix, 
+                       np.where((matrix >= 10) & (matrix <= 15), 100, 200))
+print("\nMatrix with conditional replacements:")
+print(transformed)
+
+```
+
+:::
+
+:::{exercise}
+**Exercise 4 - DNA Sequence Analysis:**
+
+You are given a DNA sequence as a NumPy array of characters (A, T, G, C).
+
+* Create a random DNA sequence of length 50 using `np.random.choice(['A', 'T', 'G', 'C'], 50)`
+* Use boolean masking to Count the number of each nucleotide (A, T, G, C)
+
+:::
+
+:::{solution}
+
+```python
+import numpy as np
+
+# Create a random DNA sequence
+np.random.seed(42)  # for reproducibility
+dna_sequence = np.random.choice(['A', 'T', 'G', 'C'], 50)
+print("DNA sequence:", ''.join(dna_sequence))
+
+# Count the number of each nucleotide
+a_count = np.sum(dna_sequence == 'A')
+t_count = np.sum(dna_sequence == 'T')
+g_count = np.sum(dna_sequence == 'G')
+c_count = np.sum(dna_sequence == 'C')
+
+print(f"A: {a_count}, T: {t_count}, G: {g_count}, C: {c_count}")
+
+```
+
+:::