crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/libimpl/mathlib.py

@@ -1,16 +1,179 @@
 import math
+import sys
+from numbers import Real
+
+import z3  # type: ignore
 
 from crosshair import NoTracing, register_patch
-from crosshair.libimpl.builtinslib import SymbolicNumberAble
+from crosshair.core import with_realized_args
+from crosshair.libimpl.builtinslib import (
+    PreciseIeeeSymbolicFloat,
+    RealBasedSymbolicFloat,
+    SymbolicBool,
+    SymbolicIntable,
+    SymbolicValue,
+    smt_xor,
+)
+from crosshair.tracers import ResumedTracing
+from crosshair.util import name_of_type
+from crosshair.z3util import z3Not, z3Or
+
+
+def _is_positive(x):
+    if isinstance(x, SymbolicValue):
+        if isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3Not(z3.fpIsNegative(x.var)))
+        elif isinstance(x, RealBasedSymbolicFloat):
+            return SymbolicBool(x.var >= 0)
+        else:
+            with ResumedTracing():
+                return x >= 0
+    else:
+        return math.copysign(1, x) == 1
+
+
+def _copysign(x, y):
+    if not isinstance(x, Real):
+        raise TypeError(f"must be real number, not {name_of_type(type(x))}")
+    if not isinstance(y, Real):
+        raise TypeError(f"must be real number, not {name_of_type(type(y))}")
+    with NoTracing():
+        x_is_positive = _is_positive(x)
+        y_is_positive = _is_positive(y)
+        # then invert as needed:
+    invert = smt_xor(x_is_positive, y_is_positive)
+    with NoTracing():
+        if isinstance(invert, SymbolicBool) and isinstance(
+            x, (PreciseIeeeSymbolicFloat, RealBasedSymbolicFloat)
+        ):
+            return type(x)(z3.If(invert.var, -x.var, x.var))
+        with ResumedTracing():
+            return -x if invert else x
+
+
+if sys.version_info >= (3, 9):
+
+    def _gcd(a=0, b=0):
+        while b:
+            a, b = b, a % b
+        return abs(a)
+
+else:  # (arguments were required in Python <= 3.8)
+
+    def _gcd(a, b):
+        while b:
+            a, b = b, a % b
+        return abs(a)
 
 
 def _isfinite(x):
     with NoTracing():
-        if isinstance(x, SymbolicNumberAble):
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
             return True
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3Not(z3Or(z3.fpIsNaN(x.var), z3.fpIsInf(x.var))))
         else:
             return math.isfinite(x)
 
 
+def _isnan(x):
+    with NoTracing():
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
+            return False
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3.fpIsNaN(x.var))
+        else:
+            return math.isnan(x)
+
+
+def _isinf(x):
+    with NoTracing():
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
+            return False
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3.fpIsInf(x.var))
+        else:
+            return math.isinf(x)
+
+
+_FUNCTIONS_WITH_REALIZATION = [
+    # TODO: we could attempt to implement some of these in the SMT solver
+    "acos",
+    "acosh",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "ceil",
+    "comb",
+    "cos",
+    "cosh",
+    "degrees",
+    "dist",
+    "erf",
+    "erfc",
+    "exp",
+    "expm1",
+    "fabs",
+    "factorial",
+    "floor",
+    "fmod",
+    "frexp",
+    "fsum",
+    "gamma",
+    "hypot",
+    "isclose",
+    "isqrt",
+    "ldexp",
+    "lgamma",
+    "log",
+    "log10",
+    "log1p",
+    "log2",
+    "modf",
+    "perm",
+    "pow",
+    "prod",
+    "radians",
+    "remainder",
+    "sin",
+    "sinh",
+    "sqrt",
+    "tan",
+    "tanh",
+    "trunc",
+]
+
+if sys.version_info >= (3, 9):
+    _FUNCTIONS_WITH_REALIZATION.extend(
+        [
+            "lcm",
+            "nextafter",
+            "ulp",
+        ]
+    )
+
+if sys.version_info >= (3, 11):
+    _FUNCTIONS_WITH_REALIZATION.extend(
+        [
+            "cbrt",
+            "exp2",
+        ]
+    )
+
+if sys.version_info >= (3, 12):
+    _FUNCTIONS_WITH_REALIZATION.append("sumprod")
+
+
 def make_registrations():
+    register_patch(math.copysign, _copysign)
+    register_patch(math.gcd, _gcd)
     register_patch(math.isfinite, _isfinite)
+    register_patch(math.isnan, _isnan)
+    register_patch(math.isinf, _isinf)
+    for fn_name in _FUNCTIONS_WITH_REALIZATION:
+        fn = getattr(math, fn_name)
+        register_patch(
+            fn, with_realized_args(fn, deep=True)
+        )  # deep realization needed for Fraction instances

crosshair/libimpl/mathlib_ch_test.py

@@ -0,0 +1,44 @@
+import math
+import sys
+from typing import Union
+
+import pytest  # type: ignore
+
+from crosshair.core import realize
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.options import AnalysisOptionSet
+from crosshair.test_util import compare_results
+
+
+def check_copysign(
+    a: Union[int, float], b: Union[int, float], realize_a: bool, realize_b: bool
+):
+    """post: _"""
+    if realize_a:
+        a = realize(a)
+    if realize_b:
+        b = realize(b)
+    return compare_results(math.copysign, a, b)
+
+
+def check_gcd(a: int, b: int):
+    """
+    pre: all([-10 < a, a < 10, -10 < b, b < 10])  # for performance
+    post: _
+    """
+    return compare_results(math.gcd, a, b)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    this_module = sys.modules[__name__]
+    messages = run_checkables(
+        analyze_function(
+            getattr(this_module, fn_name),
+            AnalysisOptionSet(max_uninteresting_iterations=50),
+        )
+    )
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/mathlib_test.py

@@ -1,24 +1,67 @@
 import math
 import sys
-import unittest
 
-from crosshair.core import standalone_statespace
-from crosshair.libimpl.builtinslib import SymbolicFloat
-from crosshair.tracers import NoTracing
+import pytest
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.libimpl.builtinslib import (
+    ModelingDirector,
+    PreciseIeeeSymbolicFloat,
+    RealBasedSymbolicFloat,
+)
+from crosshair.statespace import POST_FAIL
+from crosshair.test_util import check_states
+from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import set_debug
 
 
-class MathLibTests(unittest.TestCase):
-    def test_isfinite(self):
-        with standalone_statespace:
-            with NoTracing():
-                x = SymbolicFloat("symfloat")
-            self.assertTrue(math.isfinite(x))
-            self.assertTrue(math.isfinite(2.3))
-            self.assertFalse(math.isfinite(float("nan")))
+def test_copysign_e2e():
+    def can_find_minus_zero(x: float):
+        """post: math.copysign(1, _) == 1"""
+        if x == 0:
+            return x
+        return 1
+
+    check_states(can_find_minus_zero, POST_FAIL)
+
+
+@pytest.mark.parametrize(
+    "FloatType", [PreciseIeeeSymbolicFloat, RealBasedSymbolicFloat]
+)
+def test_copysign_symbolics(FloatType, space):
+    space.extra(ModelingDirector).global_representations[float] = FloatType
+    x = FloatType("x")
+    y = FloatType("y")
+    with ResumedTracing():
+        assert not space.is_possible(math.copysign(x, -0.0) > 0.0)
+        assert space.is_possible(math.copysign(x, y) > 0.0)
+        assert space.is_possible(math.copysign(x, y) < 0.0)
+
+
+def test_isfinite():
+    with standalone_statespace:
+        with NoTracing():
+            x = RealBasedSymbolicFloat("symfloat")
+        assert math.isfinite(x)
+        assert math.isfinite(2.3)
+        assert not math.isfinite(float("nan"))
+
+
+def test_isinf():
+    with standalone_statespace:
+        with NoTracing():
+            x = RealBasedSymbolicFloat("symfloat")
+        assert not math.isinf(x)
+        assert not math.isinf(float("nan"))
+        assert math.isinf(float("-inf"))
 
 
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()
+def test_log():
+    with standalone_statespace as space:
+        with NoTracing():
+            i = proxy_for_type(int, "i")
+            f = proxy_for_type(float, "f")
+        space.add(i > 0)
+        space.add(f > 0)
+        math.log(i)
+        math.log(f)

crosshair/libimpl/oslib.py

@@ -0,0 +1,7 @@
+import os
+
+from crosshair.core import register_patch
+
+
+def make_registrations():
+    register_patch(os.fspath, os._fspath)

crosshair/libimpl/pathliblib_test.py

@@ -0,0 +1,10 @@
+from pathlib import PurePath
+
+from crosshair.core import proxy_for_type
+from crosshair.tracers import ResumedTracing
+
+
+def test_PurePath___init__(space):
+    pathstr = proxy_for_type(str, "pathstr")
+    with ResumedTracing():
+        PurePath(pathstr)

crosshair/libimpl/randomlib.py

@@ -76,6 +76,7 @@ class ExplicitRandom(random.Random):
 
 
 def genint(factory: SymbolicFactory, cap: int):
+    # TODO: conditionally use SymbolicBoundedInt here and below
     with NoTracing():
         symbolic_int = SymbolicInt(factory.varname + factory.space.uniq(), int)
         factory.space.add(0 <= symbolic_int.var)

crosshair/libimpl/randomlib_test.py

@@ -7,6 +7,7 @@ from crosshair.core_and_libs import proxy_for_type, standalone_statespace
 from crosshair.libimpl.randomlib import ExplicitRandom
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
+from crosshair.tracers import ResumedTracing
 
 
 def test_ExplicitRandom():
@@ -31,9 +32,10 @@ def test_proxy_random():
     with standalone_statespace as space:
         rng = proxy_for_type(random.Random, "rng")
         i = rng.randrange(5, 10)
-        assert space.is_possible(i.var == 5)
-        assert space.is_possible(i.var == 9)
-        assert not space.is_possible(i.var == 4)
+        with ResumedTracing():
+            assert space.is_possible(i == 5)
+            assert space.is_possible(i == 9)
+            assert not space.is_possible(i == 4)
 
 
 def test_global_randrange():
@@ -105,7 +107,7 @@ def test_global_uniform_inverted_args():
         """post: -2.0 <= _ <= 10.0"""
         return random.uniform(10, -2)
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, CONFIRMED)
 
 
 def test_global_getrandbits():