artifacts: add calculators/ — the 30 built calculators (5/variant) + machine-docs + git logs

calculators/builder-adversary-lean/run-02/calc/evaluator.py

@@ -0,0 +1,37 @@
+from calc.parser import Num, BinOp, Unary
+
+
+class EvalError(Exception):
+    pass
+
+
+def evaluate(node):
+    """Walk the AST and return int | float.
+
+    Whole-valued results (including whole-valued division) are returned as int;
+    non-whole float results are returned as float.
+    """
+    if isinstance(node, Num):
+        return node.value
+    if isinstance(node, Unary):
+        if node.op == '-':
+            return -evaluate(node.operand)
+        raise EvalError(f"unknown unary op {node.op!r}")
+    if isinstance(node, BinOp):
+        left = evaluate(node.left)
+        right = evaluate(node.right)
+        if node.op == '+':
+            return left + right
+        if node.op == '-':
+            return left - right
+        if node.op == '*':
+            return left * right
+        if node.op == '/':
+            if right == 0:
+                raise EvalError("division by zero")
+            result = left / right
+            if result == int(result):
+                return int(result)
+            return result
+        raise EvalError(f"unknown binary op {node.op!r}")
+    raise EvalError(f"unknown node type {type(node).__name__!r}")

calculators/builder-adversary-lean/run-02/calc/lexer.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from typing import Union
+
+
+class LexError(Exception):
+    pass
+
+
+@dataclass
+class Token:
+    kind: str
+    value: Union[int, float, str, None]
+
+
+def tokenize(src: str) -> list:
+    tokens = []
+    i = 0
+    while i < len(src):
+        ch = src[i]
+        if ch in ' \t':
+            i += 1
+        elif ch == '+':
+            tokens.append(Token('PLUS', '+'))
+            i += 1
+        elif ch == '-':
+            tokens.append(Token('MINUS', '-'))
+            i += 1
+        elif ch == '*':
+            tokens.append(Token('STAR', '*'))
+            i += 1
+        elif ch == '/':
+            tokens.append(Token('SLASH', '/'))
+            i += 1
+        elif ch == '(':
+            tokens.append(Token('LPAREN', '('))
+            i += 1
+        elif ch == ')':
+            tokens.append(Token('RPAREN', ')'))
+            i += 1
+        elif ch.isdigit() or ch == '.':
+            j = i
+            while j < len(src) and (src[j].isdigit() or src[j] == '.'):
+                j += 1
+            raw = src[i:j]
+            try:
+                value = float(raw) if '.' in raw else int(raw)
+            except ValueError:
+                raise LexError(f"invalid number literal {raw!r} at position {i}")
+            tokens.append(Token('NUMBER', value))
+            i = j
+        else:
+            raise LexError(f"unexpected character {ch!r} at position {i}")
+    tokens.append(Token('EOF', None))
+    return tokens

calculators/builder-adversary-lean/run-02/calc/parser.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+from typing import Union
+
+from calc.lexer import Token
+
+
+class ParseError(Exception):
+    pass
+
+
+@dataclass
+class Num:
+    value: Union[int, float]
+
+
+@dataclass
+class BinOp:
+    op: str
+    left: object
+    right: object
+
+
+@dataclass
+class Unary:
+    op: str
+    operand: object
+
+
+Node = Union[Num, BinOp, Unary]
+
+
+class _Parser:
+    def __init__(self, tokens: list):
+        self._tokens = tokens
+        self._pos = 0
+
+    def _peek(self) -> Token:
+        return self._tokens[self._pos]
+
+    def _consume(self, kind: str = None) -> Token:
+        tok = self._tokens[self._pos]
+        if kind and tok.kind != kind:
+            raise ParseError(f"expected {kind!r}, got {tok.kind!r} ({tok.value!r})")
+        self._pos += 1
+        return tok
+
+    def parse(self) -> Node:
+        if self._peek().kind == 'EOF':
+            raise ParseError("empty input")
+        node = self._expr()
+        if self._peek().kind != 'EOF':
+            tok = self._peek()
+            raise ParseError(f"unexpected token {tok.kind!r} ({tok.value!r})")
+        return node
+
+    def _expr(self) -> Node:
+        node = self._term()
+        while self._peek().kind in ('PLUS', 'MINUS'):
+            op = self._consume().value
+            node = BinOp(op, node, self._term())
+        return node
+
+    def _term(self) -> Node:
+        node = self._unary()
+        while self._peek().kind in ('STAR', 'SLASH'):
+            op = self._consume().value
+            node = BinOp(op, node, self._unary())
+        return node
+
+    def _unary(self) -> Node:
+        if self._peek().kind == 'MINUS':
+            self._consume()
+            return Unary('-', self._unary())
+        return self._primary()
+
+    def _primary(self) -> Node:
+        tok = self._peek()
+        if tok.kind == 'NUMBER':
+            self._consume()
+            return Num(tok.value)
+        if tok.kind == 'LPAREN':
+            self._consume()
+            node = self._expr()
+            if self._peek().kind != 'RPAREN':
+                raise ParseError(f"unclosed parenthesis, got {self._peek().kind!r}")
+            self._consume()
+            return node
+        raise ParseError(f"unexpected token {tok.kind!r} ({tok.value!r})")
+
+
+def parse(tokens: list) -> Node:
+    return _Parser(tokens).parse()

calculators/builder-adversary-lean/run-02/calc/test_evaluator.py

@@ -0,0 +1,134 @@
+import subprocess
+import sys
+import unittest
+
+from calc.evaluator import EvalError, evaluate
+from calc.lexer import tokenize
+from calc.parser import parse
+
+
+def calc(s):
+    return evaluate(parse(tokenize(s)))
+
+
+class TestD1Arithmetic(unittest.TestCase):
+    def test_add_mul_precedence(self):
+        self.assertEqual(calc("2+3*4"), 14)
+
+    def test_parens(self):
+        self.assertEqual(calc("(2+3)*4"), 20)
+
+    def test_left_assoc_sub(self):
+        self.assertEqual(calc("8-3-2"), 3)
+
+    def test_unary_minus_add(self):
+        self.assertEqual(calc("-2+5"), 3)
+
+    def test_mul_unary(self):
+        self.assertEqual(calc("2*-3"), -6)
+
+    def test_basic_add(self):
+        self.assertEqual(calc("1+1"), 2)
+
+    def test_basic_sub(self):
+        self.assertEqual(calc("5-3"), 2)
+
+    def test_basic_mul(self):
+        self.assertEqual(calc("3*4"), 12)
+
+    def test_nested_parens(self):
+        self.assertEqual(calc("((2+3))"), 5)
+
+    def test_unary_only(self):
+        self.assertEqual(calc("-5"), -5)
+
+    def test_double_unary(self):
+        self.assertEqual(calc("--5"), 5)
+
+
+class TestD2Division(unittest.TestCase):
+    def test_true_division(self):
+        self.assertAlmostEqual(calc("7/2"), 3.5)
+
+    def test_div_by_zero_raises(self):
+        with self.assertRaises(EvalError):
+            calc("1/0")
+
+    def test_div_by_zero_not_zdiv_error(self):
+        try:
+            calc("1/0")
+            self.fail("expected EvalError")
+        except EvalError:
+            pass
+        except ZeroDivisionError:
+            self.fail("bare ZeroDivisionError escaped the API")
+
+    def test_div_integer(self):
+        self.assertEqual(calc("6/3"), 2)
+
+
+class TestD3ResultType(unittest.TestCase):
+    def test_whole_div_no_dot_zero(self):
+        result = calc("4/2")
+        self.assertEqual(result, 2)
+        self.assertIsInstance(result, int)
+
+    def test_nonwhole_div_is_float(self):
+        result = calc("7/2")
+        self.assertIsInstance(result, float)
+        self.assertAlmostEqual(result, 3.5)
+
+    def test_int_add_is_int(self):
+        result = calc("2+3")
+        self.assertIsInstance(result, int)
+
+    def test_str_whole_result(self):
+        self.assertEqual(str(calc("4/2")), "2")
+
+    def test_str_float_result(self):
+        self.assertEqual(str(calc("7/2")), "3.5")
+
+
+class TestD4CLI(unittest.TestCase):
+    def _run(self, expr):
+        return subprocess.run(
+            [sys.executable, "calc.py", expr],
+            capture_output=True,
+            text=True,
+        )
+
+    def test_basic_expr(self):
+        r = self._run("2+3*4")
+        self.assertEqual(r.returncode, 0)
+        self.assertEqual(r.stdout.strip(), "14")
+
+    def test_parens_expr(self):
+        r = self._run("(2+3)*4")
+        self.assertEqual(r.returncode, 0)
+        self.assertEqual(r.stdout.strip(), "20")
+
+    def test_float_div(self):
+        r = self._run("7/2")
+        self.assertEqual(r.returncode, 0)
+        self.assertEqual(r.stdout.strip(), "3.5")
+
+    def test_whole_div_no_dot(self):
+        r = self._run("4/2")
+        self.assertEqual(r.returncode, 0)
+        self.assertEqual(r.stdout.strip(), "2")
+
+    def test_div_by_zero_nonzero_exit(self):
+        r = self._run("1/0")
+        self.assertNotEqual(r.returncode, 0)
+        self.assertGreater(len(r.stderr), 0)
+        self.assertEqual(r.stdout, "")
+
+    def test_invalid_expr_nonzero_exit(self):
+        r = self._run("1 +")
+        self.assertNotEqual(r.returncode, 0)
+        self.assertGreater(len(r.stderr), 0)
+        self.assertEqual(r.stdout, "")
+
+
+if __name__ == '__main__':
+    unittest.main()

calculators/builder-adversary-lean/run-02/calc/test_lexer.py

@@ -0,0 +1,94 @@
+import unittest
+from calc.lexer import tokenize, Token, LexError
+
+
+def kinds(src):
+    return [t.kind for t in tokenize(src)]
+
+
+def tok(src):
+    return [(t.kind, t.value) for t in tokenize(src)]
+
+
+class TestNumbers(unittest.TestCase):
+    def test_integer(self):
+        result = tokenize("42")
+        self.assertEqual(result[0], Token('NUMBER', 42))
+        self.assertEqual(result[1], Token('EOF', None))
+        self.assertIsInstance(result[0].value, int)
+
+    def test_float(self):
+        result = tokenize("3.14")
+        self.assertEqual(result[0].kind, 'NUMBER')
+        self.assertAlmostEqual(result[0].value, 3.14)
+        self.assertIsInstance(result[0].value, float)
+
+    def test_leading_dot(self):
+        result = tokenize(".5")
+        self.assertEqual(result[0].kind, 'NUMBER')
+        self.assertAlmostEqual(result[0].value, 0.5)
+
+    def test_trailing_dot(self):
+        result = tokenize("10.")
+        self.assertEqual(result[0].kind, 'NUMBER')
+        self.assertAlmostEqual(result[0].value, 10.0)
+        self.assertIsInstance(result[0].value, float)
+
+
+class TestOperatorsAndParens(unittest.TestCase):
+    def test_plus(self):
+        self.assertIn(Token('PLUS', '+'), tokenize("+"))
+
+    def test_minus(self):
+        self.assertIn(Token('MINUS', '-'), tokenize("-"))
+
+    def test_star(self):
+        self.assertIn(Token('STAR', '*'), tokenize("*"))
+
+    def test_slash(self):
+        self.assertIn(Token('SLASH', '/'), tokenize("/"))
+
+    def test_lparen(self):
+        self.assertIn(Token('LPAREN', '('), tokenize("("))
+
+    def test_rparen(self):
+        self.assertIn(Token('RPAREN', ')'), tokenize(")"))
+
+    def test_sequence(self):
+        self.assertEqual(kinds("1+2*3"),
+                         ['NUMBER', 'PLUS', 'NUMBER', 'STAR', 'NUMBER', 'EOF'])
+
+
+class TestWhitespaceAndErrors(unittest.TestCase):
+    def test_whitespace_skipped(self):
+        self.assertEqual(kinds("  12  +  3 "),
+                         ['NUMBER', 'PLUS', 'NUMBER', 'EOF'])
+
+    def test_tab_skipped(self):
+        self.assertEqual(kinds("1\t+\t2"), ['NUMBER', 'PLUS', 'NUMBER', 'EOF'])
+
+    def test_complex_expr(self):
+        self.assertEqual(kinds("3.5*(1-2)"),
+                         ['NUMBER', 'STAR', 'LPAREN', 'NUMBER', 'MINUS', 'NUMBER', 'RPAREN', 'EOF'])
+
+    def test_lex_error_at_sign(self):
+        with self.assertRaises(LexError) as ctx:
+            tokenize("1 @ 2")
+        self.assertIn('@', str(ctx.exception))
+
+    def test_lex_error_dollar(self):
+        with self.assertRaises(LexError):
+            tokenize("$")
+
+    def test_lex_error_letter(self):
+        with self.assertRaises(LexError):
+            tokenize("abc")
+
+    def test_lex_error_position(self):
+        with self.assertRaises(LexError) as ctx:
+            tokenize("1 @ 2")
+        self.assertIn('2', str(ctx.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

calculators/builder-adversary-lean/run-02/calc/test_parser.py

@@ -0,0 +1,103 @@
+import unittest
+from calc.lexer import tokenize
+from calc.parser import parse, ParseError, Num, BinOp, Unary
+
+
+def p(src):
+    return parse(tokenize(src))
+
+
+class TestPrecedence(unittest.TestCase):
+    def test_mul_binds_tighter_than_add(self):
+        # 1+2*3 => BinOp(+, Num(1), BinOp(*, Num(2), Num(3)))
+        tree = p('1+2*3')
+        self.assertEqual(tree, BinOp('+', Num(1), BinOp('*', Num(2), Num(3))))
+
+    def test_div_binds_tighter_than_sub(self):
+        # 6-4/2 => BinOp(-, Num(6), BinOp(/, Num(4), Num(2)))
+        tree = p('6-4/2')
+        self.assertEqual(tree, BinOp('-', Num(6), BinOp('/', Num(4), Num(2))))
+
+    def test_mul_binds_tighter_than_sub(self):
+        tree = p('5-2*3')
+        self.assertEqual(tree, BinOp('-', Num(5), BinOp('*', Num(2), Num(3))))
+
+
+class TestLeftAssociativity(unittest.TestCase):
+    def test_sub_left_assoc(self):
+        # 8-3-2 => BinOp(-, BinOp(-, Num(8), Num(3)), Num(2))
+        tree = p('8-3-2')
+        self.assertEqual(tree, BinOp('-', BinOp('-', Num(8), Num(3)), Num(2)))
+
+    def test_div_left_assoc(self):
+        # 8/4/2 => BinOp(/, BinOp(/, Num(8), Num(4)), Num(2))
+        tree = p('8/4/2')
+        self.assertEqual(tree, BinOp('/', BinOp('/', Num(8), Num(4)), Num(2)))
+
+    def test_add_left_assoc(self):
+        tree = p('1+2+3')
+        self.assertEqual(tree, BinOp('+', BinOp('+', Num(1), Num(2)), Num(3)))
+
+    def test_mul_left_assoc(self):
+        tree = p('2*3*4')
+        self.assertEqual(tree, BinOp('*', BinOp('*', Num(2), Num(3)), Num(4)))
+
+
+class TestParentheses(unittest.TestCase):
+    def test_parens_override_precedence(self):
+        # (1+2)*3 => BinOp(*, BinOp(+, Num(1), Num(2)), Num(3))
+        tree = p('(1+2)*3')
+        self.assertEqual(tree, BinOp('*', BinOp('+', Num(1), Num(2)), Num(3)))
+
+    def test_nested_parens(self):
+        tree = p('((2+3))')
+        self.assertEqual(tree, BinOp('+', Num(2), Num(3)))
+
+    def test_parens_right_side(self):
+        tree = p('3*(1+2)')
+        self.assertEqual(tree, BinOp('*', Num(3), BinOp('+', Num(1), Num(2))))
+
+
+class TestUnaryMinus(unittest.TestCase):
+    def test_simple_unary(self):
+        tree = p('-5')
+        self.assertEqual(tree, Unary('-', Num(5)))
+
+    def test_unary_paren(self):
+        tree = p('-(1+2)')
+        self.assertEqual(tree, Unary('-', BinOp('+', Num(1), Num(2))))
+
+    def test_mul_unary(self):
+        # 3 * -2 => BinOp(*, Num(3), Unary(-, Num(2)))
+        tree = p('3 * -2')
+        self.assertEqual(tree, BinOp('*', Num(3), Unary('-', Num(2))))
+
+    def test_double_unary(self):
+        tree = p('--5')
+        self.assertEqual(tree, Unary('-', Unary('-', Num(5))))
+
+
+class TestErrors(unittest.TestCase):
+    def test_trailing_op(self):
+        with self.assertRaises(ParseError):
+            p('1 +')
+
+    def test_unclosed_paren(self):
+        with self.assertRaises(ParseError):
+            p('(1')
+
+    def test_two_numbers(self):
+        with self.assertRaises(ParseError):
+            p('1 2')
+
+    def test_close_before_open(self):
+        with self.assertRaises(ParseError):
+            p(')(')
+
+    def test_empty_string(self):
+        with self.assertRaises(ParseError):
+            p('')
+
+
+if __name__ == '__main__':
+    unittest.main()