enh: optimize expression resolver for div

enh: optimize crossmath generator

Author: kamarton

crossmath.py

@@ -4,7 +4,7 @@
 
 from expression import Expression, ExpressionValidator
 from expression_map import ExpressionMap, ExpressionItem, Direction
-from expression_resolver import ExpressionResolver
+from expression_resolver import ExpressionResolver, ExpressionResolverException
 from number_factory import NumberFactory
 
 
@@ -13,7 +13,9 @@ def __init__(self, exp_map: ExpressionMap, number_factory: NumberFactory):
         self._map = exp_map
         self._number_factory = number_factory
         self._expression_resolver = ExpressionResolver(
-            validator=ExpressionValidator(number_factory=number_factory),
+            validator=ExpressionValidator(
+                number_factory=number_factory, minimum=-100, maximum=50
+            ),
             number_factory=number_factory,
         )
 
@@ -59,12 +61,16 @@ def _check_x_y_overflow(self, x: int, y: int, length: int) -> bool:
         return True
 
     def _find_potential_values(
-        self, potential_positions: list[Tuple[int, int]]
+        self,
+        potential_positions: list[Tuple[int, int]],
+        dead_positions: list[Tuple[Direction, int, int]],
     ) -> list[Tuple[Direction, int, int, list]]:
         max_expression_length = max(Expression.SUPPORTED_LENGTHS)
         for next_position in potential_positions:
             x, y = next_position
             for direction in Direction.all():
+                if (direction, x, y) in dead_positions:
+                    continue
                 for expression_offset in range(0, -max_expression_length - 1, -2):
                     values_x_offset = (
                         0 if direction.is_vertical() else expression_offset
@@ -105,33 +111,34 @@ def _init_generate(self):
             raise Exception("No expression found")
         direction = random.choice([Direction.HORIZONTAL, Direction.VERTICAL])
         item = ExpressionItem(
-            3,
-            3,
+            2,
+            2,
             direction,
             expression,
         )
         self._map.put(item)
 
     def generate(self):
-        start_time = time.time()
         self._init_generate()
-        for i in range(40):
+        dead_positions = []
+        while True:
             potential_positions = self._find_potential_positions()
-            potential_values = list(self._find_potential_values(potential_positions))
+            potential_values = list(
+                self._find_potential_values(potential_positions, dead_positions)
+            )
             random.shuffle(potential_values)
             is_expression_appended = False
             for desc in potential_values:
+                print(".", end="")
                 direction, _x, _y, values = desc
                 # print("desc:", desc, "x:", _x, "y:", _y)
                 try:
                     expression = self._expression_resolver.resolve(
                         Expression.from_values(values)
                     )
-                except ValueError:
-                    # TODO store dead positions
-                    continue
-                if expression is None:
-                    # TODO store dead positions
+                except ExpressionResolverException as e:
+                    print(f"ExpressionResolverException: {e}")
+                    dead_positions.append((direction, _x, _y))
                     continue
                 expression_item = ExpressionItem(_x, _y, direction, expression)
                 self._map.put(expression_item)
@@ -140,7 +147,5 @@ def generate(self):
             if not is_expression_appended:
                 break
 
-            print("time: ", time.time() - start_time)
-
     def print(self):
         self._map.print(number_factory=self._number_factory)

expression_resolver.py

@@ -5,6 +5,33 @@
 from number_factory import NumberFactory
 
 
+class ExpressionResolverException(Exception):
+    def __init__(
+        self,
+        message: str = "Expression resolver exception",
+        expression: Expression | None = None,
+    ):
+        super().__init__(f"{message} (expression={expression})")
+
+
+class ExpressionResolverNotResolvable(ExpressionResolverException):
+    def __init__(
+        self,
+        message: str = "Expression is not resolvable",
+        expression: Expression | None = None,
+    ):
+        super().__init__(message, expression=expression)
+
+
+class ExpressionResolverMaybeNotResolvable(ExpressionResolverException):
+    def __init__(
+        self,
+        message: str = "Expression is maybe not resolvable",
+        expression: Expression | None = None,
+    ):
+        super().__init__(message, expression=expression)
+
+
 class ExpressionResolver:
     def __init__(self, validator: ExpressionValidator, number_factory: NumberFactory):
         self._validator = validator
@@ -22,11 +49,28 @@ def _fix_result(self, expression: Expression):
         expression.operand2 = self._number_factory.fix(expression.operand2)
         expression.result = self._number_factory.fix(expression.result)
 
-    def _resolve_result_is_none(self, expression: Expression) -> Expression | None:
+    def _next_operator(self, expression: Expression) -> list[Operator]:
+        if expression.operand1 is None or expression.operand2 is None:
+            yield random.choice(Operator.get_operators_without_eq())
+        operators = Operator.get_operators_without_eq()
+        random.shuffle(operators)
+        for operator in operators:
+            yield operator
+
+    def _resolve_result_is_none(self, expression: Expression) -> Expression:
+        start = time.time()
+        operators = self._next_operator(expression)
         while True:
             exp_result = expression.clone()
             if exp_result.operator is None:
-                exp_result.operator = random.choice(Operator.get_operators_without_eq())
+                try:
+                    exp_result.operator = next(operators)
+                except StopIteration:
+                    raise ExpressionResolverNotResolvable(expression=expression)
+            if exp_result.operator == Operator.DIV and NumberFactory.is_zero(
+                exp_result.operand2
+            ):
+                continue
             if exp_result.operand1 is None:
                 exp_result.operand1 = self._number_factory.next()
             if exp_result.operand2 is None:
@@ -51,11 +95,14 @@ def _resolve_result_is_none(self, expression: Expression) -> Expression | None:
             self._check_result(expression, exp_result)
             if not self._validator.validate(exp_result):
                 # TODO time or count limit
+                if time.time() - start > 1.0:
+                    raise ExpressionResolverMaybeNotResolvable(expression=expression)
                 continue
             self._fly_back(exp_result)
             return exp_result
 
-    def _resolve_result_is_available(self, expression: Expression) -> Expression | None:
+    def _resolve_result_is_available(self, expression: Expression) -> Expression:
+        start = time.time()
         while True:
             exp_calc = expression.clone()
             exp_result = expression.clone()
@@ -90,6 +137,12 @@ def _resolve_result_is_available(self, expression: Expression) -> Expression | N
                 # a * ? = c -> c / a = b
                 # ? * b = c -> c / b = a
                 exp_calc.operator = Operator.DIV
+                if not_has_operands:
+                    exp_result.operand1 = exp_calc.operand1 = self._number_factory.next(
+                        dividable_by=exp_result.result,
+                        zero_allowed=False,
+                    )
+                    print(exp_calc)
             elif operator == Operator.DIV:
                 # a / b = c
                 if not_has_operands:
@@ -109,20 +162,31 @@ def _resolve_result_is_available(self, expression: Expression) -> Expression | N
             else:
                 raise RuntimeError(f"Invalid operator: {operator}")
             if exp_result.operand1 is None:
+                if ExpressionResolver.is_zero_division(
+                    exp_calc.operator, exp_calc.operand2
+                ):
+                    continue
                 exp_result.operand1 = self._number_factory.fix(
                     eval(f"{exp_calc.result} {exp_calc.operator} {exp_calc.operand2}")
                 )
             elif exp_result.operand2 is None:
+                if ExpressionResolver.is_zero_division(
+                    exp_calc.operator, exp_calc.operand1
+                ):
+                    continue
                 exp_result.operand2 = self._number_factory.fix(
                     eval(f"{exp_calc.result} {exp_calc.operator} {exp_calc.operand1}")
                 )
             else:
-                raise ValueError(f"Operator resolver not supported ({expression})")
+                raise ExpressionResolverException(
+                    "Operator resolver mode not supported", expression=expression
+                )
             self._check_result(expression, exp_result)
 
-            # print("expression:", expression, "exp_result:", exp_result)
             if not self._validator.validate(exp_result):
                 # TODO time or count limit
+                if time.time() - start > 1.0:
+                    raise ExpressionResolverMaybeNotResolvable(expression=expression)
                 continue
             self._fly_back(exp_result)
             return exp_result
@@ -152,3 +216,7 @@ def _check_result(self, expression: Expression, result: Expression):
         if expression.operator is not None:
             if expression.operator != result.operator:
                 raise RuntimeError(f"Invalid operator: {expression} -> {result}")
+
+    @staticmethod
+    def is_zero_division(operator: Operator, operand2: float) -> bool:
+        return operator == Operator.DIV and NumberFactory.is_zero(operand2)

main.py

@@ -4,11 +4,11 @@
 from expression_map import ExpressionMap
 from number_factory import NumberFactory
 
-WIDTH = int(os.environ.get("WIDTH", 20))
-HEIGHT = int(os.environ.get("HEIGHT", 20))
-NUMBER_FACTORY_MIN = float(os.environ.get("NUMBER_FACTORY_MIN", 0.1))
-NUMBER_FACTORY_MAX = float(os.environ.get("NUMBER_FACTORY_MAX", 8.0))
-NUMBER_FACTORY_STEP = float(os.environ.get("NUMBER_FACTORY_STEP", 0.5))
+WIDTH = int(os.environ.get("WIDTH", 30))
+HEIGHT = int(os.environ.get("HEIGHT", 30))
+NUMBER_FACTORY_MIN = float(os.environ.get("NUMBER_FACTORY_MIN", 0.01))
+NUMBER_FACTORY_MAX = float(os.environ.get("NUMBER_FACTORY_MAX", 10.0))
+NUMBER_FACTORY_STEP = float(os.environ.get("NUMBER_FACTORY_STEP", 0.1))
 
 if __name__ == "__main__":
     exp_map = ExpressionMap(width=WIDTH, height=HEIGHT)
@@ -20,6 +20,7 @@
     cross_math = CrossMath(exp_map=exp_map, number_factory=number_factory)
     # try:
     cross_math.generate()
+    print()
     cross_math.print()
     number_factory.print_statistic()
     # except Exception as e:

number_factory.py

@@ -60,10 +60,16 @@ def next(
                 value += self._step
             while value > (maximum or self._max):
                 value -= self._step
-            if not zero_allowed and self.is_equal(value, 0.0):
+            if not zero_allowed and NumberFactory.is_zero(value):
                 continue
             return value
 
+    @staticmethod
+    def is_zero(value: float | None):
+        if value is None:
+            return False
+        return abs(0.0 - value) < 1e-6
+
     def is_equal(self, value1: float | None, value2: float | None) -> bool:
         return self.format(value1, decimals=8) == self.format(value2, decimals=8)
 

test_number_factory.py

@@ -71,3 +71,11 @@ def test_decimals():
     assert number_factory.get_decimals() == 0
     number_factory = NumberFactory(step=100)
     assert number_factory.get_decimals() == 0
+
+
+def test_is_zero():
+    assert NumberFactory.is_zero(0.0)
+    assert not NumberFactory.is_zero(0.1)
+    assert not NumberFactory.is_zero(-0.1)
+    assert not NumberFactory.is_zero(1.0)
+    assert not NumberFactory.is_zero(-1.0)