Aperture macro expression simplification WIP

3 files changed, 127 insertions, 16 deletions

diff --git a/gerbonara/aperture_macros/expression.py b/gerbonara/aperture_macros/expression.py
index 99d02eb..f096cf1 100644
--- a/gerbonara/aperture_macros/expression.py
+++ b/gerbonara/aperture_macros/expression.py
@@ -7,6 +7,7 @@ from dataclasses import dataclass
 import operator
 import re
 import ast
+import math
 
 from ..utils import LengthUnit, MM, Inch, MILLIMETERS_PER_INCH
 
@@ -61,7 +62,7 @@ class Expression:
         return expr(other) / self
 
     def __neg__(self):
-        return 0 - self
+        return NegatedExpression(self)
 
     def __pos__(self):
         return self
@@ -155,9 +156,12 @@ class ConstantExpression(Expression):
         return float(self.value)
 
     def __eq__(self, other):
-        return type(self) == type(other) and self.value == other.value
+        try:
+            return math.isclose(self.value, float(other), abs_tol=1e-9)
+        except TypeError:
+            return False
 
-    def to_gerber(self, _unit=None):
+    def to_gerber(self, unit=None):
         return f'{self.value:.6f}'.rstrip('0').rstrip('.')
 
     
@@ -174,9 +178,45 @@ class VariableExpression(Expression):
         return type(self) == type(other) and \
                 self.number == other.number
 
-    def to_gerber(self, _unit=None):
+    def to_gerber(self, unit=None):
         return f'${self.number}'
 
+@dataclass(frozen=True, slots=True)
+class NegatedExpression(Expression):
+    value: Expression
+
+    def optimized(self, variable_binding={}):
+        match self.value.optimized(variable_binding):
+            # -(-x) == x
+            case NegatedExpression(inner_value):
+                return inner_value
+            # -(x) == -x
+            case ConstantExpression(inner_value):
+                return ConstantExpression(-inner_value)
+            # -(x-y) == y-x
+            case OperatorExpression(operator.sub, l, r):
+                return OperatorExpression(operator.sub, r, l)
+            # -(x [*/] y) == -x [*/] y
+            case OperatorExpression((operator.mul | operator.truediv) as op, ConstantExpression(l), r):
+                return OperatorExpression(op, ConstantExpression(-l), r)
+            # -(x [*/] y) == x [*/] -y
+            case OperatorExpression((operator.mul | operator.truediv) as op, l, ConstantExpression(r)):
+                return OperatorExpression(op, l, ConstantExpression(-r))
+
+            case x:
+                return NegatedExpression(x)
+
+    def __eq__(self, other):
+        return type(self) == type(other) and \
+                self.value == other.value
+
+    def to_gerber(self, unit=None):
+        val_str = self.value.to_gerber(unit)
+        if isinstance(self.value, VariableExpression):
+            return f'-{val_str}'
+        else:
+            return f'-({val_str})'
+
 
 @dataclass(frozen=True, slots=True)
 class OperatorExpression(Expression):
@@ -198,15 +238,83 @@ class OperatorExpression(Expression):
     def optimized(self, variable_binding={}):
         l = self.l.optimized(variable_binding)
         r = self.r.optimized(variable_binding)
+        print(self.r, '->', r)
         
-        #if self.op in (operator.add, operator.mul):
-        #    if id(r) < id(l):
-        #        l, r = r, l
-
-        if isinstance(l, ConstantExpression) and isinstance(r, ConstantExpression):
-            return ConstantExpression(self.op(float(l), float(r)))
-
-        return OperatorExpression(self.op, l, r)
+        match (l, self.op, r):
+            case (ConstantExpression(), op, ConstantExpression()):
+                return ConstantExpression(self.op(float(l), float(r)))
+
+            # Minimize operations with neutral elements and zeros
+            # 0 + x == x
+            case (0, operator.add, r):
+                return r
+            # x + 0 == x
+            case (l, operator.add, 0):
+                return l
+            # 0 * x == 0
+            case (0, operator.mul, r):
+                return expr(0)
+            # x * 0 == 0
+            case (l, operator.mul, 0):
+                return expr(0)
+            # x * 1 == x
+            case (l, operator.mul, 1):
+                return l
+            # 1 * x == x
+            case (1, operator.mul, r):
+                return r
+            # x * -1 == -x
+            case (l, operator.mul, -1):
+                rv = -l
+            # -1 * x == -x
+            case (-1, operator.mul, r):
+                rv = -r
+            # x - 0 == x
+            case (l, operator.sub, 0):
+                return l
+            # 0 - x == -x (unary minus)
+            case (0, operator.sub, r):
+                rv = -r
+            # x - x == 0
+            case (l, operator.sub, r) if l == r:
+                return expr(0)
+            # x - -y == x + y
+            case (l, operator.sub, NegatedExpression(r)):
+                rv = (l + r)
+            # x / 1 == x
+            case (l, operator.truediv, 1):
+                return l
+            # x / -1 == -x
+            case (l, operator.truediv, -1):
+                rv = -l
+            # x / x == 1
+            case (l, operator.truediv, r) if l == r:
+                return expr(1)
+            # -x [*/] -y == x [*/] y
+            case (NegatedExpression(l), (operator.truediv | operator.mul) as op, NegatedExpression(r)):
+                rv = op(l, r)
+            # -x + -y == -(x + y)
+            case (NegatedExpression(l), operator.add, NegatedExpression(r)):
+                rv = -(l+r)
+            # -x + y == y - x
+            case (NegatedExpression(l), operator.add, r):
+                rv = r-l
+            # x + x == 2 * x
+            case (l, operator.add, r) if l == r:
+                rv = 2*r
+            case ((l, op, OperatorExpression(operator.mul, ConstantExpression(cons), r)) |
+                  (l, op, OperatorExpression(operator.mul, r, ConstantExpression(cons)))) \
+                 if l == r and op in (operator.add, operator.sub):
+                return op(1, cons) * r
+            case ((OperatorExpression(operator.mul, ConstantExpression(cons), r), op, l) |
+                  (OperatorExpression(operator.mul, r, ConstantExpression(cons)), op, l)) \
+                 if l == r and op in (operator.add, operator.sub):
+                return op(cons, 1) * r
+
+            case _: # default
+                return OperatorExpression(self.op, l, r)
+
+        return expr(rv).optimized(variable_binding)
         
     def to_gerber(self, unit=None):
         lval = self.l.to_gerber(unit)
diff --git a/gerbonara/aperture_macros/parse.py b/gerbonara/aperture_macros/parse.py
index 45f8c41..1527bc1 100644
--- a/gerbonara/aperture_macros/parse.py
+++ b/gerbonara/aperture_macros/parse.py
@@ -30,7 +30,7 @@ def _map_expression(node):
         if type(node.op) == ast.UAdd:
             return _map_expression(node.operand)
         else:
-            return OperatorExpression(operator.sub, ConstantExpression(0), _map_expression(node.operand))
+            return NegatedExpression(_map_expression(node.operand))
 
     elif isinstance(node, ast.Name):
         return VariableExpression(int(node.id[3:])) # node.id has format var[0-9]+
diff --git a/gerbonara/aperture_macros/primitive.py b/gerbonara/aperture_macros/primitive.py
index f575b0c..1372dfa 100644
--- a/gerbonara/aperture_macros/primitive.py
+++ b/gerbonara/aperture_macros/primitive.py
@@ -48,7 +48,7 @@ class Primitive:
 
     def to_gerber(self, unit=None):
         return f'{self.code},' + ','.join(
-                getattr(self, field.name).to_gerber(unit) for field in fields(self) if field.name != 'unit')
+                getattr(self, field.name).optimized().to_gerber(unit) for field in fields(self) if field.name != 'unit')
 
     def __str__(self):
         attrs = ','.join(str(getattr(self, name)).strip('<>') for name in type(self).__annotations__)
@@ -253,6 +253,9 @@ class Outline(Primitive):
         object.__setattr__(self, 'exposure', expr(self.exposure))
 
         if self.length.calculate() != len(self.coords)//2-1:
+            print(self.length, self.length.calculate(), len(self.coords))
+            import pprint
+            pprint.pprint(self.coords)
             raise ValueError('length must exactly equal number of segments, which is the number of points minus one')
 
         if self.coords[-2:] != self.coords[:2]:
@@ -289,8 +292,8 @@ class Outline(Primitive):
 
             rotation = ConstantExpression(0)
 
-        coords = ','.join(coord.to_gerber(unit) for coord in coords)
-        return f'{self.code},{self.exposure.to_gerber()},{len(self.coords)//2-1},{coords},{rotation.to_gerber()}'
+        coords = ','.join(coord.optimized().to_gerber(unit) for coord in coords)
+        return f'{self.code},{self.exposure.optimized().to_gerber()},{len(self.coords)//2-1},{coords},{rotation.to_gerber()}'
 
     def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
         with self.Calculator(self, variable_binding, unit) as calc: