File size: 3,912 Bytes
99a41ea |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
import math
import random
from typing import List, Tuple
def calculate_factorial(n: int) -> int:
"""Calculate factorial of a number recursively."""
if n <= 1:
return 1
return n * calculate_factorial(n - 1)
def fibonacci_sequence(n: int) -> List[int]:
"""Generate fibonacci sequence up to n terms."""
if n <= 0:
return []
elif n == 1:
return [0]
elif n == 2:
return [0, 1]
sequence = [0, 1]
for i in range(2, n):
sequence.append(sequence[i-1] + sequence[i-2])
return sequence
def is_prime(num: int) -> bool:
"""Check if a number is prime."""
if num < 2:
return False
if num == 2:
return True
if num % 2 == 0:
return False
for i in range(3, int(math.sqrt(num)) + 1, 2):
if num % i == 0:
return False
return True
def find_primes_in_range(start: int, end: int) -> List[int]:
"""Find all prime numbers in a given range."""
primes = []
for num in range(start, end + 1):
if is_prime(num):
primes.append(num)
return primes
def calculate_statistics(numbers: List[float]) -> dict:
"""Calculate basic statistics for a list of numbers."""
if not numbers:
return {"error": "Empty list provided"}
n = len(numbers)
mean = sum(numbers) / n
sorted_nums = sorted(numbers)
# Calculate median
if n % 2 == 0:
median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
else:
median = sorted_nums[n//2]
# Calculate variance and standard deviation
variance = sum((x - mean) ** 2 for x in numbers) / n
std_dev = math.sqrt(variance)
return {
"count": n,
"mean": mean,
"median": median,
"min": min(numbers),
"max": max(numbers),
"variance": variance,
"std_deviation": std_dev
}
def monte_carlo_pi(iterations: int) -> float:
"""Estimate Pi using Monte Carlo method."""
inside_circle = 0
for _ in range(iterations):
x, y = random.random(), random.random()
if x*x + y*y <= 1:
inside_circle += 1
return 4 * inside_circle / iterations
def process_data_pipeline(data: List[int]) -> dict:
"""Complex data processing pipeline demonstrating function calls."""
# Step 1: Filter for positive numbers
positive_data = []
for x in data:
if x > 0:
positive_data.append(x)
# Step 2: Find primes in the data
primes_in_data = []
for x in positive_data:
if is_prime(x):
primes_in_data.append(x)
# Step 3: Calculate statistics
positive_data_floats = []
for x in positive_data:
positive_data_floats.append(float(x))
stats = calculate_statistics(positive_data_floats)
# Step 4: Generate fibonacci sequence up to max value
max_val = max(positive_data) if positive_data else 0
fib_count = min(max_val, 20) # Limit to reasonable size
fib_sequence = fibonacci_sequence(fib_count)
# Step 5: Calculate factorials for small numbers
small_numbers = []
for x in positive_data:
if x <= 10:
small_numbers.append(x)
factorials = {}
for x in small_numbers:
factorials[x] = calculate_factorial(x)
return {
"original_count": len(data),
"positive_count": len(positive_data),
"primes_found": primes_in_data,
"statistics": stats,
"fibonacci_sequence": fib_sequence,
"factorials": factorials,
"pi_estimate": monte_carlo_pi(1000)
}
def main():
"""Main function demonstrating the pipeline."""
sample_data = [1, 2, 3, 5, 8, 13, 21, -1, 0, 17, 19, 23]
result = process_data_pipeline(sample_data)
print(f"Processing complete: {len(result)} metrics calculated")
return result
if __name__ == "__main__":
main() |