From 24d221ac8d6b86927941a48561f2d73d59492863 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 18:03:06 +0000 Subject: [PATCH 01/13] Start draft PR From 93222c5a1ac5465e0b010bdb5de7d34452eb4ec0 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 18:03:23 +0000 Subject: [PATCH 02/13] Add prime number checker function with input validation --- src/prime_checker.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 src/prime_checker.py diff --git a/src/prime_checker.py b/src/prime_checker.py new file mode 100644 index 0000000..df51b17 --- /dev/null +++ b/src/prime_checker.py @@ -0,0 +1,28 @@ +def is_prime(number: int) -> bool: + """ + Check if a given number is prime. + + Args: + number (int): The number to check for primality. + + Returns: + bool: True if the number is prime, False otherwise. + + Raises: + TypeError: If the input is not an integer. + ValueError: If the input is less than 2. + """ + # Validate input type + if not isinstance(number, int): + raise TypeError("Input must be an integer") + + # Handle special cases + if number < 2: + return False + + # Optimization: check divisibility up to square root of the number + for i in range(2, int(number**0.5) + 1): + if number % i == 0: + return False + + return True \ No newline at end of file From 795be8d8c6f1fb869d732df0147aed4b45604a9c Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 18:03:36 +0000 Subject: [PATCH 03/13] Add comprehensive tests for prime number checker --- tests/test_prime_checker.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 tests/test_prime_checker.py diff --git a/tests/test_prime_checker.py b/tests/test_prime_checker.py new file mode 100644 index 0000000..a7a6d89 --- /dev/null +++ b/tests/test_prime_checker.py @@ -0,0 +1,37 @@ +import pytest +from src.prime_checker import is_prime + +def test_prime_numbers(): + """Test known prime numbers""" + prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47] + for prime in prime_numbers: + assert is_prime(prime) == True, f"{prime} should be prime" + +def test_non_prime_numbers(): + """Test known non-prime numbers""" + non_prime_numbers = [0, 1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22] + for non_prime in non_prime_numbers: + assert is_prime(non_prime) == False, f"{non_prime} should not be prime" + +def test_large_prime(): + """Test a large prime number""" + assert is_prime(104729) == True, "Large prime number not recognized" + +def test_large_non_prime(): + """Test a large non-prime number""" + assert is_prime(100000) == False, "Large non-prime number not detected" + +def test_negative_numbers(): + """Test negative numbers""" + assert is_prime(-7) == False, "Negative numbers should not be prime" + +def test_invalid_input_type(): + """Test invalid input types""" + with pytest.raises(TypeError): + is_prime("not a number") + + with pytest.raises(TypeError): + is_prime(3.14) + + with pytest.raises(TypeError): + is_prime(None) \ No newline at end of file From 28e579d12904cb0cfc74408526950e52281f2605 Mon Sep 17 00:00:00 2001 From: laura-ct Date: Tue, 20 May 2025 18:36:47 +0000 Subject: [PATCH 04/13] Start draft PR From 2831253d6873e4869f4fc7e1fe231abcba8ca914 Mon Sep 17 00:00:00 2001 From: laura-ct Date: Tue, 20 May 2025 18:37:08 +0000 Subject: [PATCH 05/13] Implement prime factorization function with comprehensive error handling --- src/prime_factorization.py | 47 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 src/prime_factorization.py diff --git a/src/prime_factorization.py b/src/prime_factorization.py new file mode 100644 index 0000000..4e9f19c --- /dev/null +++ b/src/prime_factorization.py @@ -0,0 +1,47 @@ +from typing import List + +def prime_factorization(n: int) -> List[int]: + """ + Compute the prime factorization of a given positive integer. + + Args: + n (int): The positive integer to factorize. + + Returns: + List[int]: A list of prime factors in ascending order. + + Raises: + ValueError: If the input is less than 1. + """ + # Validate input + if not isinstance(n, int): + raise TypeError("Input must be an integer") + + if n < 1: + raise ValueError("Input must be a positive integer") + + # Handle special cases + if n == 1: + return [] + + # Prime factorization algorithm + factors = [] + + # First, handle 2 as a special case to optimize odd number checking + while n % 2 == 0: + factors.append(2) + n //= 2 + + # Check for odd prime factors + factor = 3 + while factor * factor <= n: + while n % factor == 0: + factors.append(factor) + n //= factor + factor += 2 + + # If n is a prime number greater than 2 + if n > 2: + factors.append(n) + + return factors \ No newline at end of file From 6a2cdbcd1bb746c94d35341cafc77852f56d304d Mon Sep 17 00:00:00 2001 From: laura-ct Date: Tue, 20 May 2025 18:37:18 +0000 Subject: [PATCH 06/13] Add comprehensive tests for prime factorization function --- tests/test_prime_factorization.py | 40 +++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 tests/test_prime_factorization.py diff --git a/tests/test_prime_factorization.py b/tests/test_prime_factorization.py new file mode 100644 index 0000000..bf1a397 --- /dev/null +++ b/tests/test_prime_factorization.py @@ -0,0 +1,40 @@ +import pytest +from src.prime_factorization import prime_factorization + +def test_prime_factorization_basic(): + assert prime_factorization(12) == [2, 2, 3] + assert prime_factorization(15) == [3, 5] + assert prime_factorization(100) == [2, 2, 5, 5] + +def test_prime_factorization_prime_numbers(): + assert prime_factorization(7) == [7] + assert prime_factorization(11) == [11] + assert prime_factorization(17) == [17] + +def test_prime_factorization_edge_cases(): + assert prime_factorization(1) == [] + assert prime_factorization(2) == [2] + +def test_prime_factorization_large_number(): + result = prime_factorization(84) + assert result == [2, 2, 3, 7] + assert all(is_prime(factor) for factor in result) + +def test_prime_factorization_invalid_inputs(): + with pytest.raises(ValueError): + prime_factorization(0) + with pytest.raises(ValueError): + prime_factorization(-5) + with pytest.raises(TypeError): + prime_factorization(3.14) + with pytest.raises(TypeError): + prime_factorization("not a number") + +def is_prime(n: int) -> bool: + """Helper function to check if a number is prime.""" + if n < 2: + return False + for i in range(2, int(n**0.5) + 1): + if n % i == 0: + return False + return True \ No newline at end of file From 74f85e61719746411ce03e743c4bfe6788f2ac3b Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 19:11:01 +0000 Subject: [PATCH 07/13] Start draft PR From 408ce019d68bbdbb4004db3ea43a4bc828fe98b7 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 19:11:27 +0000 Subject: [PATCH 08/13] Implement GCD calculator using prime factorization method --- src/gcd_calculator.py | 91 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 src/gcd_calculator.py diff --git a/src/gcd_calculator.py b/src/gcd_calculator.py new file mode 100644 index 0000000..06037f8 --- /dev/null +++ b/src/gcd_calculator.py @@ -0,0 +1,91 @@ +from typing import List, Union +from math import sqrt + +def get_prime_factors(n: int) -> List[int]: + """ + Decompose a number into its prime factors. + + Args: + n (int): The number to factorize (must be a positive integer) + + Returns: + List[int]: A list of prime factors + + Raises: + ValueError: If input is less than 1 + """ + if n < 1: + raise ValueError("Input must be a positive integer") + + # Handle special cases + if n == 1: + return [1] + + factors = [] + + # Check for 2 as a factor + while n % 2 == 0: + factors.append(2) + n //= 2 + + # Check for odd prime factors + for i in range(3, int(sqrt(n)) + 1, 2): + while n % i == 0: + factors.append(i) + n //= i + + # If n is a prime greater than 2 + if n > 2: + factors.append(n) + + return factors + +def gcd_prime_factors(a: int, b: int) -> int: + """ + Calculate the Greatest Common Divisor (GCD) using prime factorization. + + Args: + a (int): First number + b (int): Second number + + Returns: + int: The Greatest Common Divisor + + Raises: + ValueError: If either input is less than 1 + """ + # Handle zero cases + if a == 0 and b == 0: + return 0 + + # Take absolute values to handle negative inputs + a, b = abs(a), abs(b) + + # If either number is 0, return the other number + if a == 0: + return b + if b == 0: + return a + + # Get prime factors for both numbers + a_factors = get_prime_factors(a) + b_factors = get_prime_factors(b) + + # Calculate GCD by multiplying common prime factors + gcd = 1 + a_factor_counts = {} + b_factor_counts = {} + + # Count occurrences of factors + for factor in a_factors: + a_factor_counts[factor] = a_factor_counts.get(factor, 0) + 1 + for factor in b_factors: + b_factor_counts[factor] = b_factor_counts.get(factor, 0) + 1 + + # Find common factors with minimum count + for factor, count in a_factor_counts.items(): + if factor in b_factor_counts: + common_count = min(count, b_factor_counts[factor]) + gcd *= factor ** common_count + + return gcd \ No newline at end of file From 4db13e5a38efbf732eb80f82498b71a81f64edc7 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 19:11:40 +0000 Subject: [PATCH 09/13] Add comprehensive tests for GCD calculator --- tests/test_gcd_calculator.py | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 tests/test_gcd_calculator.py diff --git a/tests/test_gcd_calculator.py b/tests/test_gcd_calculator.py new file mode 100644 index 0000000..f00cfb1 --- /dev/null +++ b/tests/test_gcd_calculator.py @@ -0,0 +1,36 @@ +import pytest +from src.gcd_calculator import gcd_prime_factors, get_prime_factors + +def test_get_prime_factors(): + # Test basic prime factorization + assert get_prime_factors(12) == [2, 2, 3] + assert get_prime_factors(15) == [3, 5] + assert get_prime_factors(7) == [7] + assert get_prime_factors(1) == [1] + +def test_prime_factors_edge_cases(): + # Test edge cases + with pytest.raises(ValueError): + get_prime_factors(0) + with pytest.raises(ValueError): + get_prime_factors(-5) + +def test_gcd_prime_factors(): + # Test various GCD scenarios + assert gcd_prime_factors(48, 18) == 6 + assert gcd_prime_factors(54, 24) == 6 + assert gcd_prime_factors(17, 23) == 1 # Coprime numbers + assert gcd_prime_factors(0, 5) == 5 + assert gcd_prime_factors(5, 0) == 5 + assert gcd_prime_factors(0, 0) == 0 + +def test_gcd_with_negative_numbers(): + # Test GCD with negative numbers + assert gcd_prime_factors(-48, 18) == 6 + assert gcd_prime_factors(48, -18) == 6 + assert gcd_prime_factors(-48, -18) == 6 + +def test_gcd_large_numbers(): + # Test large numbers + assert gcd_prime_factors(1234567, 7654321) == 1 # Coprime large numbers + assert gcd_prime_factors(1000000, 10000) == 10000 \ No newline at end of file From 9ac64098d3c5f3e028d8e9fa76b5db84fc37cca1 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 19:44:43 +0000 Subject: [PATCH 10/13] Start draft PR From 698459b40c110e691dbc4e20f36c43a4379db1e4 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Tue, 20 May 2025 19:45:43 +0000 Subject: [PATCH 11/13] Start draft PR From 28426f7718b4fd7a16955a6a74aaa77987007319 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Thu, 22 May 2025 17:25:32 +0000 Subject: [PATCH 12/13] Start draft PR From 69089ad160643092fd57c091666e10503d61b4f2 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Thu, 22 May 2025 17:25:49 +0000 Subject: [PATCH 13/13] Implement prime number checker function --- src/prime_checker.py | 31 ++++++++++++++++++++++--------- 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/src/prime_checker.py b/src/prime_checker.py index df51b17..877c630 100644 --- a/src/prime_checker.py +++ b/src/prime_checker.py @@ -1,28 +1,41 @@ -def is_prime(number: int) -> bool: +import math + +def is_prime(n): """ Check if a given number is prime. Args: - number (int): The number to check for primality. + n (int): The number to check for primality. Returns: bool: True if the number is prime, False otherwise. Raises: TypeError: If the input is not an integer. - ValueError: If the input is less than 2. """ - # Validate input type - if not isinstance(number, int): + # Check for valid input type + if not isinstance(n, int): raise TypeError("Input must be an integer") # Handle special cases - if number < 2: + if n <= 1: return False - # Optimization: check divisibility up to square root of the number - for i in range(2, int(number**0.5) + 1): - if number % i == 0: + # Optimization for 2 and 3 + if n <= 3: + return n > 1 + + # Even numbers greater than 2 are not prime + if n % 2 == 0: + return False + + # Check up to the square root of n + sqrt_n = int(math.sqrt(n)) + 1 + + # Check for divisibility by odd numbers + for divisor in range(3, sqrt_n, 2): + if n % divisor == 0: return False + # If no divisors are found, the number is prime return True \ No newline at end of file