{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# DDA walkthrought example: Chua attractor\n", "\n", "What follows is an example of the Chua attractor. It is described in the [Analog Paradigm Application Note 3](http://analogparadigm.com/downloads/alpaca_3.pdf) as well as in section 6.15 in Bernd's new book (Analog Programming II). The attractor is described by a coupled set of three ordinary differential equations,\n", "\n", "$$\n", " \\dot x = c_1 (y-x-f(x)) \\\\\n", " \\dot y = c_2 (x-y+z) \\\\\n", " \\dot z = -c_3 y\n", "$$\n", "\n", "with $f(x)$ a simple function decribing the Chua diode (given algebraically) and a number of parameters $c_{1,2,3}$. What follows is the scaling of these equations. The resulting set of equations is slightly more verbose. It's implementation is given in the following *traditional DDA* file:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#\r\n", "# Copyright (c) 2020 anabrid GmbH\r\n", "# Contact: https://www.anabrid.com/licensing/\r\n", "#\r\n", "# This file is part of the examples of the PyAnalog toolkit.\r\n", "#\r\n", "# ANABRID_BEGIN_LICENSE:GPL\r\n", "# Commercial License Usage\r\n", "# Licensees holding valid commercial anabrid licenses may use this file in\r\n", "# accordance with the commercial license agreement provided with the\r\n", "# Software or, alternatively, in accordance with the terms contained in\r\n", "# a written agreement between you and Anabrid GmbH. For licensing terms\r\n", "# and conditions see https://www.anabrid.com/licensing. For further\r\n", "# information use the contact form at https://www.anabrid.com/contact.\r\n", "# \r\n", "# GNU General Public License Usage\r\n", "# Alternatively, this file may be used under the terms of the GNU \r\n", "# General Public License version 3 as published by the Free Software\r\n", "# Foundation and appearing in the file LICENSE.GPL3 included in the\r\n", "# packaging of this file. Please review the following information to\r\n", "# ensure the GNU General Public License version 3 requirements\r\n", "# will be met: https://www.gnu.org/licenses/gpl-3.0.html.\r\n", "# ANABRID_END_LICENSE\r\n", "#\r\n", "\r\n", "\r\n", "# Chua attractor, chapter 6.15 from Bernds book ap2.pdf\r\n", "# Below is the scaled version (equations 6.40-6.51)\r\n", "\r\n", "x0 = const(0.1)\r\n", "x1 = mult(-10, neg(sum(x, fx)))\r\n", "x2 = neg(sum(y, mult(0.5, x1)))\r\n", "x = neg(sum(mult(3.12, neg(int(x2, dt, 0))), x0))\r\n", "\r\n", "y1 = neg(sum(z, neg(mult(0.125, y))))\r\n", "y2 = neg(sum(mult(1.25, x), mult(2, y1)))\r\n", "y = mult(4, neg(int(y2, dt, 0)))\r\n", "\r\n", "z = int(mult(3.5, y), dt, 0)\r\n", "\r\n", "f1 = abs(sum(mult(0.7143,x), 0.2857))\r\n", "f2 = abs(sum(mult(0.7143,x), -0.2857))\r\n", "f3 = neg(sum(f1, neg(f2)))\r\n", "fx = sum(mult(0.714, x), mult(0.3003, f3))\r\n", "\r\n", "dt = const(0.001)\r\n" ] } ], "source": [ "!cat chua.dda" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following, we use the PyDDA library to read in this DDA file and demonstrate the internal representation." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "State({'dt': const(0.001),\n", " 'f1': abs(sum(mult(0.7143, x), 0.2857)),\n", " 'f2': abs(sum(mult(0.7143, x), -0.2857)),\n", " 'f3': neg(sum(f1, neg(f2))),\n", " 'fx': sum(mult(0.714, x), mult(0.3003, f3)),\n", " 'x': neg(sum(mult(3.12, neg(int(x2, dt, 0))), x0)),\n", " 'x0': const(0.1),\n", " 'x1': mult(-10, neg(sum(x, fx))),\n", " 'x2': neg(sum(y, mult(0.5, x1))),\n", " 'y': mult(4, neg(int(y2, dt, 0))),\n", " 'y1': neg(sum(z, neg(mult(0.125, y)))),\n", " 'y2': neg(sum(mult(1.25, x), mult(2, y1))),\n", " 'z': int(mult(3.5, y), dt, 0)})" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from dda.dsl import read_traditional_dda\n", "chua_text = open(\"chua.dda\").read()\n", "state = read_traditional_dda(chua_text)\n", "state" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Syntax trees: Down into the rabbit hole" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Obviously, the output of the internal data structure *state* and the DDA file itself does not differ so much. That is by intention, both look quite pythonic. The state itself is basically a dictionary (mapping) from strings (the left hand sides in the DDA file) to the expressions (their right hand sides). Let's inspect such an expression." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int(mult(3.5, y), dt, 0)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "state[\"z\"]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dda.ast.Symbol" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(state[\"z\"])" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "int\n", "(mult(3.5, y), dt, 0)\n" ] } ], "source": [ "print(state[\"z\"].head)\n", "print(state[\"z\"].tail)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What we are actually looking at is the PyDDA-representation of a mathematical expression tree. We can visualize this tree:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "DDA-Symbol\n", "\n", "\n", "\n", "int\n", "\n", "\n", "int\n", "\n", "\n", "\n", "mult\n", "\n", "\n", "mult\n", "\n", "\n", "\n", "int->mult\n", "\n", "\n", "\n", "\n", "\n", "dt\n", "\n", "\n", "dt\n", "\n", "\n", "\n", "int->dt\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "\n", "int->0\n", "\n", "\n", "\n", "\n", "\n", "3.5\n", "\n", "3.5\n", "\n", "\n", "\n", "mult->3.5\n", "\n", "\n", "\n", "\n", "\n", "y\n", "\n", "\n", "y\n", "\n", "\n", "\n", "mult->y\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "state[\"z\"].draw_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Given this, we can compute the dependencies of all variables in the sytem:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "graph = state.draw_dependency_graph(export_dot=False)\n", "graph" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Draw the graph with matlotlib\n", "import networkx as nx\n", "from networkx.drawing.nx_agraph import graphviz_layout\n", "pos = graphviz_layout(graph)\n", "nx.draw(graph, pos=pos)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# draw the graph with graphviz (requires pydot,graphviz)\n", "from networkx.drawing.nx_pydot import to_pydot\n", "from graphviz import Source\n", "nx2dot = lambda graph: Source(to_pydot(graph).to_string())" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "x1\n", "\n", "x1\n", "\n", "\n", "\n", "x\n", "\n", "x\n", "\n", "\n", "\n", "x1->x\n", "\n", "\n", "\n", "\n", "\n", "fx\n", "\n", "fx\n", "\n", "\n", "\n", "x1->fx\n", "\n", "\n", "\n", "\n", "\n", "x2\n", "\n", "x2\n", "\n", "\n", "\n", "x->x2\n", "\n", "\n", "\n", "\n", "\n", "dt\n", "\n", "dt\n", "\n", "\n", "\n", "x->dt\n", "\n", "\n", "\n", "\n", "\n", "x0\n", "\n", "x0\n", "\n", "\n", "\n", "x->x0\n", "\n", "\n", "\n", "\n", "\n", "fx->x\n", "\n", "\n", "\n", "\n", "\n", "f3\n", "\n", "f3\n", "\n", "\n", "\n", "fx->f3\n", "\n", "\n", "\n", "\n", "\n", "x2->x1\n", "\n", "\n", "\n", "\n", "\n", "y\n", "\n", "y\n", "\n", "\n", "\n", "x2->y\n", "\n", "\n", "\n", "\n", "\n", "y->dt\n", "\n", "\n", "\n", "\n", "\n", "y2\n", "\n", "y2\n", "\n", "\n", "\n", "y->y2\n", "\n", "\n", "\n", "\n", "\n", "y1\n", "\n", "y1\n", "\n", "\n", "\n", "y1->y\n", "\n", "\n", "\n", "\n", "\n", "z\n", "\n", "z\n", "\n", "\n", "\n", "y1->z\n", "\n", "\n", "\n", "\n", "\n", "z->y\n", "\n", "\n", "\n", "\n", "\n", "z->dt\n", "\n", "\n", "\n", "\n", "\n", "y2->x\n", "\n", "\n", "\n", "\n", "\n", "y2->y1\n", "\n", "\n", "\n", "\n", "\n", "f1\n", "\n", "f1\n", "\n", "\n", "\n", "f1->x\n", "\n", "\n", "\n", "\n", "\n", "f2\n", "\n", "f2\n", "\n", "\n", "\n", "f2->x\n", "\n", "\n", "\n", "\n", "\n", "f3->f1\n", "\n", "\n", "\n", "\n", "\n", "f3->f2\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nx2dot(graph)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Based on this dependency analysis, one can *linearize* the state, that is, define an ordering how to compute the state numerically:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "vars = state.variable_ordering()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The evolved variables are: ['int_1', 'int_2', 'z']\n", "Auxilliary variables are: ['f1', 'f2', 'f3', 'fx', 'mult_10', 'mult_6', 'mult_9', 'sum_1', 'sum_2', 'sum_3', 'sum_4', 'sum_5', 'sum_6', 'sum_7', 'sum_8', 'x', 'x1', 'x2', 'y', 'y1', 'y2']\n" ] } ], "source": [ "print(\"The evolved variables are:\", vars.evolved)\n", "print(\"Auxilliary variables are:\", vars.aux.all)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One sees a number of new variables. They were introduced by *naming* all *intermediate* expressions. What are these intermediates? Let's review again the variable *z*:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "DDA-Symbol\n", "\n", "\n", "\n", "int\n", "\n", "\n", "int\n", "\n", "\n", "\n", "mult\n", "\n", "\n", "mult\n", "\n", "\n", "\n", "int->mult\n", "\n", "\n", "\n", "\n", "\n", "dt\n", "\n", "\n", "dt\n", "\n", "\n", "\n", "int->dt\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "\n", "int->0\n", "\n", "\n", "\n", "\n", "\n", "3.5\n", "\n", "3.5\n", "\n", "\n", "\n", "mult->3.5\n", "\n", "\n", "\n", "\n", "\n", "y\n", "\n", "\n", "y\n", "\n", "\n", "\n", "mult->y\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "state[\"z\"].draw_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, the left most child is an intermediate expression, since it computes `mult(3.5, y)`. We can give this intermediate result a concrete name and replace the whole subtree with this name:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "DDA-Symbol\n", "\n", "\n", "\n", "int\n", "\n", "\n", "int\n", "\n", "\n", "\n", "mult_6\n", "\n", "\n", "mult_6\n", "\n", "\n", "\n", "int->mult_6\n", "\n", "\n", "\n", "\n", "\n", "dt\n", "\n", "\n", "dt\n", "\n", "\n", "\n", "int->dt\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "\n", "int->0\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "state.name_computing_elements()[\"z\"].draw_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulating a circuit\n", "\n", "In the following, we use the C++ code generator to simulate this simple ordinary differential equation:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "// This code was generated by PyDDA.\n", "\n", "#include /* don't forget -lm for linking */\n", "#include /* for feraisexcept and friends */\n", "#include /* for signaling NAN */\n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "\n", "bool debug;\n", "constexpr double _nan_ = std::numeric_limits::signaling_NaN();\n", "\n", "namespace dda {\n", "\n", "/* if you use an old C++ compiler, just remove the newer features */\n", "#define A constexpr double /* constexpr requires C++11 */\n", "#define D template A /* Variadic templates require C++17 */\n", "\n", "// Known limitations for div(int, double): If certain arguments appear as integer\n", "// in the code (i.e. 1 instead of 1.0), there is div(int,int) kicking in from\n", "// cstdlib. TODO: Should rename div to Div; following int->Int.\n", "\n", "A neg(double a) { return -a; }\n", "A div(double a, double b) { return a/b; }\n", "D Int(T... a) { return -(a + ...); } // int() is res\n", "// ... (in total 481 lines of C/C++ code) ...\n" ] } ], "source": [ "cpp_code = state.export(to=\"C\")\n", "print(cpp_code[:1000])\n", "print(\"// ... (in total \", cpp_code.count(\"\\n\"), \" lines of C/C++ code) ...\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We printed the generated C++ code, which is in fact just a string in python, in the cell above. Next come some shortcut functions which call the system C++ compiler and run the binary, all externally on the system shell. The return value is slurped in as CSV data with numpy, so we readily have it for plotting." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "from dda.cpp_exporter import compile, run\n", "compile(cpp_code)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running: ./a.out --max_iterations=10 x y z\n", "x\ty\tz\n", "0.100223\t0.0005\t0\n", "0.100448\t0.00100062\t-1.75e-06\n", "0.100675\t0.00150184\t-5.25215e-06\n", "0.100905\t0.00200368\t-1.05086e-05\n", "0.101136\t0.00250611\t-1.75215e-05\n", "0.10137\t0.00300915\t-2.62929e-05\n", "0.101605\t0.00351277\t-3.68249e-05\n", "0.101843\t0.00401699\t-4.91196e-05\n", "0.102082\t0.0045218\t-6.3179e-05\n", "0.102324\t0.00502718\t-7.90053e-05\n", "\n" ] } ], "source": [ "# This shows the stdout of the binary generated by the above C++ code:\n", "print(run(arguments={\"max_iterations\":10}, fields_to_export=list(\"xyz\"), return_ndarray=False))" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running: ./a.out --max_iterations=1000 --modulo_write=10\n" ] } ], "source": [ "# We can slurp in the CSV data directly to a numpy recarray:\n", "result = run(arguments={\"max_iterations\":1000, \"modulo_write\":10})" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.100223, 0.102568, 0.105126, 0.107902, 0.110904, 0.114137,\n", " 0.11761 , 0.121327, 0.125297, 0.129525, 0.134019, 0.138785,\n", " 0.143831, 0.149164, 0.154792, 0.16072 , 0.166958, 0.173512,\n", " 0.180391, 0.187603, 0.195156, 0.203058, 0.211319, 0.219946,\n", " 0.22895 , 0.23834 , 0.248125, 0.258317, 0.268924, 0.279959,\n", " 0.291432, 0.303354, 0.315739, 0.328597, 0.341943, 0.355789,\n", " 0.370149, 0.385039, 0.400471, 0.415958, 0.430975, 0.445545,\n", " 0.459687, 0.473419, 0.486757, 0.499714, 0.512304, 0.524535,\n", " 0.536418, 0.54796 , 0.559167, 0.570045, 0.580597, 0.590828,\n", " 0.600738, 0.61033 , 0.619603, 0.628559, 0.637196, 0.645513,\n", " 0.653509, 0.661182, 0.668528, 0.675547, 0.682235, 0.688589,\n", " 0.694606, 0.700283, 0.705617, 0.710605, 0.715244, 0.719531,\n", " 0.723464, 0.727041, 0.730258, 0.733115, 0.73561 , 0.737741,\n", " 0.739508, 0.74091 , 0.741947, 0.742621, 0.742931, 0.742879,\n", " 0.742467, 0.741697, 0.740573, 0.739097, 0.737275, 0.735109,\n", " 0.732606, 0.729772, 0.726611, 0.723132, 0.719342, 0.715248,\n", " 0.710859, 0.706184, 0.701233, 0.696016])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "result[\"x\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The above cell output shows a NumPy array, which is a Python-internal representation of the CSV file printed in the cell above. NumPy arrays are suitable for plotting, as we do next.\n", "\n", "What is actually called by `cpp_exporter.run()` is [np.genfromtxt()](https://numpy.org/doc/stable/reference/generated/numpy.genfromtxt.html). As our CSV file has a header row with column names, it creates a [numpy recarray](https://numpy.org/doc/stable/reference/generated/numpy.recarray.html). Therefore, we can address the column `x` by writing `result[\"x\"]`." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5kElEQVR4nO3dd3gVZfbA8e9JIxB6EmooofcaAiIqqKgogigqSrGgWBbLqvvTXXddV3dXd3VddS2IgAgWEEVFV8UuNkrovbfQQgIBAiSknN8f79WNGCBAbuaW83mePObemcw9I8mcmbecV1QVY4wx4SvC6wCMMcZ4yxKBMcaEOUsExhgT5iwRGGNMmLNEYIwxYS7K6wBOVkJCgjZu3NjrMIwxJqjMnz8/U1UTS9oWdImgcePGpKWleR2GMcYEFRHZfKxt1jRkjDFhzhKBMcaEOUsExhgT5oKuj6Ak+fn5pKenk5ub63UoxxQbG0tSUhLR0dFeh2KMMb8QEokgPT2dKlWq0LhxY0TE63B+RVXJysoiPT2d5ORkr8MxxphfCImmodzcXOLj4wMyCQCICPHx8QH9xGKMCV8hkQiAgE0CPwn0+Iwx4SskmoaMMeElv7CIPQePkJmTx96D+eTk5bM/t4CDeQUcKSjiSEER+YVFgLsJixAhJiqC2OgIYqMjqVwhiqoVo6lWMZr4uBgSq1QgNjrS47PyjiUCY0xAyszJY11GDhszD7Ip8yCbsw6xfd9htmfnkpmTV+afV6VCFHWqxVK/RkWSalSkUc04khPiaJIYR8OalYiKDJkGlF+xRGCM8ZSqsnXPYRanZ7MkPZvl2/ezZtcBMnOO/LxPTFQEDWpUpH6NSrSpW5U61WJJqFyBhMox1KgUQ9WK0VSuEEXlClFUiI4gJjKCyAhBRFBVihSOFBSRV1DI4fxCcnIL2J+bT/ahfLIOHmH3gTx2H8hje/ZhtmUfZtHWbLIP5f/v8yMjaFarMq3qVqFN3ap0bFCdtvWqUikmNC6hoXEWHps3bx4jR45k7ty5FBYWkpqaytSpU2nXrp3XoRkTcAqLlBXb9zNnYxbzNu0hbdNesg66i35MZASt6lahT8tatKxThRa1q5CcEEe96hWJjDi1fjYRIVKgYkwkFWMiqQ5Q7cQ/l33oCBsyD7Jh90HW7jrAyp0H+G5tJtMXbAMgQqBlnap0a1yDlMY1SW1ckzrVYk8pRq+FXCL4ywfLWbF9f5kes029qvz50rbH3N6tWzcGDBjAH//4Rw4fPsywYcMsCRhTzM59uXy1OoNv1+7mh/VZP99tN6xZiXNaJtK1UQ06JlWnRe0qxEQFRhNM9UoxdGkYQ5eGNX7xfsaBXJZs3ceS9GwWbMnmnfnpTPrRlfFpkhjHmU0TOLNZAmc2i6dKbHDMGwq5ROCVhx56iG7duhEbG8uzzz7rdTjGeEpVWbnjAJ8s28HnKzNYscPdnNWtFsv5rWvTq1kCPZrEB+UddK0qsZzfJpbz29QGoKCwiFU7DzB7Qxbfr8vknQXpTJ69magIIaVxDfq0rMUFbeuQnBDnceTHFnKJ4Hh37v60Z88ecnJyyM/PJzc3l7i4wP1HN8ZfVu7Yz/uLtvPxsh1szjpEhEDXRjW4/6JWnNe6Fs1rVQ65odRRkRG0q1+NdvWrcdNZTcgvLGLB5r18vWY3X63K4LGPV/HYx6toXqsyF7StzSXt69G6bpWA+v8gqup1DCclJSVFjy5DvXLlSlq3bu1RRM6AAQMYMmQIGzduZMeOHTz33HO/2icQ4jSmrO3cl8v0hem8v3A7q3cdICpC6NksgX7t6tC3TW0SKlfwOkRPbcs+zGfLd/Lpil3M2biHwiKlSWIc/dvXZWDn+jRNrFwucYjIfFVNKWlbyD0ReGHSpElERUVx7bXXUlhYSM+ePfnyyy8599xzvQ7NGL/ILyzi8xW7eCttK9+s2U2Rujv/Rwe25ZIO9agZF+N1iAGjfvWKXH9mMtefmUxWTh6fLN/Jh4t38J+v1vHsl+vomFSNQZ3rM7BTfWp49P/Nr08EInIR8AwQCYxT1ceP2v47YKjvZRTQGkhU1T3HOmagPhGURrDEacyx7Nh3mDfnbmXK3C1kHMijTtVYBndNYnDXJBoHcBt4INq1P5cZi7YzfeE2Vu7YT0xkBBe0rc1VKQ3o1SyBiFMcJXUsnjwRiEgk8DzQF0gH5onIDFVd8dM+qvoE8IRv/0uB3x4vCRhjvLFgy17Gf7eRT5btpEiV3i0SeaxHI3q3rHXKwzrDXe2qsdx8dhNuPrsJK7bv5620rby3aBsfLtlBw5qVuLZ7Q67smkR8OTSt+bNpKBVYp6obAERkCjAQWHGM/a8B3vRjPMaYk1BUpHy6YicvzdrAwi3ZVImNYmSvZIb3aESDmpW8Di+ktKlXlYcHtOWBfq2YuXwnr8/ZwuMfr+KpT9fQv2NdbuiZTPukUkx+OEX+TAT1ga3FXqcD3UvaUUQqARcBo4+xfRQwCqBhw4ZlG6Ux5heOFBTx3sJtjJm1ng27D9IovhJ/GdCWwV2TiKtg3Yr+FBsdycBOrr9gza4DvDZ7M+/MT2f6gm10bVSD0X2a0adVrTL/XH/+q5b0vHisDolLge+P1SykqmOBseD6CMomPGNMcUcKipg2fysvfLWebdmHaVuvKs9d25l+7epa848HWtSuwiMD23HfhS2ZlpbOqz9sYs2uA0GXCNKBBsVeJwHbj7HvEKxZyBhP5BcW8fb8dJ77ch3bsg/TqUF1/jqoHb1bJAbUWPdwVTU2mpG9krm+Z2MKior88hn+TATzgOYikgxsw13srz16JxGpBpwDDPNjLMaYoxQVKR8u3cG/P1vDxsyDdGpQnb9f3p6zmydYAghAkRFCZIR/SmX7LRGoaoGIjAZm4oaPTlDV5SJyq2/7GN+ug4BPVfWgv2IxxvzSD+sy+fvHK1m2bT+t6lRh3IgUzmtdyxJAmPJrz4+qfgR8dNR7Y456PRGY6M84jDHOuowDPPbRKr5YlUH96hX599UdGdixfpmPWTfBxYYAlIE//elPJCQkcNdddwHw4IMPUrt2be68806PIzPG2Xc4n6c/X8OkHzdTKSaSB/q14vqejcN6VS7zP6GXCD5+AHYuLdtj1mkP/R4/5uaRI0dy+eWXc9ddd1FUVMSUKVOYO3du2cZgzCkoKlLeStvKP2euZu+hI1yT2pB7+7Yol0lKJniEXiLwQOPGjYmPj2fhwoXs2rWLzp07Ex8f73VYJswt27aPP763jEVbs0ltXJM/D2hD23r+m5RkglfoJYLj3Ln700033cTEiRPZuXMnN954oycxGAOQk1fAkzNXM+nHTdSMi+GpqzoyqHN96wg2xxR6icAjgwYN4qGHHiI/P5833njD63BMmPpsxS4een8ZO/fnMrxHI+69oCXVKgbHKlnGO5YIykhMTAx9+vShevXqREZaB5wpX5k5eTz0/jI+WrqTlrWr8PzQLr9aYtGYY7FEUEaKioqYPXs206ZN8zoUE0ZUlRmLt/PwjOUczCvkvgtaMOrspgGz7q8JDpYIysCKFSvo378/gwYNonnz5l6HY8JEZk4ef5i+lE9X7KJTg+o8MbgDzWtX8TosE4QsEZSBNm3asGHDBq/DMGFk5vKd/GH6Ug7kFfD7fq246awmVhjOnLKQSQSqGtCjIoJtbWgTmA7k5vPwjBW8syCdtvWq8ubVnWhhTwHmNIVEIoiNjSUrK4v4+PiATAaqSlZWFrGxsV6HYoLYgi17uXvKItL3HmJ0n2bceV5z6wswZSIkEkFSUhLp6ens3r3b61COKTY2lqSkJK/DMEGosEh5/qt1PPPFWupUjWXqLWfQrXFNr8MyISQkEkF0dDTJycleh2FMmdu1P5e7pixk9oY9DOhYj0cva2fzAkyZC4lEYEwo+mbNbu6ZuohDRwp5YnAHBndNCsimTxP8LBEYE2AKi5SnP1/Df75c55sc1plmtaxD2PiPJQJjAkhmTh53vrmQH9ZncXVKAx4e0JaKMTZT3fiXX4cciMhFIrJaRNaJyAPH2Ke3iCwSkeUi8o0/4zEmkM3fvJdLnv2W+Zv38s/BHfjH4A6WBEy58NsTgYhEAs8DfXEL2c8TkRmquqLYPtWBF4CLVHWLiNTyVzzGBCpV5fU5W/jLB8upW60i796eSpt6Vb0Oy4QRfzYNpQLrVHUDgIhMAQYCK4rtcy0wXVW3AKhqhh/jMSbg5OYX8tD7y3grLZ3eLRN55urOVKtko4JM+fJnIqgPbC32Oh3oftQ+LYBoEfkaqAI8o6qT/BiTMQEjY38ut7w2n4Vbsrnj3GbcfX4LKxNhPOHPRFDSb/TRdRaigK7AeUBF4EcRma2qa35xIJFRwCiAhg0b+iFUY8rX4q3Z3DJ5PvsO5/Pi0C70a1/X65BMGPNnZ3E60KDY6yRgewn7fKKqB1U1E5gFdDz6QKo6VlVTVDUlMTHRbwEbUx5mLN7OVS/9SGSE8M5tPS0JGM/5MxHMA5qLSLKIxABDgBlH7fM+cJaIRIlIJVzT0Uo/xmSMZ1SVZz5fy51vLqRDUjVmjD7TOoVNQPBb05CqFojIaGAmEAlMUNXlInKrb/sYVV0pIp8AS4AiYJyqLvNXTMZ4JTe/kPvfWcL7i7ZzRZck/n55OypE2dBQExgk2Mojp6SkaFpamtdhGFNqew8eYdTkNOZt2svvLmzJ7b2bWqkIU+5EZL6qppS0zWYWG+NHW7IOcf0rc0nPPsxz13amf4d6XodkzK9YIjDGTxZtzWbkxHkUqvL6Td2tdLQJWJYIjPGDr1ZncPtrC0ioEsPEG1JpmljZ65CMOSZLBMaUsbfnp3P/O0toVacKr9zQjVpVbGU6E9gsERhThsZ8s57HP15Fr2YJjBnelcoV7E/MBD77LTWmDKgqj3+8ipdmbeDSjvX415UdbT1hEzQsERhzmgqLlD9MX8rUtK0M79GIvwxoS4TVDDJBxBKBMafhSEERd09dyEdLd3LHuc24p28LmyNggo4lAmNOUW5+Ibe9Np+vVu/mj5e05qazmngdkjGnxBKBMafgYF4BN72axuyNWfx9UHuu7W5VcU3wskRgzEk6kJvP9a/MY9HWbJ66qiODOid5HZIxp8USgTEnYd/hfEZMmMvybft47prOVkLahARLBMaUUvahIwwfP5dVO/fzwtAuXNC2jtchGVMmLBEYUwrZh44wdNwc1u7KYcywrpzXurbXIRlTZiwRGHMC+w7lM3z8XNbuyuGlEV3p07KW1yEZU6Zs6qMxx+H6BOawaud+xgzvYknAhCRLBMYcw4HcfK6bMJcVO/bz4tCunNvKmoNMaPJrIhCRi0RktYisE5EHStjeW0T2icgi39dD/ozHmNI6fKSQkRPTWLptH89d24Xz21gSMKHLb30EIhIJPA/0BdKBeSIyQ1VXHLXrt6ra319xGHOycvMLGTU5jbTNe3hmSGcutNFBJsT584kgFVinqhtU9QgwBRjox88z5rTlFxYx+o2FfLs2k39c0YFLO9rSkib0+TMR1Ae2Fnud7nvvaGeIyGIR+VhE2pZ0IBEZJSJpIpK2e/duf8RqDEVFyn3TFvP5yl08OrAtV6Y08DokY8qFPxNBSSUY9ajXC4BGqtoR+A/wXkkHUtWxqpqiqimJiYllG6UxuPUE/jxjOe8v2s7vLmzJ8DMaex2SMeXGn4kgHSh+S5UEbC++g6ruV9Uc3/cfAdEikuDHmIwp0VOfrWHy7M3ccnYTbu/d1OtwjClX/kwE84DmIpIsIjHAEGBG8R1EpI74ireLSKovniw/xmTMr7zy/Ub+8+U6hnRrwAP9Wtl6Aibs+G3UkKoWiMhoYCYQCUxQ1eUicqtv+xhgMHCbiBQAh4Ehqnp085ExfjNj8XYe+XAFF7Wtw98GtbckYMKSBNt1NyUlRdPS0rwOw4SA79ZmcsPEuXRuWINJN6YSGx3pdUjG+I2IzFfVlJK22cxiE5aWbdvHLZPTaJpYmZdHpFgSMGHNEoEJO+l7D3HDxHlUrxTDqzemUq1itNchGeMpqz5qwsq+Q251sbz8Qt64qTu1q8Z6HZIxnrNEYMJGXkEhN09OY0vWISaNTKV57Speh2RMQDippiERiRCRqv4Kxhh/UVX+7+0lzN24hyev6kiPJvFeh2RMwDhhIhCRN0SkqojEASuA1SLyO/+HZkzZefrztT/PGh5g9YOM+YXSPBG0UdX9wGXAR0BDYLg/gzKmLL27MJ1nvljL4K5JNmvYmBKUJhFEi0g0LhG8r6r5/LpmkDEBad6mPdz/9lJ6NKnJ323CmDElKk0ieAnYBMQBs0SkEbDfn0EZUxa27jnELZPnU79GRcYM60pMlI2WNqYkJxw1pKrPAs8We2uziPTxX0jGnL6cvAJunpRGQWER465LoXqlGK9DMiZglaazuLaIjBeRj32v2wDX+T0yY05RUZFy95RFrM3I4fmhXWiaWNnrkIwJaKV5Vp6IKxz301CLNcDdforHmNP21Gdr+HzlLh7q34azmtv6FcacSGkSQYKqvgUUgasqChT6NSpjTtFHS3fw3FeupPSIMxp5HY4xQaE0ieCgiMTjGykkIj2AfX6NyphTsGrnfu6btpguDavzl4FtbYSQMaVUmhIT9+AWlGkqIt8Dibh1BIwJGNmHjjBq0nwqV4hizLCuVIiyaqLGlFZpRg0tEJFzgJa4dYhX++YSGBMQCouUO6csYue+XKbc0oNaVkjOmJNSmlFDI4Brga5AF+Aa33snJCIXichqEVknIg8cZ79uIlIoIvakYU7aM1+sZdaa3Tw8oC1dGtbwOhxjgk5pmoa6Ffs+FjgPWABMOt4PiUgk8DzQF7eQ/TwRmaGqK0rY7x+4kUnGnJQvVu7i2S/WcmXXJK5JbeB1OMYEpdI0Dd1R/LWIVAMml+LYqcA6Vd3g+7kpwEBc4bri7gDe4ZcJx5gT2px1kN9OXUTbelV59LJ21jlszCk6lTn3h4DmpdivPrC12Ot033s/E5H6wCBgzPEOJCKjRCRNRNJ27959kuGaUHT4SCG3vrYAEWHMsK621KQxp+GETwQi8gH/KzIXAbQB3irFsUu6PTu6WN3TwP2qWni8uzlVHQuMBbd4fSk+24QwVeUP7y5l1c79TLi+Gw1qVvI6JGOCWmn6CJ4s9n0BsFlV00vxc+lA8UbbJGD7UfukAFN8SSABuFhEClT1vVIc34SpybM38+7Cbfz2/Bb0aVnL63CMCXql6SP45hSPPQ9oLiLJwDZgCG70UfFjJ//0vYhMBD60JGCOZ/7mPTzywQrObVWLO85t5nU4xoSEYyYCETlAyesOCKCqetwlK1W1QERG40YDRQITVHW5iNzq237cfgFjjrZzXy63vraAetUr8u+rOhERYZ3DxpSFYyYCVT3tlb1V9SPcqmbF3ysxAajq9af7eSZ05eYXcstr8zmYV8BrI7tTrVK01yEZEzJK00cAgIjUws0jAEBVt/glImOOoqo8+O4yFm/NZsywrrSsc9r3KMaYYkozs3iAiKwFNgLf4FYr+9jPcRnzs/HfbeSdBencfX5zLmpXx+twjAk5pZlH8CjQA1jj69w9D/jer1EZ4/PVqgz+/tFKLmpbhzvPLc30FWPMySpNIshX1SwgQkQiVPUroJN/wzLGlZW+482FtKlXlaeu7midw8b4SWn6CLJFpDIwC3hdRDJw8wmM8ZvdB/IYOTGNuAqRjBvRjUoxpe7OMsacpNI8EQzElZX4LfAJsB641J9BmfB2+EghoyankXUwj3EjulGnmpWVNsafSnObNQqY5ptN/Kqf4zFhrrBIuXvqQhZtzebFoV1pn1TN65CMCXmleSKoCswUkW9F5DciUtvfQZnw9bf/rmTm8l386ZI2NkLImHJywkSgqn9R1bbAb4B6wDci8rnfIzNhZ8J3G5nw/UZuPDOZG3sln/gHjDFl4mTKUGcAO4EswCp9mTI1Y/F2Hv3vCi5sW5sHL2ntdTjGhJXSTCi7TUS+Br7AVQi9WVU7+DswEz6+W5vJvW8tolujmjwzpDORNkzUmHJVms7iRsDdqrrIz7GYMLQ0fR+3TE6jaWJlXr4uxRaYMcYDpSlDfcxF5405Hesycrj+lblUrxTDqzemUq2iFZIrlcPZsGcD7N3kvg7shJxdcHA35O6DIwfdV+ERfi4gHBEF0XEQEwexVSEuESrXgir1oGYy1EiG+KZQsbpnp2W8Y7N0jCfS9x5i+Pg5iMDkkanUrmpzBUq0fzukp8G2+bBrufs6cNT6ThWquot6XC2o3tBd7GPiILKC2y7iksKRQ5B/0CWSrHWw+Qc4vOeXx6rWAOq0hzodoEEqJHVzicOENEsEptxlHMhl2Lg5HMwrYMqoM2iSWNnrkALH3s2wcZb72vw97N/m3o+IhsSW0LgX1G4D8c2hRmOo0QgqnEY11iOHIHuze8LIXAM7l8HOpbDmE9AikAiXGJqeC836uuQQaU9uoUZUg2sJ4JSUFE1LS/M6DHOK9h48wjUvz2Zz1iFeu6k7XRvV8DokbxXmw6bvYO1nsPZTyFrr3o9LdBf9Bt2hfoq7GEeX41NT3gFInwdbZrv4tswGLXRPHy37QZvLXHIoz5jMaRGR+aqaUtK2U1mhDIATrVBmzNH2Hcpn2Pg5bMg8yITruoVvEig4Auu/hJUzYNV/ITfbNeMknwXdboImvd3dv3g4eqpCFXehb3que527DzZ8454UVv0XlkyFmCrQ9jLoPMwlLC/jNaflhCuUicgjuPkDk3HLVA4FSvUsKiIXAc/glqocp6qPH7V9IK7MdRGukN3dqvrdyZ+GCXT7c/MZMWEOa3flMHZEV3o1T/A6pPKlClvnuAvo8nfh8F6oUA1aXQytL3UX/5g4r6M8tthq0GaA+yrMh43fwLLp7mvhZIhvBikjofNQt68JKidsGhKROara/UTvlfBzkcAaoC+QjlvM/hpVXVFsn8rAQVVVEekAvKWqrY53XGsaCj4HcvO5bsJclqTvY8ywrpzfJoyqlBzYBYvfgAWTYc96iKoIrftD+6vcxT8qxusIT09eDqx4DxZMcokuOg46XQs9bnOjkEzAOKWmoWIKRWQoMAXXVHQNUFiKn0sF1qnqBl8QU3CVTH9OBKqaU2z/OI7TFGWC035fEliavo/nru0cHklAFTZ9C3Nfds0oWggNe8LZ97m7/9Pp3A00FSq7pqHOw2D7QpgzFha8Cmnjoe3lcNY9ULut11GaEyhNIrgW17zzDO5C/b3vvROpD2wt9jod+NVThIgMAh7Dla24pKQDicgoXBVUGjZsWIqPNoFg3+F8Royfw4od+3l+aBcubBviReSOHIIlU2DOS7B7FVSsAWfcDl2ug4QwWF2tXmcY9CKc/zD8+BykTYBlb7vkd+6fXL+HCUh+GzUkIlcCF6rqTb7Xw4FUVb3jGPufDTykqucf77jWNBQc9h48wogJc1m1cz8vDg3x5qCcDHf3P2+cG5dftyOk3gLtLofoil5H551De2DOGPjxBTd/ocMQ6PMHqN7A68jC0qmOGvoPxx81dOcJPjcdKP4vngRsP8a+qOosEWkqIgmqmnmCY5sAlnEgl+Hj5rIx6yAvDe/Kua1CNAns2Qg//AcWvuYmbLW8GHqOhoZn2AgagEo13YU/9Rb47imXLJdPh553Qq+7A7tzPMwcr2nodG+75wHNRSQZ2AYM4agmJRFpBqz3dRZ3AWJw1U1NkErfe4hh4+aQcSCPV67vxpnNQnB00O7VMOtJ1+wREQUdr3EXt4RmXkcWmOLi4cK/uQ7kz/4Ms/7pRhr1fRTaD7akGQCON3z0F6uRiUicqh4s7YFVtUBERgMzccNHJ6jqchG51bd9DHAFMEJE8oHDwNUabDPczM/W785hxPi57M/NZ/LIEJwslrESZj3hhkxGV4Qet8MZo6FqXa8jCw7VkmDweEgdBZ/cD9NvgkWvwSVP2Qgjj5Vm+OgZwHigsqo2FJGOwC2qent5BHg06yMITIu3ZnPDxHkI8OqNqbSrH0JjyTPXwtePw7J3XHNG6ig44zcQF4JPO+WlqNB1Jn/xCBTkwdm/c81FVr7Cb053+OjTwIXADABVXezr2DUGgG/X7uaWyfOpGRfD5JHdSU4IkbbfvZvhm3/A4jchKtZdqHre6dq+zemJiITUm92Iok8egK/+Cqs+gMtetOGmHihV0TlV3Sq/bMcrzTwCEwbeW7iN3729mKaJlZl0Yyq1QqGKaE6G6wNIm+CKrnW/DXr9Fioneh1Z6KlSB66c6OYc/PceeOkc6H0/9LrHJQtTLkqTCLaKSE9ARSQGuBNY6d+wTKBTVV74ej1PzFxN9+SajB2REvzrCeTluPHv3z8LBbmuXMI597u2beNfbQZAozPho3vhy7/Cui/g8rGurLbxu9Ikgltxk8nq44aEfopbyN6EqYLCIh6asZw35mxhYKd6/HNwBypEBfHdW2G+mw379T/gYAa0HgDnPRQek8ACSVw8DH4FWvSD/94LL/aC/k+5kUXGr0qzQlkmrtCcMezPzWf0GwuZtWY3t/duyn0XtCQiWNcYVoXVH7khjVlrXRmIIW9Ag25eRxa+RKDj1dCwO7xzM7wz0q3LcOFjVvLaj443oez/VPWfx5pYVooJZSbEbMk6xMhX57Ex8yCPX96eIalB/Ni+fSHMfNBdZOKbw5A3XZ19G9MeGGo0hhs+gi8fhe+fcau0XfUq1GzidWQh6XhPBD8Vh7Oxmoa5G/dw62vzKSxSJo1MpWfTIB06uW+bu7gsfhMqJcAl/3K1gGzYYuCJjIa+j7iZ2u/eCi/1hitehhYXeh1ZyDleIrga+BCorqrPlFM8JgC9NnszD89YTsOalRh/fbfgHB6alwM/POs6grXIjQLqdY+txxsMWvaDW2bB1GHwxtVw7oNw1n329FaGjpcIuopII+BGEZmEW5TmZ6q6p+QfM6HiSEERD3/gOoX7tEzk6SGdg29kUFGRu/v/4hHI2emGKZ7/sFvr1wSPGo3gxpnwwV1uVNGOxXDZGFcG25y24yWCMcAnQBNgPr9MBOp734SoHfsO85vXF7BgSza3927KvRe0JDLYOoU3fQef/B52LnHr/l492S2+boJTTCU3pLRuR/jsT/DKRXDNVKhW3+vIgl5pSky8qKq3lVM8J2QlJvzvh3WZ3PHmQnLzC/nn4I5c0iHIauns2QCfPQQrP4CqSe4JwIqbhZa1n8G0G1zJj2vehPpdvI4o4B2vxETEiX44kJKA8a+iIuX5r9YxbPwcasTF8P7oXsGVBA5nw6d/hOe7w7ovoc8f4Y406HClJYFQ07wvjPwUImPglYvdSnDmlJWqxIQJfZk5efx26iK+XZvJpR3r8fjl7YmrECS/HoX5MH8ifP2YWwyl81C3IlaVEF8RLdzVbgM3f+E6kKcOg4ufgG43eR1VUAqSv3TjTz+sz+TuKYvYdzifxy5vz5BuDZBguINWhTWfuGagzDXQ+CxX975uR68jM+Wlci24/kN4+0Y3G3nfNjcrPBh+fwOIJYIwdqSgiKc+W8NLs9aTnBDHqzem0rpukAyn3L4QPv2TWyQ+vplNCAtnMXFw9evw0X1uJbSDGdD/GYi0y1tp2f+pMLV+dw53T1nE0m37uCa1IX/q35pKMUHw67B3s5sQtnQaVIqHfk9Ayg02ISzcRUZB/39D5drwzeOuv+iK8VaWopT8+pcvIhfhCtZFAuNU9fGjtg8F7ve9zAFuU9XF/owp3BUVKZN+3MTjn6wiNjqSMcO6clG7IGhLP7QHvv0XzB3rSkP3usetDxAbQgvgmNMjAn1+DxVruBXQ3rjS1Y6qUMXryAKe3xKBiEQCzwN9cVVL54nIDFVdUWy3jcA5qrpXRPoBY4Hu/oop3KXvPcT/vb2EH9Zn0btlIv+4ogO1A339gCOHYO5L8O2/IW8/dBrq/titNLQ5lh63umTw3m0w+XIYOg0qVvc6qoDmzyeCVGCdqm4AEJEpwED+V8MIVf2h2P6zAfvr9oOiIuX1uVt4/CO3jERQdAgXFrgFzr/5BxzYAc0vdPMBarfxOjITDDpe7SagTbsBJg2A4e/ZynLH4c9EUB/YWux1Ose/2x8JfFzSBhEZBYwCaNgwiCteemBT5kHuf2cJczbuoVezBB67vD0NalbyOqxjKyqCFe/BV3+DrHWQ1M219TY+0+vITLBpfalrGpo6DCZeAiPed6OMzK/4MxGUdLtZ4jRmEemDSwS9StquqmNxzUakpKQcfyq0AdyIoJe/3cCzX6wlJiqCf1zRnqtSAvgpQNWtSvXFX1xJiMRWbiRIq0tsJJA5dS0ugKFvwZvXwKuXwnUfWDIogT8TQTrQoNjrJGD70TuJSAdgHNBPVbP8GE/YmLdpD3+YvpS1GTlc3L4Of760bWD3BWz+Ab54FLb84JYmvGwMdLjK1qw1ZaNJb7j2LXjjKksGx+DPRDAPaC4iycA2YAhwbfEdRKQhMB0Yrqpr/BhLWMg4kMvjH69i+oJt1K9ekfHXpXBe69peh3Vs2xa4JqB1n7thfxc/6dYGiIrxOjITapLPsmRwHH5LBKpaICKjgZm44aMTVHW5iNzq2z4GeAiIB17wNVkUHKsokjm2/MIiJv24mac/W0NuQSG3927K6HObBe68gF3L4au/w6oPoWJNOP8vkDrKde4Z4y/JZ7kRRK9fCZMuczOSrQMZKEX10UBj1Uf/R1X5anUGf/3vSjbsPsg5LRL586VtaJIYoDXaM1a5yT7L34UKVaHnHdD9VlscxpSvDV/D61dBrVYwYkbYDC09XvXRAL1lNCeyYvt+Hvt4Jd+uzaRJYhwTrk+hT8tagdkZnLnODQNdOs2VAzjrPjjjN3Y3ZrzRpDcMed11IL92BYx4L+wnnVkiCDJb9xziqc/W8N6ibVSrGM1D/dsw/IxGREeesKJ4+ctaD9/8E5a+BVGxcOad0PMuiIv3OjIT7pr3hSsnwlsj4I0hMOxtiK7odVSesUQQJDL25/LC1+t5Y84WROCWs5tyW++mgbl0ZNZ6Vw5i8RRXL77H7XDm3VA50evIjPmf1v1h0Esw/WaYdj1c/VrY1qyyRBDgMnPyeHnWBl79cRP5hcqVXZO46/zm1K0WgHcvWeth1pOwZKr7g+p+K5x5F1QJ4JFLJrx1uBLy9rkS1u/dBoPGQkQAPl37mSWCAJWxP5exszbw2pzN5BUUMahTfe48rzmNE+K8Du3XMtfBrCdcE1BkjCUAE1y63QS5++CLRyC2ulvgJhD72vzIEkGA2Zx1kJe/3cC0tHQKipSBnerxmz7NaBqII4EyVsG3T8KydyCygmsC6nmnJQATfHrdA4f3wg//cfMLzvk/ryMqV5YIAsTirdmM/XYDHy/dQVREBJd3qc9tvZvSKD4AnwB2LXdPAMvfg+hKcMZolwCsD8AEKxE4/xE4mOkmOcYlQMqNXkdVbiwReKigsIjPVuxi/HcbSdu8lyoVorj57CaMPDOZWoFYEmL7QtcHsOpDiKkCZ90DPX5jo4BMaIiIgAH/cWtf/PdeqJQAbQZ4HVW5sETggcycPKbO28rrszezfV8uDWpW5E/923BVShJVYgNw1MLWuW4Y6LrP3EIw5zwA3W+xeQAm9ERGu2Glkwa60USVa0HDHl5H5XeWCMpJUZEye0MWb87byifLdpBfqJzZLJ6HLm1L3za1iYwIsM4pVbce8KwnYOMsVwri3D9B6s22KpgJbTGV4JopML4vvHE1jPwMElt4HZVfWSLws23Zh3l3QTrT5qezOesQVWOjGNq9EcN6NKJZrQDsAFaFtZ+6JqD0ua4Y3AV/c+sCxwRgf4Ux/hAXD8PeccngtSvgps9DehCEJQI/OJCbz8zlu3h3YTo/rM9CFVKTa3L3+c3p164usdEBWF65qBBWznATwXYuhWoN4ZJ/QadhtgC4CU81k13F0on93frH138EFQLw5q0MWCIoI4eOFPD16t18sHg7X6zK4EhBEQ1rVuKu85pzeeckGsYHaGXNwnxY8hZ892/IWgvxzWDgC249gDCdZWnMz+p3cX0Gb14N74x0K56F4DoZlghOw77D+Xy9OoNPlu3kq9UZ5OYXkVA5hmtTGzKgUz06N6gemEXgAPIPw4LJ8MOzsG8r1G7vfuFbDwjJX3RjTlmLC6DfP+Gj++CTB9z3gfp3fYosEZykTZkH+Wp1Bp+v3MWcDXsoKFISq1Tgyq4N6Ne+DqmNaxIViAXgfpK7D+aNgx9fgEOZ0KAH9P83NDs/5H65jSkzqTfD3k3w43NQIxnOuN3riMqUJYITOJCbz5wNe/huXSZfr85gU9YhAJomxnHTWU3o26Y2nRpUD7xRP0fLyYDZL8C88ZC33134e91ji8IbU1p9H4XszTDzD67/oGU/ryMqM5YIjnLoSAELNmcze0MWP27IYvHWbAqKlNjoCM5oEs8NZybTu2ViYM74LcneTW7a/MLXoCAP2gx0E8HqdvQ6MmOCS0SEK0qX3Q/eHgkjZ0Kd9l5HVSb8mghE5CLgGdxSleNU9fGjtrcCXgG6AA+q6pP+jOdoqsr2fbks2pLN/M17mb95D8u376egSImMENrVr8aos5vQq3kCXRvVoEJUELWd71oO3z3t6gBJBHQc4kpBJzTzOjJjgtdPcwxePtetY3DzF1CljtdRnTa/JQIRiQSeB/oC6cA8EZmhqiuK7bYHuBO4zF9x/ERV2bk/l2Xb9rNs2z6Wb9/Hoq37yMzJAyA2OoKOSdUZdXYTujeJp2ujGlSuEIQPTJt/dCOA1s6E6DjocZsrBletvteRGRMaqtaFa6fAhIvcKmc3fBT0i9r480qXCqxT1Q0AIjIFGAj8nAhUNQPIEJFL/BgHANMXbOPeaYtxsUCThDjObpFApwbV6ZhUndZ1qxITFcCdvMdTVOQu/N89DVtnQ6V46POgK69rZSCMKXt1O8IV42DKUHh/tPs+iAdb+DMR1Ae2FnudDnQ/lQOJyChgFEDDhg1PKZjU5Jo8MrAtbetVpVWdqsQF493+0QrzYenb8P0zsHulmwTW7wnoPMw9whpj/KfVJXDen9w6BrVaw9n3eR3RKfPn1bCk9KinciBVHQuMBUhJSTmlYzSoWYkRZzQ+lR8NPHk5sGAS/Pg87E+HWm3h8peh7SCbBGZMeep1D2SshC8fhcSW0PpSryM6Jf5MBOlAg2Kvk4Dtfvy80JezG+a+BHNfhtxsaHSmmwPQvG9QP5YaE7REXOnqPRtg+i0wMhnqtPM6qpPmz0QwD2guIsnANmAIcK0fPy90Za13E1kWveGGgLa6xI0AatDN68iMMdEV4erX4eU+MOUauPnroFujw2+JQFULRGQ0MBM3fHSCqi4XkVt928eISB0gDagKFInI3UAbVd3vr7iCyrb5rv1/xQzX5NPxGuh5ByQ09zoyY0xxVeu6ZPBKP5h2HQx/N6iaaUX1lJrcPZOSkqJpaWleh+E/qrD2M1cDaNO3UKEadLvRLQgfAuOVjQlpi6fAu7dA6ii4+Amvo/kFEZmvqiklbQuBoTMhouAILJ3mZgHvXglV67t1ALpeBxWqeB2dMaY0Og5xZdx/fA7qdIAuw72OqFQsEXjtcDbMnwhzxsCBHW4E0KCXoN0VQfVoaYzxOf8vsGsZ/PceN6w0qcSb8IBiicAr2VvdxX/+RDiSA016w8DnoOl5NgLImGAWGQWDX4GxvWHqMBj1TcCvbmaJoLxtX+QeG5dNd6/bXe46gK0InDGho1JNt4jN+L7w1nC47kOIivE6qmOyRFAeiopg3ef/6wCOqexqAHW/Fao3OPHPG2OCT512MPB5ePsGmPl7t/RrgLJE4E/5ubBkqpsBnLnadQD3fdR1AMdW8zo6Y4y/tbscti9wg0DqdYHOQ72OqESWCPwhZzekjXczgA9lutEDVgLCmPB03sOwYwl8+FvXeVy/i9cR/YolgrKUsQpmPw+Lp0JhHjS/EHqOhsZnWQewMeEqMgoGT/B1Hg+HW76BuASvo/oFSwSnSxXWf+maf9Z/AVGx7vGv+22Q2MLr6IwxgSAuAa6eDOMvhLdvdDOPIwJnoStLBKcq/zAseQtmv+gmgFWuDef+EbreGHR1Rowx5aBeZ9dhPGM0fPlXOP/PXkf0M0sEJ+vATpg3DtImwKEsqN0eLnvRTQCLquB1dMaYQNZlOKTPg++egvpdoXV/ryMCLBGU3vaF7u5/2XQoKoCW/dwSkI17Wfu/Mab0Ln7ClaF491ZI/CogikhaIjiewgJY9QHMHuOWgIypDN1GuoJS8U29js4YE4yiKsBVk+Cls13n8c1fQEyctyF5+umB6mAWLHgV5o13K4DVaAwXPuY6gW38vzHmdFVvAIPHw+TL4YO73PByD1sWLBEUt2OJWwFs6dtQkAvJ57jHuBYXBlQPvzEmBDQ9F8590HUcJ6VC91GehWKJoDAfVn4Ac8fClh8hqqIrJZt6C9Ru43V0xphQ1uteSE9zJSjqdYIGqZ6EEeHPg4vIRSKyWkTWicgDJWwXEXnWt32JiJTflLsDu+Drf8DT7V0tkP3b4YK/wr0r4dJnLAkYY/wvIgIGjXHlZ6ZdDwczPQnDb08EIhIJPA/0xS1kP09EZqjqimK79QOa+766Ay/6/usfqu6uf944t/xjUb4r+9z/39D8Amv+McaUv4o13GSzcX3hnZEwbHq5X4v82TSUCqxT1Q0AIjIFGAgUTwQDgUnq1sucLSLVRaSuqu4o82g2fgsf3w8Zy93yj6k3Q8pISGhW5h9ljDEnpW5HuORJmHEHfP246zsoR/5MBPWBrcVep/Pru/2S9qkP/CIRiMgoYBRAw4YNTy2aCpXdY9ilz0L7wZ4P1zLGmF/oMgK2zoFZ/4SkbtDignL7aH/2EZQ0FkpPYR9UdayqpqhqSmJi4qlFU68z3PKtKwFtScAYE4guftJVK5h+M2RvKbeP9WciSAeKr7qSBGw/hX3Kjs0ANsYEsuiKcNWroEXw1nVQkFcuH+vPRDAPaC4iySISAwwBZhy1zwxghG/0UA9gn1/6B4wxJljEN3X1y7YvgJl/KJeP9FsiUNUCYDQwE1gJvKWqy0XkVhG51bfbR8AGYB3wMnC7v+Ixxpig0bq/W8t83jhYMs3vHyduwE7wSElJ0bS0NK/DMMYY/yrMh1cvdRUPbv4SarU6rcOJyHxVTSlpm18nlBljjDlFkdEw+BWIqQRvjYC8HL99lCUCY4wJVFXrwhXjIHONW/PYTy04lgiMMSaQNekNfR6EpW+5BbH8wIrOGWNMoDvr3v8tiesHlgiMMSbQRUTAYP88DYA1DRljTNizRGCMMWHOEoExxoQ5SwTGGBPmLBEYY0yYs0RgjDFhzhKBMcaEOUsExhgT5oKu+qiI7AY2n+KPJwCZZRhOsAjH8w7Hc4bwPO9wPGc4+fNupKolLvEYdIngdIhI2rHKsIaycDzvcDxnCM/zDsdzhrI9b2saMsaYMGeJwBhjwly4JYKxXgfgkXA873A8ZwjP8w7Hc4YyPO+w6iMwxhjza+H2RGCMMeYolgiMMSbMhU0iEJGLRGS1iKwTkQe8jscfRKSBiHwlIitFZLmI3OV7v6aIfCYia33/reF1rGVNRCJFZKGIfOh7HQ7nXF1E3haRVb5/8zPC5Lx/6/v9XiYib4pIbKidt4hMEJEMEVlW7L1jnqOI/N53bVstIhee7OeFRSIQkUjgeaAf0Aa4RkTaeBuVXxQA96pqa6AH8BvfeT4AfKGqzYEvfK9DzV3AymKvw+GcnwE+UdVWQEfc+Yf0eYtIfeBOIEVV2wGRwBBC77wnAhcd9V6J5+j7Gx8CtPX9zAu+a16phUUiAFKBdaq6QVWPAFOAgR7HVOZUdYeqLvB9fwB3YaiPO9dXfbu9ClzmSYB+IiJJwCXAuGJvh/o5VwXOBsYDqOoRVc0mxM/bJwqoKCJRQCVgOyF23qo6C9hz1NvHOseBwBRVzVPVjcA63DWv1MIlEdQHthZ7ne57L2SJSGOgMzAHqK2qO8AlC6CWh6H5w9PA/wFFxd4L9XNuAuwGXvE1iY0TkThC/LxVdRvwJLAF2AHsU9VPCfHz9jnWOZ729S1cEoGU8F7IjpsVkcrAO8Ddqrrf63j8SUT6AxmqOt/rWMpZFNAFeFFVOwMHCf7mkBPytYsPBJKBekCciAzzNirPnfb1LVwSQTrQoNjrJNzjZMgRkWhcEnhdVaf73t4lInV92+sCGV7F5wdnAgNEZBOuye9cEXmN0D5ncL/T6ao6x/f6bVxiCPXzPh/YqKq7VTUfmA70JPTPG459jqd9fQuXRDAPaC4iySISg+tYmeFxTGVORATXZrxSVZ8qtmkGcJ3v++uA98s7Nn9R1d+rapKqNsb9u36pqsMI4XMGUNWdwFYRael76zxgBSF+3rgmoR4iUsn3+34eri8s1M8bjn2OM4AhIlJBRJKB5sDckzqyqobFF3AxsAZYDzzodTx+OsdeuEfCJcAi39fFQDxulMFa339reh2rn86/N/Ch7/uQP2egE5Dm+/d+D6gRJuf9F2AVsAyYDFQItfMG3sT1geTj7vhHHu8cgQd917bVQL+T/TwrMWGMMWEuXJqGjDHGHIMlAmOMCXOWCIwxJsxZIjDGmDBnicAYY8KcJQITNHzVNm8v9rqeiLztp8+6TEQe8n1/q4iM8H1/vYjUK8PP6S0iPYu9/vmzyuj4MSIyy1eXx5gS2fBREzR89ZM+VFd10t+f9QMwQFUzj3r/a+A+VU07iWNFqWrBMbY9DOSo6pOnEe6JPv/PuKKLr/vrM0xws0RggoaI/FQ1djXwGa60+Ieq2k5ErsdVY4wE2gH/AmKA4UAecLGq7hGRpr6fSwQOATer6qqjPqcF8JKq9vG9fhjIATbhygNvAw4DZ+DKmj8FVAYygetVdYcvYfyAK4ExAzeZ8Y++mLKAoUBFYDZQiCsgdwdupmyOqj4pIp2AMbgKm+uBG1V1r+/Yc4A+QHVgpKp+KyJtgVd8nxEBXKGqa0WkI/CYql58Kv/fTeizpiETTB4A1qtqJ1X9XQnb2wHX4krw/g04pK4g24/AT80tY4E7VLUrcB/wQgnHORNYcPSbqvo2bibvUFXthFv/4T/AYN/xJvg+9yfVVfUcVf0X8B3QwxfPFOD/VHUT7kL/b985fXvUR04C7lfVDsBS4M/FtkWpaipwd7H3bwWe8cWWgpuRCm4GbrcSztMYwFUwNCZUfKVuHYYDIrIP+MD3/lKgg68qa09gmitTA7jyBEeri7tDP5GWuOTzme94kbiyAD+ZWuz7JGCqr1hYDLDxeAcWkWq4RPKN761XgWnFdvmpoOB8oLHv+x+BB33rM0xX1bUAqlooIkdEpIrv/48xv2CJwISSvGLfFxV7XYT7XY8Asn13zMdzGKhWis8TYLmqnnGM7QeLff8f4ClVnSEivYGHS3H84/np3Arx/R2r6hsiMge3SM9MEblJVb/07VcByD3NzzQhypqGTDA5AFQ51R9WtzbDRhG5Ely1Vl/7+dFWAs1KEcNqIFFEzvAdL9rXTl+Sari+BfhfBcmjj1c81n3AXhE5y/fWcOCbo/crTkSaABtU9Vlcv0QH3/vxwE9lm435FUsEJmioahbwvW/R8idO8TBDgZEishhYTslLls4COkux9qNiJgJjRGQRriloMPAP3/EW4ZqeSvIwrknqW1yn8k8+AAaJyKJiF/2fXAc8ISJLcJVGHznBuV0NLPPF1grXxwCuU/mjE/ysCWM2asiYEojIM8AHqvq517GcLhGZDvxeVVd7HYsJTPZEYEzJ/o4bthnUfAsxvWdJwByPPREYY0yYsycCY4wJc5YIjDEmzFkiMMaYMGeJwBhjwpwlAmOMCXP/D3xj836H8c9QAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(result[\"x\"], label=\"x\")\n", "plt.plot(result[\"y\"], label=\"y\")\n", "plt.xlabel(\"time (iterations)\")\n", "plt.ylabel(\"field values\")\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The above plot shows the time evolution of the quantity *x* and *y*. The plot is not very meaningful, but at least we see that the values are well within the analog computer bounds $[-1,1]$.\n", "\n", "Let's run the simulation a bit longer and display a *phase space* plot of *x* and *y*:" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running: ./a.out --max_iterations=30000 --modulo_write=50\n" ] }, { "data": { "text/plain": [ "[]" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "result = run(arguments={\"max_iterations\":30000, \"modulo_write\":50})\n", "plt.xlabel(\"x\"); plt.ylabel(\"y\")\n", "plt.plot(result[\"x\"], result[\"y\"], \"o-\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That's it for the moment. If you want to see even more advanced plotting, inspect the `run-chua.py` file in the directory of this notebook file (i.a. in the `experiments/` directory)." ] } ], "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 }