design notes

doc/design/pyparsing.ipynb

@@ -0,0 +1,434 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!pip install pyparsing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# fourFn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyparsing import (\n",
+    "    Literal,\n",
+    "    Word,\n",
+    "    Group,\n",
+    "    Forward,\n",
+    "    alphas,\n",
+    "    alphanums,\n",
+    "    Regex,\n",
+    "    ParseException,\n",
+    "    CaselessKeyword,\n",
+    "    Suppress,\n",
+    "    delimitedList,\n",
+    ")\n",
+    "import math\n",
+    "import operator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exprStack = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def push_first(toks):\n",
+    "    exprStack.append(toks[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def push_unary_minus(toks):\n",
+    "    for t in toks:\n",
+    "        if t == \"-\":\n",
+    "            exprStack.append(\"unary -\")\n",
+    "        else:\n",
+    "            break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bnf = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def BNF():\n",
+    "    \"\"\"\n",
+    "    expop   :: '^'\n",
+    "    multop  :: '*' | '/'\n",
+    "    addop   :: '+' | '-'\n",
+    "    integer :: ['+' | '-'] '0'..'9'+\n",
+    "    atom    :: PI | E | real | fn '(' expr ')' | '(' expr ')'\n",
+    "    factor  :: atom [ expop factor ]*\n",
+    "    term    :: factor [ multop factor ]*\n",
+    "    expr    :: term [ addop term ]*\n",
+    "    \"\"\"\n",
+    "    global bnf\n",
+    "    if not bnf:\n",
+    "        # use CaselessKeyword for e and pi, to avoid accidentally matching\n",
+    "        # functions that start with 'e' or 'pi' (such as 'exp'); Keyword\n",
+    "        # and CaselessKeyword only match whole words\n",
+    "        e = CaselessKeyword(\"E\")\n",
+    "        pi = CaselessKeyword(\"PI\")\n",
+    "        # fnumber = Combine(Word(\"+-\"+nums, nums) +\n",
+    "        #                    Optional(\".\" + Optional(Word(nums))) +\n",
+    "        #                    Optional(e + Word(\"+-\"+nums, nums)))\n",
+    "        # or use provided pyparsing_common.number, but convert back to str:\n",
+    "        # fnumber = ppc.number().addParseAction(lambda t: str(t[0]))\n",
+    "        fnumber = Regex(r\"[+-]?\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?\")\n",
+    "        ident = Word(alphas, alphanums + \"_$\")\n",
+    "\n",
+    "        plus, minus, mult, div = map(Literal, \"+-*/\")\n",
+    "        lpar, rpar = map(Suppress, \"()\")\n",
+    "        addop = plus | minus\n",
+    "        multop = mult | div\n",
+    "        expop = Literal(\"^\")\n",
+    "\n",
+    "        expr = Forward()\n",
+    "        expr_list = delimitedList(Group(expr))\n",
+    "        # add parse action that replaces the function identifier with a (name, number of args) tuple\n",
+    "        def insert_fn_argcount_tuple(t):\n",
+    "            fn = t.pop(0)\n",
+    "            num_args = len(t[0])\n",
+    "            t.insert(0, (fn, num_args))\n",
+    "\n",
+    "        fn_call = (ident + lpar - Group(expr_list) + rpar).setParseAction(\n",
+    "            insert_fn_argcount_tuple\n",
+    "        )\n",
+    "        atom = (\n",
+    "            addop[...]\n",
+    "            + (\n",
+    "                (fn_call | pi | e | fnumber | ident).setParseAction(push_first)\n",
+    "                | Group(lpar + expr + rpar)\n",
+    "            )\n",
+    "        ).setParseAction(push_unary_minus)\n",
+    "\n",
+    "        # by defining exponentiation as \"atom [ ^ factor ]...\" instead of \"atom [ ^ atom ]...\", we get right-to-left\n",
+    "        # exponents, instead of left-to-right that is, 2^3^2 = 2^(3^2), not (2^3)^2.\n",
+    "        factor = Forward()\n",
+    "        factor <<= atom + (expop + factor).setParseAction(push_first)[...]\n",
+    "        term = factor + (multop + factor).setParseAction(push_first)[...]\n",
+    "        expr <<= term + (addop + term).setParseAction(push_first)[...]\n",
+    "        bnf = expr\n",
+    "    return bnf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# map operator symbols to corresponding arithmetic operations\n",
+    "epsilon = 1e-12\n",
+    "opn = {\n",
+    "    \"+\": operator.add,\n",
+    "    \"-\": operator.sub,\n",
+    "    \"*\": operator.mul,\n",
+    "    \"/\": operator.truediv,\n",
+    "    \"^\": operator.pow,\n",
+    "}\n",
+    "\n",
+    "fn = {\n",
+    "    \"sin\": math.sin,\n",
+    "    \"cos\": math.cos,\n",
+    "    \"tan\": math.tan,\n",
+    "    \"exp\": math.exp,\n",
+    "    \"abs\": abs,\n",
+    "    \"trunc\": int,\n",
+    "    \"round\": round,\n",
+    "    \"sgn\": lambda a: -1 if a < -epsilon else 1 if a > epsilon else 0,\n",
+    "    # functionsl with multiple arguments\n",
+    "    \"multiply\": lambda a, b: a * b,\n",
+    "    \"hypot\": math.hypot,\n",
+    "    # functions with a variable number of arguments\n",
+    "    \"all\": lambda *a: all(a),\n",
+    "    \"Circle\": lambda x,y,r: f\"center=({x},{y}),radius={r}\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate_stack(s):\n",
+    "    op, num_args = s.pop(), 0\n",
+    "    if isinstance(op, tuple):\n",
+    "        op, num_args = op\n",
+    "    if op == \"unary -\":\n",
+    "        return -evaluate_stack(s)\n",
+    "    if op in \"+-*/^\":\n",
+    "        # note: operands are pushed onto the stack in reverse order\n",
+    "        op2 = evaluate_stack(s)\n",
+    "        op1 = evaluate_stack(s)\n",
+    "        return opn[op](op1, op2)\n",
+    "    elif op == \"PI\":\n",
+    "        return math.pi  # 3.1415926535\n",
+    "    elif op == \"E\":\n",
+    "        return math.e  # 2.718281828\n",
+    "    elif op in fn:\n",
+    "        # note: args are pushed onto the stack in reverse order\n",
+    "        args = reversed([evaluate_stack(s) for _ in range(num_args)])\n",
+    "        return fn[op](*args)\n",
+    "    elif op[0].isalpha():\n",
+    "        raise Exception(\"invalid identifier '%s'\" % op)\n",
+    "    else:\n",
+    "        # try to evaluate as int first, then as float if int fails\n",
+    "        try:\n",
+    "            return int(op)\n",
+    "        except ValueError:\n",
+    "            return float(op)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test(s, expected):\n",
+    "    exprStack[:] = []\n",
+    "    try:\n",
+    "        results = BNF().parseString(s, parseAll=True)\n",
+    "        val = evaluate_stack(exprStack[:])\n",
+    "    except ParseException as pe:\n",
+    "        print(s, \"failed parse:\", str(pe))\n",
+    "    except Exception as e:\n",
+    "        print(s, \"failed eval:\", str(e), exprStack)\n",
+    "    else:\n",
+    "        if val == expected:\n",
+    "            print(s, \"=\", val, results, \"=>\", exprStack)\n",
+    "        else:\n",
+    "            print(s + \"!!!\", val, \"!=\", expected, results, \"=>\", exprStack)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9 = 9 ['9'] => ['9']\n",
+      "-9 = -9 ['-', '9'] => ['9', 'unary -']\n",
+      "--9 = 9 ['-', '-', '9'] => ['9', 'unary -', 'unary -']\n",
+      "-E = -2.718281828459045 ['-', 'E'] => ['E', 'unary -']\n",
+      "9 + 3 + 6 = 18 ['9', '+', '3', '+', '6'] => ['9', '3', '+', '6', '+']\n",
+      "9 + 3 / 11 = 9.272727272727273 ['9', '+', '3', '/', '11'] => ['9', '3', '11', '/', '+']\n",
+      "(9 + 3) = 12 [['9', '+', '3']] => ['9', '3', '+']\n",
+      "(9+3) / 11 = 1.0909090909090908 [['9', '+', '3'], '/', '11'] => ['9', '3', '+', '11', '/']\n",
+      "9 - 12 - 6 = -9 ['9', '-', '12', '-', '6'] => ['9', '12', '-', '6', '-']\n",
+      "9 - (12 - 6) = 3 ['9', '-', ['12', '-', '6']] => ['9', '12', '6', '-', '-']\n",
+      "2*3.14159 = 6.28318 ['2', '*', '3.14159'] => ['2', '3.14159', '*']\n",
+      "3.1415926535*3.1415926535 / 10 = 0.9869604400525172 ['3.1415926535', '*', '3.1415926535', '/', '10'] => ['3.1415926535', '3.1415926535', '*', '10', '/']\n",
+      "PI * PI / 10 = 0.9869604401089358 ['PI', '*', 'PI', '/', '10'] => ['PI', 'PI', '*', '10', '/']\n",
+      "PI*PI/10 = 0.9869604401089358 ['PI', '*', 'PI', '/', '10'] => ['PI', 'PI', '*', '10', '/']\n",
+      "PI^2 = 9.869604401089358 ['PI', '^', '2'] => ['PI', '2', '^']\n",
+      "round(PI^2) = 10 [('round', 1), [['PI', '^', '2']]] => ['PI', '2', '^', ('round', 1)]\n",
+      "6.02E23 * 8.048 = 4.844896e+24 ['6.02E23', '*', '8.048'] => ['6.02E23', '8.048', '*']\n",
+      "e / 3 = 0.9060939428196817 ['E', '/', '3'] => ['E', '3', '/']\n",
+      "sin(PI/2) = 1.0 [('sin', 1), [['PI', '/', '2']]] => ['PI', '2', '/', ('sin', 1)]\n",
+      "10+sin(PI/4)^2 = 10.5 ['10', '+', ('sin', 1), [['PI', '/', '4']], '^', '2'] => ['10', 'PI', '4', '/', ('sin', 1), '2', '^', '+']\n",
+      "trunc(E) = 2 [('trunc', 1), [['E']]] => ['E', ('trunc', 1)]\n",
+      "trunc(-E) = -2 [('trunc', 1), [['-', 'E']]] => ['E', 'unary -', ('trunc', 1)]\n",
+      "round(E) = 3 [('round', 1), [['E']]] => ['E', ('round', 1)]\n",
+      "round(-E) = -3 [('round', 1), [['-', 'E']]] => ['E', 'unary -', ('round', 1)]\n",
+      "E^PI = 23.140692632779263 ['E', '^', 'PI'] => ['E', 'PI', '^']\n",
+      "exp(0) = 1.0 [('exp', 1), [['0']]] => ['0', ('exp', 1)]\n",
+      "exp(1) = 2.718281828459045 [('exp', 1), [['1']]] => ['1', ('exp', 1)]\n",
+      "2^3^2 = 512 ['2', '^', '3', '^', '2'] => ['2', '3', '2', '^', '^']\n",
+      "(2^3)^2 = 64 [['2', '^', '3'], '^', '2'] => ['2', '3', '^', '2', '^']\n",
+      "2^3+2 = 10 ['2', '^', '3', '+', '2'] => ['2', '3', '^', '2', '+']\n",
+      "2^3+5 = 13 ['2', '^', '3', '+', '5'] => ['2', '3', '^', '5', '+']\n",
+      "2^9 = 512 ['2', '^', '9'] => ['2', '9', '^']\n",
+      "sgn(-2) = -1 [('sgn', 1), [['-', '2']]] => ['2', 'unary -', ('sgn', 1)]\n",
+      "sgn(0) = 0 [('sgn', 1), [['0']]] => ['0', ('sgn', 1)]\n",
+      "sgn(0.1) = 1 [('sgn', 1), [['0.1']]] => ['0.1', ('sgn', 1)]\n",
+      "foo(0.1) failed eval: invalid identifier 'foo' ['0.1', ('foo', 1)]\n",
+      "round(E, 3) = 2.718 [('round', 2), [['E'], ['3']]] => ['E', '3', ('round', 2)]\n",
+      "round(PI^2, 3) = 9.87 [('round', 2), [['PI', '^', '2'], ['3']]] => ['PI', '2', '^', '3', ('round', 2)]\n",
+      "sgn(cos(PI/4)) = 1 [('sgn', 1), [[('cos', 1), [['PI', '/', '4']]]]] => ['PI', '4', '/', ('cos', 1), ('sgn', 1)]\n",
+      "sgn(cos(PI/2)) = 0 [('sgn', 1), [[('cos', 1), [['PI', '/', '2']]]]] => ['PI', '2', '/', ('cos', 1), ('sgn', 1)]\n",
+      "sgn(cos(PI*3/4)) = -1 [('sgn', 1), [[('cos', 1), [['PI', '*', '3', '/', '4']]]]] => ['PI', '3', '*', '4', '/', ('cos', 1), ('sgn', 1)]\n",
+      "+(sgn(cos(PI/4))) = 1 ['+', [('sgn', 1), [[('cos', 1), [['PI', '/', '4']]]]]] => ['PI', '4', '/', ('cos', 1), ('sgn', 1)]\n",
+      "-(sgn(cos(PI/4))) = -1 ['-', [('sgn', 1), [[('cos', 1), [['PI', '/', '4']]]]]] => ['PI', '4', '/', ('cos', 1), ('sgn', 1), 'unary -']\n",
+      "hypot(3, 4) = 5.0 [('hypot', 2), [['3'], ['4']]] => ['3', '4', ('hypot', 2)]\n",
+      "multiply(3, 7) = 21 [('multiply', 2), [['3'], ['7']]] => ['3', '7', ('multiply', 2)]\n",
+      "all(1,1,1) = True [('all', 3), [['1'], ['1'], ['1']]] => ['1', '1', '1', ('all', 3)]\n",
+      "all(1,1,1,1,1,0) = False [('all', 6), [['1'], ['1'], ['1'], ['1'], ['1'], ['0']]] => ['1', '1', '1', '1', '1', '0', ('all', 6)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "test(\"9\", 9)\n",
+    "test(\"-9\", -9)\n",
+    "test(\"--9\", 9)\n",
+    "test(\"-E\", -math.e)\n",
+    "test(\"9 + 3 + 6\", 9 + 3 + 6)\n",
+    "test(\"9 + 3 / 11\", 9 + 3.0 / 11)\n",
+    "test(\"(9 + 3)\", (9 + 3))\n",
+    "test(\"(9+3) / 11\", (9 + 3.0) / 11)\n",
+    "test(\"9 - 12 - 6\", 9 - 12 - 6)\n",
+    "test(\"9 - (12 - 6)\", 9 - (12 - 6))\n",
+    "test(\"2*3.14159\", 2 * 3.14159)\n",
+    "test(\"3.1415926535*3.1415926535 / 10\", 3.1415926535 * 3.1415926535 / 10)\n",
+    "test(\"PI * PI / 10\", math.pi * math.pi / 10)\n",
+    "test(\"PI*PI/10\", math.pi * math.pi / 10)\n",
+    "test(\"PI^2\", math.pi ** 2)\n",
+    "test(\"round(PI^2)\", round(math.pi ** 2))\n",
+    "test(\"6.02E23 * 8.048\", 6.02e23 * 8.048)\n",
+    "test(\"e / 3\", math.e / 3)\n",
+    "test(\"sin(PI/2)\", math.sin(math.pi / 2))\n",
+    "test(\"10+sin(PI/4)^2\", 10 + math.sin(math.pi / 4) ** 2)\n",
+    "test(\"trunc(E)\", int(math.e))\n",
+    "test(\"trunc(-E)\", int(-math.e))\n",
+    "test(\"round(E)\", round(math.e))\n",
+    "test(\"round(-E)\", round(-math.e))\n",
+    "test(\"E^PI\", math.e ** math.pi)\n",
+    "test(\"exp(0)\", 1)\n",
+    "test(\"exp(1)\", math.e)\n",
+    "test(\"2^3^2\", 2 ** 3 ** 2)\n",
+    "test(\"(2^3)^2\", (2 ** 3) ** 2)\n",
+    "test(\"2^3+2\", 2 ** 3 + 2)\n",
+    "test(\"2^3+5\", 2 ** 3 + 5)\n",
+    "test(\"2^9\", 2 ** 9)\n",
+    "test(\"sgn(-2)\", -1)\n",
+    "test(\"sgn(0)\", 0)\n",
+    "test(\"sgn(0.1)\", 1)\n",
+    "test(\"foo(0.1)\", None)\n",
+    "test(\"round(E, 3)\", round(math.e, 3))\n",
+    "test(\"round(PI^2, 3)\", round(math.pi ** 2, 3))\n",
+    "test(\"sgn(cos(PI/4))\", 1)\n",
+    "test(\"sgn(cos(PI/2))\", 0)\n",
+    "test(\"sgn(cos(PI*3/4))\", -1)\n",
+    "test(\"+(sgn(cos(PI/4)))\", 1)\n",
+    "test(\"-(sgn(cos(PI/4)))\", -1)\n",
+    "test(\"hypot(3, 4)\", 5)\n",
+    "test(\"multiply(3, 7)\", 21)\n",
+    "test(\"all(1,1,1)\", True)\n",
+    "test(\"all(1,1,1,1,1,0)\", False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Circle(0,0,5) = center=(0,0),radius=5 [('Circle', 3), [['0'], ['0'], ['5']]] => ['0', '0', '5', ('Circle', 3)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "test(\"Circle(0,0,5)\", \"center=(0,0),radius=5\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Circle(0,1,3)!!! center=(0,1),radius=3 != center=(0,0),radius=5 [('Circle', 3), [['0'], ['1'], ['3']]] => ['0', '1', '3', ('Circle', 3)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "test(\"Circle(0,1,3)\", \"center=(0,0),radius=5\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A=3\n",
+    "N=4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "N*A/5 failed eval: invalid identifier 'A' ['N', 'A', '*', '5', '/']\n"
+     ]
+    }
+   ],
+   "source": [
+    "test(\"N*A/5\",12/5)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

doc/design/readme.md

@@ -0,0 +1,14 @@
+# Design Notes
+
+# Alternatives Drawing Libraries
+   
+   Instead of Matplotlib, the following libraries could be used
+   
+   - Casey Duckering [drawSvg](https://github.com/cduck/drawSvg)
+   - Martin Renou [ipycanvas](https://github.com/martinRenou/ipycanvas)
+
+# Parsing yaml files expressions
+
+   In a point of time, we need to verify the syntax of yaml sketch definition, here are some parser which might help
+   
+   - Paul McGuire [pyparsing](https://github.com/pyparsing/pyparsing)

notebooks/Reference.ipynb

@@ -303,8 +303,7 @@
     "triangle: Triangle(p1=(W/2,0), p2=(3*W/2,W/2), p3=(4*W/5.,L))\n",
     "\"\"\"\n",
     "drawing_tool.erase()\n",
-    "sketchParse(tria\n",
-    "            ngle,myfig)\n",
+    "sketchParse(triangle,myfig)\n",
     "# replace 'object' by the actual one\n",
     "d = myfig['triangle'].draw() \n",
     "drawing_tool.display()\n",