Parallel Prime Number Calculation

Multiprocessing allows Python programs to leverage multiple CPU cores, significantly speeding up computationally intensive tasks. This challenge asks you to implement a function that calculates the sum of prime numbers within a given range using Python's multiprocessing module. This is a classic example demonstrating the benefits of parallel processing.

Problem Description

You are tasked with creating a function parallel_prime_sum(start, end, num_processes) that calculates the sum of all prime numbers between start and end (inclusive) using a specified number of processes. The function should divide the range into chunks and assign each chunk to a separate process for prime number calculation. The results from each process should then be aggregated to produce the final sum.

What needs to be achieved:

• Divide the range [start, end] into num_processes chunks.
• Create and start num_processes processes, each responsible for calculating the sum of primes within its assigned chunk.
• Collect the results from each process.
• Return the total sum of all prime numbers within the original range.

Key Requirements:

• Utilize the multiprocessing module for process creation and management.
• Implement a helper function is_prime(n) to determine if a number is prime.
• Handle potential errors gracefully (e.g., invalid input).
• Ensure the code is well-structured and readable.

Expected Behavior:

The function should return an integer representing the sum of all prime numbers within the specified range. The order of prime numbers in the sum doesn't matter, only the final total.

Edge Cases to Consider:

• start and end are equal.
• start is greater than end.
• num_processes is greater than the number of available CPU cores (the code should still function correctly, though performance might not be optimal).
• start or end are negative. Treat negative numbers as if they were 0 (i.e., don't include them in the prime sum).
• The range contains no prime numbers.

Examples

Example 1:

Input: start = 2, end = 10, num_processes = 2
Output: 17
Explanation: Prime numbers between 2 and 10 are 2, 3, 5, and 7. Their sum is 2 + 3 + 5 + 7 = 17. The range is split into two chunks, each processed by a separate process.

Example 2:

Input: start = 1, end = 20, num_processes = 4
Output: 77
Explanation: Prime numbers between 1 and 20 are 2, 3, 5, 7, 11, 13, 17, and 19. Their sum is 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 = 77.

Example 3:

Input: start = 10, end = 10, num_processes = 1
Output: 0
Explanation: There are no prime numbers between 10 and 10.

Constraints

• 0 <= start <= end <= 10000
• 1 <= num_processes <= 8 (Assume a maximum of 8 cores for simplicity)
• The function should return the correct sum within a reasonable time (e.g., less than 1 second for the given constraints).
• Input values will always be integers.

Notes

• Consider using a Queue to collect results from the processes.
• The is_prime function can be implemented using a simple trial division algorithm.
• Think about how to handle the case where num_processes is greater than the number of available cores. Python's multiprocessing module will handle this gracefully, but be aware of it.
• Focus on correctness and clarity first, then optimize for performance if time allows. The primary goal is to demonstrate understanding of multiprocessing concepts.