polysolve 0.6.0__tar.gz → 0.6.2__tar.gz

{polysolve-0.6.0/src/polysolve.egg-info → polysolve-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysolve
-Version: 0.6.0
+Version: 0.6.2
 Summary: A Python library for representing, manipulating, and solving exponential functions using analytical methods and genetic algorithms, with optional CUDA acceleration.
 Author-email: Jonathan Rampersad <jonathan@jono-rams.work>
 License: MIT License

{polysolve-0.6.0 → polysolve-0.6.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 # --- Core Metadata ---
 name = "polysolve"
-version = "0.6.0"
+version = "0.6.2"
 authors = [
   { name="Jonathan Rampersad", email="jonathan@jono-rams.work" },
 ]

{polysolve-0.6.0 → polysolve-0.6.2}/src/polysolve/__init__.py

@@ -133,6 +133,15 @@ class GA_Options:
             raise ValueError(
                 f"blend_alpha cannot be negative, but got {self.blend_alpha}"
             )
+        if self.root_precision > 15:
+            warnings.warn(
+                f"root_precision={self.root_precision} is greater than 15. "
+                "This demands an accuracy that is likely impossible for standard "
+                "64-bit floats (float64), which are limited to 15-16 significant digits. "
+                "The solver may fail to find any roots.",
+                UserWarning,
+                stacklevel=2
+            )
 
 def _get_cauchy_bound(coeffs: np.ndarray) -> float:
     """
@@ -256,7 +265,9 @@ class Function:
         """
         self._check_initialized()
         if self._largest_exponent == 0:
-            raise ValueError("Cannot differentiate a constant (Function of degree 0).")
+            diff_func = Function(0)
+            diff_func.set_coeffs([0])
+            return diff_func
         
         derivative_coefficients = np.polyder(self.coefficients)
         
@@ -672,7 +683,7 @@ class Function:
     
     def _multiply_by_scalar(self, scalar: Union[int, float]) -> 'Function':
         """Helper method to multiply the function by a scalar constant."""
-        self._check_initialized() # It's good practice to check here too
+        self._check_initialized()
 
         if scalar == 0:
             result_func = Function(0)
@@ -735,6 +746,21 @@ class Function:
             return NotImplemented
         
         return self
+    
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks if two Function objects are equal by comparing
+        their coefficients.
+        """
+        # Check if the 'other' object is even a Function
+        if not isinstance(other, Function):
+            return NotImplemented
+        
+        # Ensure both are initialized before trying to access .coefficients
+        if not self._initialized or not other._initialized:
+            return False
+
+        return np.array_equal(self.coefficients, other.coefficients)
 
 
     def quadratic_solve(self) -> Optional[List[float]]:
@@ -759,9 +785,35 @@ class Function:
             return None  # No real roots
 
         sqrt_discriminant = math.sqrt(discriminant)
-        root1 = (-b + sqrt_discriminant) / (2 * a)
-        root2 = (-b - sqrt_discriminant) / (2 * a)
+        
+        # 1. Calculate the first root.
+        # We use math.copysign(val, sign) to get the sign of b.
+        # This ensures (-b - sign*sqrt) is always an *addition*
+        # (or subtraction of a smaller from a larger number),
+        # avoiding catastrophic cancellation.
+        root1 = (-b - math.copysign(sqrt_discriminant, b)) / (2 * a)
+
+        # 2. Calculate the second root using Vieta's formulas.
+        # We know that root1 * root2 = c / a.
+        # This is just a division, which is numerically stable.
+
+        # Handle the edge case where c=0.
+        # If c=0, then root1 is 0.0, and root2 is -b/a
+        # We can't divide by root1=0, so we check.
+        if root1 == 0.0:
+            # If c is also 0, the other root is -b/a
+            if c == 0.0: 
+                root2 = -b / a
+            else:
+                # This case (root1=0 but c!=0) shouldn't happen
+                # with real numbers, but it's safe to just
+                # return the one root we found.
+                return [0.0] 
+        else:
+            # Standard case: Use Vieta's formula
+            root2 = (c / a) / root1
 
+        # Return roots in a consistent order
         return [root1, root2]
 
 # Example Usage

{polysolve-0.6.0 → polysolve-0.6.2/src/polysolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysolve
-Version: 0.6.0
+Version: 0.6.2
 Summary: A Python library for representing, manipulating, and solving exponential functions using analytical methods and genetic algorithms, with optional CUDA acceleration.
 Author-email: Jonathan Rampersad <jonathan@jono-rams.work>
 License: MIT License

{polysolve-0.6.0 → polysolve-0.6.2}/tests/test_polysolve.py

@@ -37,6 +37,12 @@ def m_func_2() -> Function:
     f.set_coeffs([5, -4])
     return f
 
+@pytest.fixture
+def base_func():
+    f = Function(2)
+    f.set_coeffs([1, 2, 3])
+    return f
+
 # --- Core Functionality Tests ---
 
 def test_solve_y(quadratic_func):
@@ -95,6 +101,32 @@ def test_function_multiplication(m_func_1, m_func_2):
     assert result.largest_exponent == 3
     assert np.array_equal(result.coefficients, [10, 7, -7, -4])
 
+def test_equality(base_func):
+    """Tests the __eq__ method for the Function class."""
+    
+    # 1. Test for equality with a new, identical object
+    f_identical = Function(2)
+    f_identical.set_coeffs([1, 2, 3])
+    assert base_func == f_identical
+
+    # 2. Test for inequality (different coefficients)
+    f_different = Function(2)
+    f_different.set_coeffs([1, 9, 3])
+    assert base_func != f_different
+
+    # 3. Test for inequality (different degree)
+    f_diff_degree = Function(1)
+    f_diff_degree.set_coeffs([1, 2])
+    assert base_func != f_diff_degree
+
+    # 4. Test against a different type
+    assert base_func != "some_string"
+    assert base_func != 123
+
+    # 5. Test against an uninitialized Function
+    f_uninitialized = Function(2)
+    assert base_func != f_uninitialized
+
 # --- Genetic Algorithm Root-Finding Tests ---
 
 def test_get_real_roots_numpy(quadratic_func):