Comparisons and Logic

🔍 NumPy Comparisons and Searching: The Detective’s Toolkit

Imagine you’re a detective with a magical magnifying glass. This glass can look at millions of clues at once and instantly tell you which ones match what you’re looking for. That’s exactly what NumPy’s comparison tools do with numbers!

🎯 The Big Picture

When you have thousands (or millions!) of numbers, how do you find the ones you need? NumPy gives you super-fast detective tools that can:

• Compare numbers instantly
• Combine clues with logic
• Check if ALL or ANY numbers pass a test
• Find the biggest and smallest values

Let’s become NumPy detectives! 🕵️

1️⃣ Comparison Ufuncs: Your Magnifying Glass

What is it? Special functions that compare numbers and return True or False.

Think of it like this: You have a box of candies with different weights. You want to find all candies heavier than 10 grams.

import numpy as np

candies = np.array([5, 12, 8, 15, 3])

# Which candies are heavier than 10?
heavy_candies = candies > 10
print(heavy_candies)
# [False  True False  True False]

🔧 All Comparison Tools

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])

# Using both ways - they're the same!
print(a > b)           # [False False False  True  True]
print(np.greater(a, b)) # [False False False  True  True]

# Finding equals
print(a == b)          # [False False  True False False]
print(np.equal(a, b))   # [False False  True False False]

🌟 Key Insight: The result is always an array of True/False values, same shape as your input!

2️⃣ Logical Operations: Combining Clues

What is it? Ways to combine multiple True/False answers together.

Imagine you’re looking for candies that are:

• Heavy AND round
• Or maybe: Heavy OR chocolate-flavored

weights = np.array([5, 12, 8, 15, 3])
is_round = np.array([True, False, True, True, False])

is_heavy = weights > 10

🔗 The Logic Tools

graph LR
    A["np.logical_and"] --> B["Both must be True<br/>🍬 Heavy AND Round"]
    C["np.logical_or"] --> D["At least one True<br/>🍬 Heavy OR Round"]
    E["np.logical_not"] --> F["Flip the answer<br/>🍬 NOT Heavy"]
    G["np.logical_xor"] --> H["Exactly one True<br/>🍬 One but not both"]

# AND - both conditions must be true
heavy_and_round = np.logical_and(is_heavy, is_round)
print(heavy_and_round)  # [False False False  True False]
# Only candy at index 3 is both heavy AND round!

# OR - at least one condition true
heavy_or_round = np.logical_or(is_heavy, is_round)
print(heavy_or_round)   # [ True  True  True  True False]

# NOT - flip all the answers
not_heavy = np.logical_not(is_heavy)
print(not_heavy)        # [ True False  True False  True]

# XOR - exactly one is true, not both
xor_result = np.logical_xor(is_heavy, is_round)
print(xor_result)       # [ True  True  True False False]

💡 Shortcut Operators

# You can also use & | ~ instead!
result = (weights > 10) & (is_round)  # Same as logical_and
result = (weights > 10) | (is_round)  # Same as logical_or
result = ~(weights > 10)              # Same as logical_not

# ⚠️ Important: Use parentheses!

3️⃣ np.all and np.any: The Quick Questions

What are they? Fast ways to ask “Did ALL pass?” or “Did ANY pass?”

Think of a classroom:

• np.all: Did ALL students pass the test?
• np.any: Did ANY student pass the test?

test_scores = np.array([85, 92, 78, 95, 88])
passing = 70

# Did everyone pass?
all_passed = np.all(test_scores >= passing)
print(all_passed)  # True - everyone scored 70+!

# Did anyone get 100?
any_perfect = np.any(test_scores == 100)
print(any_perfect)  # False - no one got 100

📊 Working with 2D Arrays

grades = np.array([
    [85, 90, 88],  # Student 1
    [75, 60, 82],  # Student 2
    [92, 95, 98]   # Student 3
])

# Did each student pass all subjects? (check rows)
np.all(grades >= 70, axis=1)  # [ True False  True]
# Student 2 failed one subject!

# Did anyone fail in each subject? (check columns)
np.any(grades < 70, axis=0)   # [False  True False]
# Someone failed subject 2!

graph LR
    A["np.all#40;arr#41;"] --> B["Returns ONE True/False<br/>All elements checked"]
    A --> C["axis=0: Check each column"]
    A --> D["axis=1: Check each row"]

    E["np.any#40;arr#41;"] --> F["Returns ONE True/False<br/>All elements checked"]
    E --> G["axis=0: Check each column"]
    E --> H["axis=1: Check each row"]

4️⃣ Array Comparison Utilities: Advanced Detective Work

What are they? Specialized tools for comparing entire arrays.

🔍 np.array_equal - Exact Match Check

a = np.array([1, 2, 3])
b = np.array([1, 2, 3])
c = np.array([1, 2, 4])

np.array_equal(a, b)  # True - perfect match!
np.array_equal(a, c)  # False - one differs

🔍 np.allclose - “Close Enough” Check

Perfect for decimal numbers that might be slightly different:

a = np.array([1.0, 2.0, 3.0])
b = np.array([1.00001, 2.00001, 3.00001])

a == b  # [False False False] - strict check fails!
np.allclose(a, b)  # True - close enough!

# Control how "close" is close enough
np.allclose(a, b, rtol=1e-5)  # relative tolerance
np.allclose(a, b, atol=1e-8)  # absolute tolerance

🔍 np.isclose - Element-by-Element Close Check

a = np.array([1.0, 2.0, 1000.0])
b = np.array([1.001, 2.0, 1000.1])

np.isclose(a, b, rtol=0.001)
# [ True  True  True] - all within 0.1%

🔍 np.where - Find the Locations

scores = np.array([45, 88, 92, 65, 78])

# WHERE are the passing scores?
passing_indices = np.where(scores >= 70)
print(passing_indices)  # (array([1, 2, 4]),)
# Positions 1, 2, and 4 have passing scores!

# Replace values conditionally
result = np.where(scores >= 70, 'Pass', 'Fail')
print(result)  # ['Fail' 'Pass' 'Pass' 'Fail' 'Pass']

5️⃣ Element-wise Min/Max Functions: Finding Champions

What are they? Tools to find the biggest or smallest at each position.

Imagine two friends comparing test scores subject by subject:

alice_scores = np.array([85, 92, 78])
bob_scores = np.array([90, 88, 82])

# Who scored higher in each subject?
best_per_subject = np.maximum(alice_scores, bob_scores)
print(best_per_subject)  # [90 92 82]
# Takes Alice's 92, Bob's 90 and 82

# Who scored lower in each subject?
lowest_per_subject = np.minimum(alice_scores, bob_scores)
print(lowest_per_subject)  # [85 88 78]

📊 The Min/Max Family

# Handling missing data (NaN)
a = np.array([1, np.nan, 3])
b = np.array([2, 5, 1])

np.maximum(a, b)  # [ 2. nan  3.] - NaN "poisons" result
np.fmax(a, b)     # [2. 5. 3.] - ignores NaN, uses 5

🎯 Clamping Values with Clip

temperatures = np.array([-5, 15, 30, 45, 100])

# Keep temperatures between 0 and 40
safe_temps = np.clip(temperatures, 0, 40)
print(safe_temps)  # [ 0 15 30 40 40]
# -5 became 0, 45 and 100 became 40

🧠 Quick Mental Model

graph LR
    A["🔍 NumPy Comparisons"] --> B["Compare Values"]
    A --> C["Combine Logic"]
    A --> D["Quick Questions"]
    A --> E["Array Utilities"]
    A --> F["Find Min/Max"]

    B --> B1[">, <, ==, !=, >=, <="]
    C --> C1["and, or, not, xor"]
    D --> D1["all#40;#41; - everyone?<br/>any#40;#41; - anyone?"]
    E --> E1["array_equal, allclose<br/>isclose, where"]
    F --> F1["maximum, minimum<br/>fmax, fmin, clip"]

🎉 You’re Now a NumPy Detective!

Remember:

1. Comparisons give you True/False arrays
2. Logic lets you combine conditions
3. all/any answer quick yes/no questions
4. Utilities help with tricky comparisons
5. Min/Max find champions at each position

These tools work on MILLIONS of numbers in milliseconds. That’s the power of NumPy! 🚀

Next time you need to find needles in a haystack of numbers, you know exactly which detective tools to grab!