From c4cee11fb6ba67a34eb524a5dfd5e15aecd6c39e Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:07:29 -0300 Subject: [PATCH 01/17] Implement prime number checker function --- src/prime_checker.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 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 00000000..d4067bef --- /dev/null +++ b/src/prime_checker.py @@ -0,0 +1,30 @@ +def is_prime(number): + """ + Check if a given number is prime. + + A prime number is a natural number greater than 1 that is only divisible by 1 and itself. + + Args: + number (int): The number to check for primality. + + Returns: + bool: True if the number is prime, False otherwise. + + Raises: + ValueError: If the input is not a positive integer. + """ + # Check for invalid input + if not isinstance(number, int): + raise ValueError("Input must be an integer") + + # Numbers less than 2 are not prime + if number < 2: + return False + + # Check for divisibility up to the square root of the number + # This is an optimization to reduce the number of iterations + 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 fae79d4b883052d6c1b5850031e0a6dba2a48b76 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:07:36 -0300 Subject: [PATCH 02/17] Add comprehensive tests for prime number checker --- tests/test_prime_checker.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 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 00000000..b44c3bce --- /dev/null +++ b/tests/test_prime_checker.py @@ -0,0 +1,35 @@ +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] + for num in prime_numbers: + assert is_prime(num) is True, f"{num} 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] + for num in non_prime_numbers: + assert is_prime(num) is False, f"{num} should not be prime" + +def test_large_prime(): + """Test a larger prime number.""" + assert is_prime(97) is True + assert is_prime(541) is True + +def test_large_non_prime(): + """Test a larger non-prime number.""" + assert is_prime(100) is False + assert is_prime(999) is False + +def test_invalid_input(): + """Test error handling for invalid inputs.""" + with pytest.raises(ValueError): + is_prime(3.14) + + with pytest.raises(ValueError): + is_prime("not a number") + + with pytest.raises(ValueError): + is_prime(None) \ No newline at end of file From 61790b2043107ef3411ca50231b83622a00cc516 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:07:42 -0300 Subject: [PATCH 03/17] Add pytest to requirements --- requirements.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..55b033e9 --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +pytest \ No newline at end of file From db76459f9a79e535f7689c0289df7bb28c357f98 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:09:07 -0300 Subject: [PATCH 04/17] Add prime factorization implementation --- src/prime_factorization.py | 45 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 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 00000000..e1a64651 --- /dev/null +++ b/src/prime_factorization.py @@ -0,0 +1,45 @@ +def prime_factorization(n): + """ + Compute the prime factorization of a given positive integer. + + Args: + n (int): A positive integer to factorize. + + Returns: + list: A list of prime factors in ascending order. + + Raises: + ValueError: If the input is not a positive integer. + """ + # Validate input + if not isinstance(n, int): + raise ValueError("Input must be an integer") + + if n <= 0: + raise ValueError("Input must be a positive integer") + + # Special case for 1 + if n == 1: + return [] + + # List to store prime factors + factors = [] + + # Check for 2 as a factor first + while n % 2 == 0: + factors.append(2) + n = n // 2 + + # Check for odd factors starting from 3 + factor = 3 + while factor * factor <= n: + while n % factor == 0: + factors.append(factor) + n = 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 4b704770123f214bc097535293c7fe2b3198c2b7 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:09:15 -0300 Subject: [PATCH 05/17] Add tests for prime factorization function --- tests/test_prime_factorization.py | 45 +++++++++++++++++++++++++++++++ 1 file changed, 45 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 00000000..a4764e58 --- /dev/null +++ b/tests/test_prime_factorization.py @@ -0,0 +1,45 @@ +import pytest +from src.prime_factorization import prime_factorization + +def test_prime_factorization_basic(): + """Test basic prime factorization scenarios.""" + 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(): + """Test prime numbers factorization.""" + assert prime_factorization(7) == [7] + assert prime_factorization(11) == [11] + assert prime_factorization(17) == [17] + +def test_prime_factorization_edge_cases(): + """Test edge cases.""" + assert prime_factorization(1) == [] + assert prime_factorization(2) == [2] + +def test_prime_factorization_large_number(): + """Test a larger number with multiple prime factors.""" + 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(): + """Test invalid input handling.""" + with pytest.raises(ValueError, match="Input must be an integer"): + prime_factorization("12") + + with pytest.raises(ValueError, match="Input must be a positive integer"): + prime_factorization(0) + + with pytest.raises(ValueError, match="Input must be a positive integer"): + prime_factorization(-5) + +def is_prime(n): + """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 09064fadfa7663ff9dc2b5064d5fb181ef5e3a89 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:10:50 -0300 Subject: [PATCH 06/17] Implement GCD calculator using prime factorization method --- src/gcd_calculator.py | 53 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 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 00000000..2763d95f --- /dev/null +++ b/src/gcd_calculator.py @@ -0,0 +1,53 @@ +from src.prime_factorization import prime_factorization + +def gcd_using_prime_factors(a, b): + """ + Calculate the Greatest Common Divisor (GCD) using prime factorization method. + + This function computes the GCD by finding the common prime factors + between two numbers and multiplying them. + + Args: + a (int): First positive integer. + b (int): Second positive integer. + + Returns: + int: The Greatest Common Divisor of a and b. + + Raises: + ValueError: If either input is not a positive integer. + """ + # Validate inputs + if not (isinstance(a, int) and isinstance(b, int)): + raise ValueError("Inputs must be integers") + + if a <= 0 or b <= 0: + raise ValueError("Inputs must be positive integers") + + # Special case: if either number is 0, return the other number + if a == 0: + return b + if b == 0: + return a + + # Get prime factors of both numbers + a_factors = prime_factorization(a) + b_factors = prime_factorization(b) + + # Find common prime factors + gcd = 1 + + # Use two pointers to track factors of a and b + i, j = 0, 0 + while i < len(a_factors) and j < len(b_factors): + if a_factors[i] == b_factors[j]: + # Common prime factor found + gcd *= a_factors[i] + i += 1 + j += 1 + elif a_factors[i] < b_factors[j]: + i += 1 + else: + j += 1 + + return gcd \ No newline at end of file From fc6e2c8877b18fa9dd972d4660d596eeaa29225e Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:10:59 -0300 Subject: [PATCH 07/17] Add comprehensive tests for GCD calculator --- tests/test_gcd_calculator.py | 37 ++++++++++++++++++++++++++++++++++++ 1 file changed, 37 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 00000000..7d8ff5a9 --- /dev/null +++ b/tests/test_gcd_calculator.py @@ -0,0 +1,37 @@ +import pytest +from src.gcd_calculator import gcd_using_prime_factors + +def test_gcd_basic_cases(): + """Test basic GCD calculations.""" + assert gcd_using_prime_factors(48, 18) == 6 + assert gcd_using_prime_factors(54, 24) == 6 + assert gcd_using_prime_factors(17, 23) == 1 + assert gcd_using_prime_factors(100, 75) == 25 + +def test_gcd_zero_cases(): + """Test GCD calculations involving zero.""" + assert gcd_using_prime_factors(0, 5) == 5 + assert gcd_using_prime_factors(7, 0) == 7 + assert gcd_using_prime_factors(0, 0) == 0 + +def test_gcd_same_number(): + """Test GCD of a number with itself.""" + assert gcd_using_prime_factors(7, 7) == 7 + assert gcd_using_prime_factors(100, 100) == 100 + +def test_gcd_error_handling(): + """Test error handling for invalid inputs.""" + with pytest.raises(ValueError, match="Inputs must be integers"): + gcd_using_prime_factors("10", 5) + + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(-5, 10) + + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(0, -5) + +def test_gcd_large_numbers(): + """Test GCD calculations with larger numbers.""" + assert gcd_using_prime_factors(1024, 512) == 512 + assert gcd_using_prime_factors(2**10, 2**15) == 2**10 + assert gcd_using_prime_factors(15487469, 32451899) == 1 # Both prime \ No newline at end of file From ec6e9a5daeb0d001df45976c3a0b7b6259f0e3f6 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:11:10 -0300 Subject: [PATCH 08/17] Update GCD calculator to handle zero cases correctly --- src/gcd_calculator.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/gcd_calculator.py b/src/gcd_calculator.py index 2763d95f..eece6455 100644 --- a/src/gcd_calculator.py +++ b/src/gcd_calculator.py @@ -8,21 +8,21 @@ def gcd_using_prime_factors(a, b): between two numbers and multiplying them. Args: - a (int): First positive integer. - b (int): Second positive integer. + a (int): First non-negative integer. + b (int): Second non-negative integer. Returns: int: The Greatest Common Divisor of a and b. Raises: - ValueError: If either input is not a positive integer. + ValueError: If either input is not an integer. """ # Validate inputs if not (isinstance(a, int) and isinstance(b, int)): raise ValueError("Inputs must be integers") - if a <= 0 or b <= 0: - raise ValueError("Inputs must be positive integers") + if a < 0 or b < 0: + raise ValueError("Inputs must be non-negative integers") # Special case: if either number is 0, return the other number if a == 0: From 0e18ff3fc14c2656db480410ab1150166fd6a923 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:11:22 -0300 Subject: [PATCH 09/17] Update tests to match new error handling --- tests/test_gcd_calculator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_gcd_calculator.py b/tests/test_gcd_calculator.py index 7d8ff5a9..10c9a296 100644 --- a/tests/test_gcd_calculator.py +++ b/tests/test_gcd_calculator.py @@ -24,10 +24,10 @@ def test_gcd_error_handling(): with pytest.raises(ValueError, match="Inputs must be integers"): gcd_using_prime_factors("10", 5) - with pytest.raises(ValueError, match="Inputs must be positive integers"): + with pytest.raises(ValueError, match="Inputs must be non-negative integers"): gcd_using_prime_factors(-5, 10) - with pytest.raises(ValueError, match="Inputs must be positive integers"): + with pytest.raises(ValueError, match="Inputs must be non-negative integers"): gcd_using_prime_factors(0, -5) def test_gcd_large_numbers(): From 0e8b1e6505ed8257a9cc5e649da8505fea576e44 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:12:53 -0300 Subject: [PATCH 10/17] Implement LCM calculator using GCD method --- src/lcm_calculator.py | 52 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 src/lcm_calculator.py diff --git a/src/lcm_calculator.py b/src/lcm_calculator.py new file mode 100644 index 00000000..e3879526 --- /dev/null +++ b/src/lcm_calculator.py @@ -0,0 +1,52 @@ +from src.gcd_calculator import gcd + +def lcm(a: int, b: int) -> int: + """ + Calculate the Least Common Multiple (LCM) of two integers using the GCD method. + + The LCM is calculated using the formula: LCM(a,b) = |a * b| / GCD(a,b) + + Args: + a (int): First integer + b (int): Second integer + + Returns: + int: The least common multiple of a and b + + Raises: + ValueError: If either input is not a positive integer + """ + # Validate inputs are positive integers + if not (isinstance(a, int) and isinstance(b, int)): + raise ValueError("Both inputs must be integers") + + if a <= 0 or b <= 0: + raise ValueError("Both inputs must be positive integers") + + # Calculate LCM using the GCD method + return abs(a * b) // gcd(a, b) + +def lcm_multiple(*numbers: int) -> int: + """ + Calculate the LCM of multiple integers. + + Args: + *numbers (int): Variable number of positive integers + + Returns: + int: The least common multiple of all input numbers + + Raises: + ValueError: If no numbers are provided or if any input is invalid + """ + if not numbers: + raise ValueError("At least one number must be provided") + + # Start with the first number + result = numbers[0] + + # Iteratively calculate LCM for all numbers + for num in numbers[1:]: + result = lcm(result, num) + + return result \ No newline at end of file From 09660b5b8aaa0c87e4bedde6d32eb955e453cf8e Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:13:02 -0300 Subject: [PATCH 11/17] Add tests for LCM calculator --- tests/test_lcm_calculator.py | 51 ++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 tests/test_lcm_calculator.py diff --git a/tests/test_lcm_calculator.py b/tests/test_lcm_calculator.py new file mode 100644 index 00000000..03c017d4 --- /dev/null +++ b/tests/test_lcm_calculator.py @@ -0,0 +1,51 @@ +import pytest +from src.lcm_calculator import lcm, lcm_multiple + +def test_lcm_basic(): + """Test basic LCM calculations""" + assert lcm(4, 6) == 12 + assert lcm(21, 6) == 42 + assert lcm(17, 5) == 85 + +def test_lcm_with_one(): + """Test LCM when one number is 1""" + assert lcm(1, 5) == 5 + assert lcm(5, 1) == 5 + +def test_lcm_same_number(): + """Test LCM when both numbers are the same""" + assert lcm(7, 7) == 7 + assert lcm(13, 13) == 13 + +def test_lcm_coprime(): + """Test LCM of coprime numbers""" + assert lcm(17, 23) == 391 + assert lcm(11, 13) == 143 + +def test_lcm_multiple_numbers(): + """Test LCM of multiple numbers""" + assert lcm_multiple(2, 3, 4) == 12 + assert lcm_multiple(3, 4, 6) == 12 + assert lcm_multiple(2, 3, 5, 7) == 210 + +def test_lcm_invalid_inputs(): + """Test error handling for invalid inputs""" + with pytest.raises(ValueError, match="Both inputs must be integers"): + lcm(3.5, 4) + + with pytest.raises(ValueError, match="Both inputs must be positive integers"): + lcm(-4, 6) + + with pytest.raises(ValueError, match="Both inputs must be positive integers"): + lcm(4, 0) + +def test_lcm_multiple_invalid_inputs(): + """Test error handling for lcm_multiple""" + with pytest.raises(ValueError, match="At least one number must be provided"): + lcm_multiple() + + with pytest.raises(ValueError): + lcm_multiple(2, 3, 0) + + with pytest.raises(ValueError): + lcm_multiple(2, -3, 4) \ No newline at end of file From 7e019f34c0e2fe946b2c97edd9561c4cf5c9dd37 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:13:16 -0300 Subject: [PATCH 12/17] Update LCM calculator to use correct GCD function name --- src/lcm_calculator.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/lcm_calculator.py b/src/lcm_calculator.py index e3879526..72831d5c 100644 --- a/src/lcm_calculator.py +++ b/src/lcm_calculator.py @@ -1,4 +1,4 @@ -from src.gcd_calculator import gcd +from src.gcd_calculator import gcd_using_prime_factors as gcd def lcm(a: int, b: int) -> int: """ @@ -20,8 +20,12 @@ def lcm(a: int, b: int) -> int: if not (isinstance(a, int) and isinstance(b, int)): raise ValueError("Both inputs must be integers") - if a <= 0 or b <= 0: - raise ValueError("Both inputs must be positive integers") + if a < 0 or b < 0: + raise ValueError("Both inputs must be non-negative integers") + + # Special case: if either number is 0, return 0 + if a == 0 or b == 0: + return 0 # Calculate LCM using the GCD method return abs(a * b) // gcd(a, b) @@ -31,7 +35,7 @@ def lcm_multiple(*numbers: int) -> int: Calculate the LCM of multiple integers. Args: - *numbers (int): Variable number of positive integers + *numbers (int): Variable number of non-negative integers Returns: int: The least common multiple of all input numbers From d5545308bb72fde8a471ead11aabdf4df7e6da29 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:13:29 -0300 Subject: [PATCH 13/17] Update LCM calculator to handle input validation and error messages --- src/lcm_calculator.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/lcm_calculator.py b/src/lcm_calculator.py index 72831d5c..bad91107 100644 --- a/src/lcm_calculator.py +++ b/src/lcm_calculator.py @@ -20,12 +20,8 @@ def lcm(a: int, b: int) -> int: if not (isinstance(a, int) and isinstance(b, int)): raise ValueError("Both inputs must be integers") - if a < 0 or b < 0: - raise ValueError("Both inputs must be non-negative integers") - - # Special case: if either number is 0, return 0 - if a == 0 or b == 0: - return 0 + if a <= 0 or b <= 0: + raise ValueError("Both inputs must be positive integers") # Calculate LCM using the GCD method return abs(a * b) // gcd(a, b) @@ -35,7 +31,7 @@ def lcm_multiple(*numbers: int) -> int: Calculate the LCM of multiple integers. Args: - *numbers (int): Variable number of non-negative integers + *numbers (int): Variable number of positive integers Returns: int: The least common multiple of all input numbers @@ -46,6 +42,13 @@ def lcm_multiple(*numbers: int) -> int: if not numbers: raise ValueError("At least one number must be provided") + # Validate all inputs + for num in numbers: + if not isinstance(num, int): + raise ValueError("All inputs must be integers") + if num <= 0: + raise ValueError("All inputs must be positive integers") + # Start with the first number result = numbers[0] From 7c4ae41066b98c5537ff8b4b0a226e20319088e6 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Tue, 8 Apr 2025 20:13:40 -0300 Subject: [PATCH 14/17] Update test cases for LCM calculator --- tests/test_lcm_calculator.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tests/test_lcm_calculator.py b/tests/test_lcm_calculator.py index 03c017d4..764dec11 100644 --- a/tests/test_lcm_calculator.py +++ b/tests/test_lcm_calculator.py @@ -44,8 +44,11 @@ def test_lcm_multiple_invalid_inputs(): with pytest.raises(ValueError, match="At least one number must be provided"): lcm_multiple() - with pytest.raises(ValueError): + with pytest.raises(ValueError, match="All inputs must be positive integers"): lcm_multiple(2, 3, 0) - with pytest.raises(ValueError): - lcm_multiple(2, -3, 4) \ No newline at end of file + with pytest.raises(ValueError, match="All inputs must be positive integers"): + lcm_multiple(2, -3, 4) + + with pytest.raises(ValueError, match="All inputs must be integers"): + lcm_multiple(2, 3, 3.5) \ No newline at end of file From afc8491720783e1c99018fe1273b8763b5c94525 Mon Sep 17 00:00:00 2001 From: laura-abro Date: Tue, 8 Apr 2025 20:14:35 -0300 Subject: [PATCH 15/17] Add fraction simplifier implementation --- src/fraction_simplifier.py | 48 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 src/fraction_simplifier.py diff --git a/src/fraction_simplifier.py b/src/fraction_simplifier.py new file mode 100644 index 00000000..4304c9f5 --- /dev/null +++ b/src/fraction_simplifier.py @@ -0,0 +1,48 @@ +from src.gcd_calculator import calculate_gcd + +def simplify_fraction(numerator: int, denominator: int) -> tuple[int, int]: + """ + Simplify a fraction to its lowest terms. + + Args: + numerator (int): The numerator of the fraction. + denominator (int): The denominator of the fraction. + + Returns: + tuple[int, int]: A tuple containing the simplified numerator and denominator. + + Raises: + ValueError: If the denominator is zero. + TypeError: If numerator or denominator are not integers. + """ + # Validate input types + if not isinstance(numerator, int) or not isinstance(denominator, int): + raise TypeError("Numerator and denominator must be integers") + + # Check for zero denominator + if denominator == 0: + raise ValueError("Denominator cannot be zero") + + # Handle zero numerator case + if numerator == 0: + return 0, 1 + + # Determine sign + sign = 1 + if numerator < 0 and denominator < 0: + sign = 1 + elif numerator < 0 or denominator < 0: + sign = -1 + + # Take absolute values for GCD calculation + abs_numerator = abs(numerator) + abs_denominator = abs(denominator) + + # Calculate GCD + gcd = calculate_gcd(abs_numerator, abs_denominator) + + # Simplify the fraction + simplified_numerator = sign * (abs_numerator // gcd) + simplified_denominator = abs_denominator // gcd + + return simplified_numerator, simplified_denominator \ No newline at end of file From d2128e0195a1a435bd4cee86f0186d54edb14532 Mon Sep 17 00:00:00 2001 From: laura-abro Date: Tue, 8 Apr 2025 20:14:44 -0300 Subject: [PATCH 16/17] Add tests for fraction simplifier --- tests/test_fraction_simplifier.py | 37 +++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 tests/test_fraction_simplifier.py diff --git a/tests/test_fraction_simplifier.py b/tests/test_fraction_simplifier.py new file mode 100644 index 00000000..0a568683 --- /dev/null +++ b/tests/test_fraction_simplifier.py @@ -0,0 +1,37 @@ +import pytest +from src.fraction_simplifier import simplify_fraction + +def test_simplify_standard_fraction(): + assert simplify_fraction(4, 6) == (2, 3) + assert simplify_fraction(15, 25) == (3, 5) + +def test_simplify_negative_fractions(): + assert simplify_fraction(-4, 6) == (-2, 3) + assert simplify_fraction(4, -6) == (-2, 3) + assert simplify_fraction(-4, -6) == (2, 3) + +def test_zero_numerator(): + assert simplify_fraction(0, 5) == (0, 1) + assert simplify_fraction(0, -5) == (0, 1) + +def test_already_simplified_fraction(): + assert simplify_fraction(3, 7) == (3, 7) + assert simplify_fraction(-3, 7) == (-3, 7) + +def test_large_numbers(): + assert simplify_fraction(1000000, 10000) == (100, 1) + assert simplify_fraction(10000, 1000000) == (1, 100) + +def test_error_handling(): + # Test zero denominator + with pytest.raises(ValueError, match="Denominator cannot be zero"): + simplify_fraction(5, 0) + + # Test non-integer inputs + with pytest.raises(TypeError, match="Numerator and denominator must be integers"): + simplify_fraction(5.5, 6) + + with pytest.raises(TypeError, match="Numerator and denominator must be integers"): + simplify_fraction(5, "6") + with pytest.raises(TypeError, match="Numerator and denominator must be integers"): + simplify_fraction("5", 6) \ No newline at end of file From bb88cd1f7636b62a12d72ca45414935e4df9f580 Mon Sep 17 00:00:00 2001 From: laura-abro Date: Tue, 8 Apr 2025 20:14:57 -0300 Subject: [PATCH 17/17] Update GCD function import name --- src/fraction_simplifier.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/fraction_simplifier.py b/src/fraction_simplifier.py index 4304c9f5..9a55ff17 100644 --- a/src/fraction_simplifier.py +++ b/src/fraction_simplifier.py @@ -1,4 +1,4 @@ -from src.gcd_calculator import calculate_gcd +from src.gcd_calculator import gcd_using_prime_factors def simplify_fraction(numerator: int, denominator: int) -> tuple[int, int]: """ @@ -39,7 +39,7 @@ def simplify_fraction(numerator: int, denominator: int) -> tuple[int, int]: abs_denominator = abs(denominator) # Calculate GCD - gcd = calculate_gcd(abs_numerator, abs_denominator) + gcd = gcd_using_prime_factors(abs_numerator, abs_denominator) # Simplify the fraction simplified_numerator = sign * (abs_numerator // gcd)