{"nbformat":4,"nbformat_minor":0,"metadata":{"@webio":{"lastCommId":null,"lastKernelId":null},"colab":{"name":"linear_sysid.ipynb","provenance":[{"file_id":"https://github.com/RussTedrake/underactuated/blob/master/exercises/sysid/linear_sysid/linear_sysid.ipynb","timestamp":1620190976421}],"collapsed_sections":[]},"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.7.4"}},"cells":[{"cell_type":"markdown","metadata":{"id":"oTuAaWDCHYKo"},"source":["Welcome! If you are new to Google Colab/Jupyter notebooks, you might take a look at [this notebook](https://colab.research.google.com/notebooks/basic_features_overview.ipynb) first.\n","\n","**I recommend you run the first code cell of this notebook immediately, to start provisioning drake on the cloud machine, then you can leave this window open as you [read the textbook](http://underactuated.csail.mit.edu/sysid.html).**\n","\n","# Notebook Setup\n","\n","The following cell will:\n","- on Colab (only), install Drake to `/opt/drake`, install Drake's prerequisites via `apt`, and add pydrake to `sys.path`. This will take approximately two minutes on the first time it runs (to provision the machine), but should only need to reinstall once every 12 hours. If you navigate between notebooks using Colab's \"File->Open\" menu, then you can avoid provisioning a separate machine for each notebook.\n","- import packages used throughout the notebook.\n","\n","You will need to rerun this cell if you restart the kernel, but it should be fast (even on Colab) because the machine will already have drake installed."]},{"cell_type":"code","metadata":{"id":"83oQRibV0n5V","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1620251846677,"user_tz":240,"elapsed":59042,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"9f4ceed7-5654-41c4-ae0d-7537ec63b473"},"source":["import importlib\n","import sys\n","from urllib.request import urlretrieve\n","\n","# Install drake (and underactuated).\n","if 'google.colab' in sys.modules and importlib.util.find_spec('underactuated') is None:\n"," urlretrieve(f\"http://underactuated.csail.mit.edu/scripts/setup/setup_underactuated_colab.py\",\n"," \"setup_underactuated_colab.py\")\n"," from setup_underactuated_colab import setup_underactuated\n"," setup_underactuated(underactuated_sha='975f925803f947c5bacf4dd28b7aa880c77c2039', drake_version='0.27.0', drake_build='release')\n","\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","import pydrake.all\n","from pydrake.all import (\n"," LinearSystem,\n"," DiagramBuilder, PiecewisePolynomial, TrajectorySource,\n"," LogOutput, Simulator, LinearQuadraticRegulator\n",")\n","from pydrake.solvers.mathematicalprogram import MathematicalProgram, Solve\n"],"execution_count":1,"outputs":[{"output_type":"stream","text":["Cloning into '/opt/underactuated'...\n","\n","HEAD is now at 975f925 add linear_sysid exercise (#443)\n","\n","\n","WARNING: apt does not have a stable CLI interface. Use with caution in scripts.\n","\n","\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"wGn1Cg_yKeb3"},"source":["# Linear System Identification\n","\n","In this notebook, you will test different objective functions in linear system identification. Consider a discrete-time linear system of the form\n","\n","$$x[n+1] = Ax[n]+Bu[n]$$\n","where $x[n]\\in\\mathbf{R}^p$ and $u[n]\\in\\mathbf{R}^q$ are state and control at step $n$.\n","The system matrix $A\\in\\mathbf{R}^{p\\times p}$ and $B\\in\\mathbf{R}^{p\\times q}$ are unknown parameters of the model, and your task is to identify the parameters given a simulated trajectory.\n","\n","Let's first define a test system:"]},{"cell_type":"code","metadata":{"id":"ZjtocMexV9_5","executionInfo":{"status":"ok","timestamp":1620251846680,"user_tz":240,"elapsed":59035,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}}},"source":["A = np.array([[0.8, -0.1, 0.0, 0.0], \n"," [0., 0.2, 0.0, 0.1], \n"," [0., -0.1, 1.0001, 0.0], \n"," [0., 0.2, 0.0, 0.1]])\n","\n","B = np.array([[0.0], [-0.02], [0.01], [-0.02]])\n","C = np.identity(4)\n","D = np.zeros((4,1))"],"execution_count":2,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"CO9zOdhJHS3N"},"source":["Let's run a simulation to obtain the trajectory data. We add noise to the state representing measurement noise."]},{"cell_type":"code","metadata":{"id":"LiijCdD6V-HA","colab":{"base_uri":"https://localhost:8080/","height":295},"executionInfo":{"status":"ok","timestamp":1620251847119,"user_tz":240,"elapsed":59468,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"1679111b-03a6-4123-b068-c4be1c26b3a0"},"source":["def generate_data(A, B, C, D, noise_level = 1e-5):\n"," # Define a Linear system\n"," sys = LinearSystem(A, B, C, D, time_period = 0.1)\n","\n"," ts = np.arange(0, 100, 0.1)\n"," utraj = PiecewisePolynomial.CubicShapePreserving(ts, np.sin(0.1*ts).reshape((1,-1)))\n","\n"," builder = DiagramBuilder()\n"," plant = builder.AddSystem(sys)\n","\n"," usys = builder.AddSystem(TrajectorySource(utraj)) \n"," builder.Connect(usys.get_output_port(), plant.get_input_port())\n","\n"," logger = LogOutput(plant.get_output_port(), builder)\n"," diagram = builder.Build()\n","\n"," simulator = Simulator(diagram)\n"," simulator.AdvanceTo(ts[-1])\n","\n"," t = logger.sample_times()\n"," U = utraj.vector_values(logger.sample_times())\n"," X = logger.data()\n"," X = X + np.random.normal(size = X.shape)*noise_level\n","\n"," return t, U, X\n"," \n","\n","t, U, X = generate_data(A, B, C, D)\n","\n","\n","fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n","ax[0].plot(t, X.T)\n","ax[1].plot(t, U.T)\n","ax[0].set_title(\"state\")\n","ax[1].set_title(\"control\")\n","ax[0].set_xlabel(\"time\")\n","ax[1].set_xlabel(\"time\")\n","plt.show()"],"execution_count":3,"outputs":[{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAlMAAAEWCAYAAABCPBKqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXycd3Xo/88Z7bs12jdL8m7HS2xr8Z59I5AQoDRJgcAvaQgNUOC2t1B6KTd9tTdt7y0pkEIpUEihEEgIBOLsthM7lizJjp3YcWzLkqx9X619NN/fH5pJFEWyJGtmnlnO+/Wal0czzzzPkf145sz3e57zFWMMSimllFLq8tisDkAppZRSKpBpMqWUUkoptQiaTCmllFJKLYImU0oppZRSi6DJlFJKKaXUImgypZRSSim1CJpMKaWUUj4mIgdE5D6r41CeocmU8igR+aaI/GwB218tIo3ejEkppTxpoe9zKvhpMqWUUkp5kEzSz9cQov/Y6rKJyF+JSJOIDIjIGRG5Ffhr4I9F5KKInHBt9xkROe3arkZEPut6PA54Fsh2bX9RRLJFxCYiXxWR8yLSJSK/EhG7db+pUiqQiUieiPxGRDpc7ynfdb3P/I2IXBCRdhF5TESSXNsXiIgRkXtEpF5EOkXk667nbmbm97kDIvL3IvIaMAQsE5EdIlIpIn2uP3dY9XegvEuTKXVZRGQ18Hmg2BiTANwEvA38A/C4MSbeGLPJtXk78EEgEfgM8C0R2WKMGQRuAZpd28cbY5qBLwAfBq4CsoEe4FEf/npKqSAhImHAH4ALQAGQA/wS+LTrdg2wDIgHvjvt5buA1cB1wDdEZK0x5jlmfp8D+CRwP5AADADPAN8GUoB/AZ4RkRSP/5LKcppMqcs1AUQB60QkwhhTZ4w5P9OGxphnjDHnzaRXgBeA3ZfY9wPA140xjcaYUeCbwMdEJNzDv4NSKviVMPml7C+NMYPGmBFjzCHgT4B/McbUGGMuAl8D7pz2PvO/jTHDxpgTwAlg0/v2/l4/McacMsY4gBuBc8aY/zLGOIwxv2DyC+eHPP0LKutpMqUuizGmGvgSk4lOu4j8UkSyZ9pWRG4RkXIR6RaRXuADQOoldp8PPCUiva7tTzOZvGV49JdQSoWCPOCCK8GZKpvJ0Sq3C0A4732faZ1yf4jJ0atLabjE/t3HyJkrYBV4NJlSl80Y89/GmF1MJj8G+EfXn+8QkSjgSeD/AhnGmCXAXkDcu5lh1w3ALcaYJVNu0caYJm/9LkqpoNUALJ1hZLuZyfcut6WAA2ibxz5net+a/vj0/buPoe9jQUiTKXVZRGS1iFzrSpZGgGHAyeQbUcGUK1kimZwO7AAcInILk8Pfbm1Airvw0+X7wN+LSL7rWGkicrt3fyOlVJCqAFqAh0UkTkSiRWQn8AvgyyJSKCLxvFsHNX0EaybT3+dmshdYJSJ3i0i4iPwxsI7J+i0VZDSZUpcrCngY6GRyKDydyZqDX7ue7xKRY8aYAeCLwK+YLCS/G3javRNjzNtMvqnVuKb1soF/dW3zgogMAOVAqU9+K6VUUDHGTDBZp7QCqAcagT8Gfgz8F/AqUMvkl8IvzHO373mfm+W4XUxeePM/gC7gfwIfNMZ0Xt5vovyZGDPbaKVSSimllJqLjkwppZRSSi2CJlNKKaWUUougyZRSSiml1CJoMqWUUkoptQiWdZROTU01BQUFVh1eKWWBo0ePdhpj0qyOwxP0PUyp0HKp9y/LkqmCggKqqqqsOrxSygIiMr0jdMDS9zClQsul3r90mk8ppZRSahE0mVJKKaWUWgRNppRSSimlFkGTKaWUUkqpRdBkSimllFJqETSZUkoFBRH5sYi0i8jJWZ4XEfm2iFSLyBsismXKc/eIyDnX7R7fRa2UCgaaTCmlgsVPgJsv8fwtwErX7X7gewAiYgf+FigFSoC/FZFkr0aqlAoqlvWZUkr5h77RPo60HKFhoAERYXnSckqzSokOj7Y6tAUxxrwqIgWX2OR24DFjjAHKRWSJiGQBVwMvGmO6AUTkRSaTsl94N2LfMsbwZlMfr9f3MjAyTkZiNDtXpJK9JMbq0FSAMMZwsqmf1xt6GBhxkBYfxY4VKeQmx1odmuU0mVIqRA2MDfDo8Ud54uwTjE6Mvue5+Ih4PrXuU3xm/WcCLqm6hBygYcrPja7HZnv8fUTkfiZHtVi6dKl3ovSCg+c6+PtnTvN268B7HheBD6zP4msfWKMfiOqSDp/v5O/+cJrTLf3ve+6mKzL4m1vXkWcP3XNIkymlQtAbHW/wF6/8Be1D7dy2/DbuWHkHq5NX4zRO3uh8g1+d+RX/duLfeOHCCzxyzSPkJ+ZbHbJfMMb8APgBQFFRkbE4nDlNOA3/94UzfO/AefJTYnn4Ixu4enU6yXERXOga4nfHm/jJa3W8eraDf/njK7lhXYbVISs/43QavvXSWb6zr5o8ewz/cMcGrl0zeQ7Vdw3x+xPN/Pi1Om5+5FX+38ev5Ob1mVaHbAmtmVIqxJQ1l3HfC/dhExuP3fIYD+18iM3pm4mNiCU+Mp4d2Tt45JpH+N7136NruItPPfspznSfsTpsT2gC8qb8nOt6bLbHA5rTafiLX5/gewfOc3fpUl748h7uLFlKZlI0UeFhrMpI4C9vWsNzX9pDYVocn/2vKn5zrNHqsJUfcToN//PJN/jOvmr+uCiPF798FXeXvnsOrcxI4Cs3rua5L+1mVWYCn/v5UX5V1TD3joOQJlNKhZA3O97kC/u+QG5CLj/7wM/YmLZx1m135eziJ7f8hAhbBH/6wp/SMBDwb5JPA59yXdW3DegzxrQAzwM3ikiyq/D8RtdjAe1///4UT73exF/cuIp/uGMDUeFhM26XZ4/lF3+6jW3LUvjLJ97glbMdPo5U+at/2HuaJ4428ufXreThj24gOmLmcyg3OZb/vm8bu1em8dUn3+Dl020+jtR6mkwpFSJaB1v5wr4vkBqTyn/c8B+kxqTO+ZplScv44Y0/ZMJM8PmXP8/FsYs+iPTyiMgvgDJgtYg0isi9IvKAiDzg2mQvUANUA/8B/BmAq/D874BK1+0hdzF6oPp1VQM/LbvAfbsKefCaFXNuHxcVzr9/ciurMhJ48OfHuNA16IMolT97+kQzPzxUy6d3FPCl61ciIpfcPiYyjO/9yRauyE7iC794nZoO/32v8AZNpoJAx1AHx9qOcaLjBH2jfVaHo/yQ0zj5+qGvM+QY4tHrHiUlJmXery1IKuBbV3+Luv46/uHIP3gxysUxxtxljMkyxkQYY3KNMT8yxnzfGPN91/PGGPOgMWa5MWaDMaZqymt/bIxZ4br9p3W/xeJVtw/wv353ku3LUvjqLWvm/BB0S4iO4If3FGET+OIvjzM+4fRypMpf1XYO8rUn36AoP5m/uXXtvM+huKhw/uNTRUSG2/jCL15n1DHh5Uj9hyZTAcoYwzM1z/Dx33+ca399Lfc8dw+f2PsJ9jy+h8+++FmOth21OkTlRx479RgVrRV8reRrLF+yfMGvL8kq4bMbP8vva37Ps7XPeiFC5QlOp+GvnnyT6Igw/vWuKwkPW9hbfM6SGB7+6EZONPTyvQPnvRSl8mdOp+F/PnGC8DAb375r84LPocykaP75Y5s41dzPo/tD5xzSZCoAdQ538rmXPsdXD36Vcec4X9n6Ff79+n/nu9d+l3vX30t1TzWffu7TPFT2ECOOEavDVRZrGGjgO69/h2vzruXDKz582fu5f+P9bEjdwMMVD9M/9v7Lo5X1fl5Rz9ELPfzNretIT7i8lhYf2JDFrRuyeHR/NQ3dQx6OUPm7J441UlnXw19/YM1l9yC7YV0Gt1+ZzfcPnA+Z6T5NpgJMfX89n9j7CY62HeXrpV/nydue5DPrP8OOnB1clXcVX9zyRf7wkT/wmSs+w6/P/poHXnqAwXGtfwhl/1T5T4Tbwvnr0r+e93D9TMJt4fyvbf+L3tFevnPsOx6MUHlCz+AY//Tc2+xckcJHt8zYJmve/uaDawmzCd98+pSHolOBoHdojP+z9zRF+cn80da8uV9wCV+/dS1R4Tb+9ulTTPbJDW6aTAWQ1sFWPvP8ZxgcH+Q/b/5P7lxzJzZ5/z9hTHgMXyn6Cv+055843n6cB158QEeoQtTBxoMcaDjAA5seICNu8T2E1qas5c7Vd/L4mceDpV1C0Hh0fzWDow6+8cErFpU0A2QlxfDn163k5bfbKTvf5aEIlb/7/is19A6P89Dt67HZFncOpSdE8+UbVnHwXCeHqjs9FKH/0mQqQAyND/Hgyw8yOD7ID2/8IetT18/5mlsKb+Ef9/wjxzuO843D3wiJbwfqXU7j5JFjj7A0YSmfWPsJj+33wc0PEh8Zz7df/7bH9qkWp7FniMfKLvDRLbmszkzwyD7v2VFAZmI0//eFM/reEQLaB0b4yeFabtuUzbrsRI/s80+2LSVnSQz//Hzwn0NzJlMikici+0XkLRE5JSJ/PsM2V4tIn4gcd92+4Z1wQ9fDFQ9zrucc/++q/8dq++p5v+6mgpv48y1/zrO1z/Lfb/+3FyNU/ubFCy9ytucsn7vyc0SERXhsv4mRifx/6/8/Xm18ldfbX/fYftXle3R/NQh8+YZVHttndEQYX7xuJUcv9LDv7XaP7Vf5p0f3VTM+Yfjy9Z47h6LCw/jS9St5o7GP5062emy//mg+I1MO4H8YY9YB24AHRWTdDNsdNMZc6bo95NEoQ9wLdS/wVPVT3LfhPnbm7Fzw6+9dfy+7c3bzraPfoqa3xgsRKn8z4Zzg347/G8uTlnNLwS0e3//da+4mNSaVfz32rx7ft1qYtv4RnjzaxMeLcj2+aPEfFeWy1B7Ld/ZVB/3IQihr6x/hFxUNfLwol4LUOI/u+47NOSxLjePRA8F9Ds2ZTBljWowxx1z3B4DTzLIIqPK8vtE+/q7871ifsp7PXfm5y9qHiPDQzoeICY/h64e+zoQzdHp/hKoXLrxATV8Nn7vyc4TZZu5avBixEbHct+E+3up6i6aLAb/ySkD70aFaHE4n9+9eeMuLuUSE2fjT3YUcb+il6kKPx/ev/MNPDtcx7nTywFWeP4fCw2z86Z5lnGzqD+r6uwXVTIlIAbAZODLD09tF5ISIPCsiV3ggNgV8+9i3GRgb4Js7vkmE7fKnalJjUvlaydc42XWSp6qf8mCEyt8YY/jpqZ9SkFjADfk3eO04H1v1MZ7/6PPkxOt3K6v0DY3z8/ILfGhTNktTYr1yjI9tzSM5NoJ/f0VHtYPR4KiDn5df4OYrMslP8eyolNsdm3NIjY/i318N3nNo3smUiMQDTwJfMsZMbzJzDMg3xmwCvgP8dpZ93C8iVSJS1dGh6z/N5VTXKX599tfcteauBdVJzeaWwlvYmrGVfz32r9opPYgdaz/Gqa5TfHLdJ2e82tNTosKiSI5O9tr+1dx+WVnP4NgEn93j+REFt5jIMD65vYCXTrdxPkR6BoWSX1U10D/i4L7dy7x2jOiIMD69I59XznZwuiU4e9TN651WRCKYTKR+boz5zfTnjTH9xpiLrvt7gQgRed/CX8aYHxhjiowxRWlpaYsMPfg9cvQRkqOT+bMr/8wj+xMRvlbyNfrH+vnBGz/wyD6V/3ns1GMkRSXxoeUfsjoU5UVOp+G/K+opKbR77Oqr2dyzPZ/IcBs/PVzn1eMo33I6Df/5Wh1bli5ha753vxh9Yls+0RE2Hiu74NXjWGU+V/MJ8CPgtDHmX2bZJtO1HSJS4tpv8E6O+kBlayXlLeXcu/5eEiI9c6kzwGr7aj607EM8fuZxOoZ0dDDY1PfXs79hPx9f9XFiwj1bjKz8y8HqTi50DfGJbfleP1ZKfBS3bsjiqWNNDI05vH485RuHz3dR3z3EPTsKvH6sJbGRfGhjNr873sTAyLjXj+dr8xmZ2gl8Erh2SuuDD0xbjf1jwEkROQF8G7jTBHPZvpcZY/ju698lPSadj6/+uMf3/9lNn8XhdPDDN3/o8X0raz1+5nHCJIw719xpdSjKy35WfoHU+EhuviLTJ8e7u3QpA6MOfn+i2SfHU973i4p6lsRGcJOPzqE/2ZbP0NgEvzsefOfQfK7mO2SMEWPMximtD/ZOW439u8aYK4wxm4wx24wxh70fevAqaynjWPsx7t94P9Hhl7e+1qXkJeTx4RUf5tdnf03rYHD3/gglYxNjPH3+aa5Zeg3pselWh6O8qLl3mJdPt/Hxojwiw33Te7koP5mV6fH895F6nxxPeVfHwCjPn2rlo1tyiY7w/BW/M9mUm8S6rER+fqQ+6NokaAd0P/TTUz8lNSaVO1be4bVj3L/xfpzGyc/e+pnXjqF8a1/DPnpHe/nIyo9YHYrysl9XNWKAu0qW+uyYIsLdpUs50djHySa9gCXQPXmsEYfTcFfJ4tbgWwgR4U+2LeV0Sz8nGoPrHNJkys+c6znH4ebD3L3mbiLDIr12nOz4bG4suJEnzz3JxTG9QicYPHn2SbListietd3qUJQXGWN46vVGthWmkGf3TjuE2Xxkcy6RYTZ+c0x7iwUyYwyPVzZQUmBnRbrnanLn47ZN2USF23jqWKNPj+ttmkz5mcfeeozosGj+aNUfef1Y96y7h4vjF/nNufddoKkCTONAI+Ut5dyx8g6vNOkMBCJys4icEZFqEfnqDM9/a0rd51kR6Z3y3MSU5572beQL83pDL3VdQ9yxxff9vZJiI7h2TTpPn2jGMeH0+fGVZxxv6KW2c5CPbc31+bEToiO4YV0Gv3+jhfEgOoc0mfIjncOdPFPzDLevuJ0l0Uu8frwrUq9ga8ZWfn765ziceoVOIPtt9W8RhDtWeG9q2J+JSBjwKHALsA64a/qyV8aYL7vrPpnshzf1W8TwlJrQ23wW+GV46lgTUeE2blnvm6Lh6T68OYfOi6Mcqu605Phq8X53vJnIcBs3b7DmHLpjcw7dg2O8ciZ4rijXZMqPPHH2Ccad43xi7Sd8dsxPrvskzYPNvNLwis+OqTzLGMMzNc9QmlVKZpw1b45+oASoNsbUGGPGgF8Ct19i+7uAX/gkMg8aczj5wxvN3HhFJgnRnlu8eiGuWZNGYnQ4v31dp/oCkWPCyR/eaOHa1ekkWnQO7VmVhj0ukqeC6BzSZMpPTDgn+M2537AtaxsFSQU+O+5VuVeRHpvOE+ee8NkxlWe90fkGjRcbuXXZrVaHYqUcoGHKz43MsoaoiOQDhcC+KQ9Hu1ZnKBeRD892EKtXcXjlbAc9Q+PcsTnb58d2iwoP49aN2Tx/qo3BUR3RDjSHz3fReXGUD1t4DkWE2fjQxixePN1Gf5D0nNJkyk+UtZTRMtjCR1d91KfHDbeF85GVH+G1ptdovhh8vT9Cwd6avUTaIrlu6XVWhxIo7gSeMMZMXfE73xhTBNwNPCIiM67PYvUqDr99vYmUuEh2r7R2BYmPbMlheHyCF97S1iqB5nfHm0mICufq1da2T7ljSy5jDifPnQyOc0iTKT/x5NknSY5K5tq8a31+7I+smLyUXgvRA4/D6eC5uue4Ku8qj3bKD0BNwNRrvHNdj83kTqZN8Rljmlx/1gAHmFzQ3a8Mj02w7+12PrAhi4gwa9+6ty5NJjMxmr1vBscHYagYGZ/g+VOt3Lw+02e9pWazKTeJnCUxmkwpz+kc7uRAwwFuW36bV9shzCYrPotdObt4qvopLUQPMEdajtA90s2thSE9xQdQCawUkUIRiWQyYXrfVXkisgZIBsqmPJYsIlGu+6lMrvrwlk+iXoBXzrYzPD5hWeH5VDabcPP6TF4528FFneoLGAfOTP573XaldVN8biLCBzZkcvBcR1BM9Wky5Qd+f/73OIyDj6yyrtniR1d9lPahdg43a/P6QLK3di8JEQnsyt1ldSiWMsY4gM8DzwOngV8ZY06JyEMiMvXqvDuBX05b7motUOVaDms/8LAxxu+SqWdPtpIcG0FJod3qUAC4ZX0mYw4n+99utzoUNU/Pn2olKSaCbctSrA4FgJvXZzE+YXj5dJvVoSxauNUBKPhDzR/YmLaRZUnLLIthT84elkQt4Q/n/8Ce3D2WxaHmb2xijH31+7g+/3qiwqKsDsdyxpi9wN5pj31j2s/fnOF1h4ENXg1ukUYdE7x8up0Pbswi3OIpPreiAjup8ZE8d7KVD22yfqRDXdr4hJOXT7dx/boMy6eJ3TbnLSEzMZpn32zljs2+73nlSf7xNxrCzvWc42zPWcunaSLCIrip4Cb2N+xncHzQ0ljU/BxpOcLF8YvckH+D1aEoLzt0rpOLow5u9oMpPrcwm3DjFZnse7ud4bGJuV+gLFVe00X/iMNnC2PPh3u6+EAQTBdrMmWxZ2qeIUzCuKngJqtD4YPLPsjIxAgv179sdShqHl6uf5m4iDi2ZW2zOhTlZc+ebCUhOpwdy1OtDuU9PrA+i+HxCV45GzzNF4PV86daiYkIY88qa68EnS5Ypos1mbKQ0zh5tvZZtmVvIyXG+jnsTWmbyInP4ZmaZ6wORc1hwjnBvvp97MndY8lFC8p3xiecvPhWGzeszSAy3L/eskuX2VkSG8FzJ1usDkVdgtNpeOFUG1etSrP8Kr7pJqeLowL+qj7/+p8ZYo63H6d5sNnyKT43EeHWZbdS3lJO57AuFeHPjrUfo2e0h+uXXm91KMrLjl7ooW94nBuvyLA6lPeJCLNx7Zp09p/p0LX6/Njxxl7aB0a5ab3/nUNhNuG6Nem8eraDMUfgnkOaTFnomZpniA6L9qtmi7cuuxWncbK3Zu/cGyvLvFz/MlFhUezKCe2r+ELBvrfbiQyzscviRp2zuW5NBn3D4xyr7517Y2WJ50+1Em4Trl3tf8kUwHVr0xkYdVBV1211KJdNkymLTDgneKn+Ja7Ku4rYiFirw3nHsqRlrLWv5YULL1gdipqFMYaXLrzEjuwdfnXuKO94+XQbpcvsxEf558XXe1alEm4TXn478C9vD1YvvdXG9uUpJMVasxbfXHauSCUy3MbLAVw3pcmURY61H6N7pNsvr8S6Pv96TnScoG1Q3xz90amuU7QNtXF9vk7xBbsLXYOc7xjk2jXWLv1xKQnREZQus7PvdOB+EAaz+q4hvz+H4qLC2b4shZdPt/HeFnCBQ5Mpi7inaXbn7LY6lPdxf0jrVX3+aX/Dfmxi46rcq6wORXnZPtc3dX/+IAS4dk0G59ovUt81ZHUoapoDZyfPoWssXotvLtevTaeua4iazsBszaPJlAX8fZpmWdIylict56X6l6wORc3gYONBrky7kqSoJKtDUV627+12lqfFkZ8SZ3Uol3SdK9nbp1N9fmf/2+0UpsZRkOrf59A17nMoQEc4NZmyQCBM01yffz1H247SNdxldShqivahdk53n2Z3rv+NaCrPujjqoLymi+vW+mfR8FQFqXEsS4sL6JqXYDQyPsHh811c5We9pWaSmxzLmsyEgK2902TKAi9eeJFwCffraZob8m/AaZzsa9hndShqioONBwF0yZ8QcOhcB+MTxu+n+NyuX5vBkZrugO9kHUzKaroYdTjfGfXxd9etTaeyroe+ocBb+FiTKR9zT/EVZxb79TTNquRV5CXk8dIFnerzJ682vkpmXCYrl6y0OhTlZS+fbichOpyt+clWhzIv16xOZ2zCyWvV2qPOXxx4u53oCBulfrI49lyuWZ3OhNPw2vnAO4c0mfKx6t5q6gfq/XqKDyYbeF6ffz0VLRX0jfZZHY5icmHjspYy9uTsQUSsDkd5kTGGV852sGdVmt8sSjuXrfnJxEaGcehc4H0QBiNjDPvPdLBzearfdT2fzZV5S0iICufVAFyeKDD+lwaRAw0HALgm7xprA5mHa/OuxWEcvNb0mtWhKKCqrYphx7BO8YWAs20XaR8YZc9K/1qL71Iiw21sX5bCwXOB90EYjGo6B6nvHuLqAJniAwgPs7FjRQoHz3UGXIsETaZ87NXGV1mXso60WP8vCNyQugF7tJ1XGl+xOhTFZL1UVFgUJVklVoeivMydkPhr1/PZ7FmVRl3XkLZI8APuhYOvDoDi86n2rEqjqXc44FokaDLlQz0jPZzoOOHXhedThdnC2JWzi0NNh3A4tajUaq82vkpxZjEx4TFWh6K87OC5TpalxZGzJLD+rXe7RtJe1dEpy7nPoTy7/7XfuZQ9ri8QgTbVp8mUDx1qOoTBBNQ0zVW5V9E/1s+JjhNWhxLS6vrqqB+oD6hzx9dE5GYROSMi1SLy1Rme/7SIdIjIcdftvinP3SMi51y3e3wb+XuNjE9wpLbrnQ+VQFKYOpkA6lSftUYdE1TUdrN7ReBME7vl2WMpTI3jYIDV3s2ZTIlInojsF5G3ROSUiPz5DNuIiHzb9Sb2hohs8U64ge1g40FSolNYl7LO6lDmbUf2DsJt4bzSoFN9VjrUdAjALzvm+wMRCQMeBW4B1gF3ichM/9EeN8Zc6br90PVaO/C3QClQAvytiFh2Cd2xCz2MjDvfGeUJJCLCnlWpHK7uwjHhtDqckPV6fS/D4xPsDMBkCiZHOMvOdzHqmLA6lHmbz8iUA/gfxph1wDbgwRnepG4BVrpu9wPf82iUQcDhdHCo+RC7cnZhk8AZEIyPjKcoo0jrpix2uPkw+Yn55CbkWh2KvyoBqo0xNcaYMeCXwO3zfO1NwIvGmG5jTA/wInCzl+Kc06vnOgm3CaXLUqwKYVF2r0xjYNTB8YZeq0MJWa9Vd2IT2LY8cM+h4fEJjl7osTqUeZvzU90Y02KMOea6PwCcBnKmbXY78JiZVA4sEZEsj0cbwI63H2dgbCAgp2muyr2Kmr4aGvobrA4lJI1PjFPVVsW2rG1Wh+LPcoCpJ2gj73+fAvioa/T8CRHJW+BrEZH7RaRKRKo6OrwzlXWouoMt+cnER4V7Zf/etnN5KjaZTAqVNQ5Vd7IpbwmJ0RFWh3JZti9PIdwmATXVt6AhEhEpADYDR6Y9Na83I1+8EfmrV5teJVzC2ZG9w+pQFsxdMK+jU9Y43nGcYcdwQJ47fub3QIExZiOTo08/XegOjDE/MMYUGWOK0tI8X9PUdXGUk039AVnr4pYUG8GmvCVaN2WR/pFxTjT0siuAz6H4qH4QeCYAACAASURBVHC25CcHVBH6vJMpEYkHngS+ZIzpv5yDefuNyJ8dbDzI1oytxEfGWx3KguUl5rEsaRkHGg9YHUpIKmsuI0zCKM4stjoUf9YE5E35Odf12DuMMV3GmFHXjz8Ets73tb5yyNU9fHeAXc4+3e6VaZxo6KVvOPCWBQl05ee7cBoCtl7Kbc/KVE4199MzOGZ1KPMyr2RKRCKYTKR+boz5zQyb+M2bkT9quthEdW91QC9Ouyd3D8fajjE0rv1jfK2suYyNaRtJiEywOhR/VgmsFJFCEYkE7gSenrrBtNKD25gsWQB4HrhRRJJdhec3uh7zuUPnOkmKiWBDjv8uNTUfO5an4DRQUdttdSgh57XqTmIiwtiyNDCWIZrNdle9V3lNl8WRzM98ruYT4EfAaWPMv8yy2dPAp1xX9W0D+owxLR6MM6C5O4gHcjK1I3sH487J2h3lO70jvZzqOsX2rO1Wh+LXjDEO4PNMJkGngV8ZY06JyEMicptrsy+6rkg+AXwR+LTrtd3A3zGZkFUCD7ke8/XvwGvVnWxflkKYLbCXC9q8dAlR4TbKzgfGB2EwOVTdSekyO5HhgXOh00w25i4hNjKMwwFyDs2nwnEn8EngTRE57nrsr4GlAMaY7wN7gQ8A1cAQ8BnPhxq4DjcfJisui8LEQqtDuWxbMrYQHRbNa02vBWQRfaA60noEg2F7tiZTczHG7GXyvWjqY9+Ycv9rwNdmee2PgR97NcA51HcP0dw3wgNXB+YVWFNFhYdRVJDM4QBcsDaQtfQNc75jkLtKllodyqJFhNkoKbRTFiAjU3MmU8aYQ8AlvyaZyUV0HvRUUMHE4XRQ0VLBDQU3BPTitFFhURRlFnG4+bDVoYSUsuYyEiISWJ+63upQlJe5pzO2B2hLhOl2LE/ln58/Q/fgGPa4SKvDCQmvVU+eQ4FeL+W2fVkK/+fZt2nvHyE9MdrqcC4psMcBA8DJzpMMjA8ExcjCzuyd1PXX0XRRy+F8wRhDWXMZxZnFhNsC8zJ5NX9l57tIjY9iRXrgXaQyk0CreQkGr1V3khofyeqM4Kiv3LF8MikMhNEpTaa8rKylDEHYlhn4PYJ25Exemu+uAVPeVT9QT/Ngs7ZECAHGGMpquti2zB7QI9hTbchJIi4yTKf6fMQYQ9n5LrYtS8EW4DV3buuyE0mMDg+I2jtNprysvLmcdSnrWBK9xOpQFq0wsZCsuCyd6vORsuYygKAY1VSXVtc1RFv/KNuCZIoPptS8BMAHYTBo7BmmtX+E0kK71aF4TJhrJYBAKELXZMqLLo5d5ETHiaD5MBQRdmTv4EjLEcad2j/G2w43HyYnPoe8hLy5N1YBzZ1wbA/Q5T9ms315Cuc7BmnrH7E6lKDnbkNRHETJFEy22ajvHqKxx7/b8mgy5UWVrZVMmImgmqbZmbOTi+MXebPjTatDCWoTzgmqWieXkAmWaR81u7KaLtIToliWGmd1KB7lrnnRuinvq6zrJikmglXpwVEv5eb+guHvI5yaTHnR4ebDxITHsCltk9WheExJZgk2sfFas9ZNedOZnjMMjA9o1/MQYIyhvGay1iXYEue1WYkkxURwuNq/PwiDQUVdN0X5yUFTL+W2Kj2BlLhITaZCWXlLOUUZRUSGBc9lwUlRSWxI3cDhJq2b8qbK1koAijKKLI5Eedv5jkE6BkaDbooPXDUvhXYO12gRujd1DIxS0zEYdFN8ADabsG35ZN3UZBcm/6TJlJc0X2ymrr8uaOqlptqZvZNTXafoHem1OpSgVdVWRX5iPhlxGVaHorysLMj6S023Y3kKDd3DNHT7d81LIKuqc9VLFQRfMgWT/zda+0eo6/Lfc0iTKS9xX4kVTPVSbtuzt2MwVLRWWB1KUJpwTnC07aiOSoWI8vNdZCVFk58Sa3UoXrHNNeKm6/R5T0VdN9ERtoBf03E27qtcK2r9d6pPkykvKWspIz0mnWVJy6wOxeOuSL2C2PBYjrQcsTqUoHS25ywDY1ovFQqCuV7KbVV6AktiIzSZ8qLKum425yUH/Hp8s1meFkdKXCRH/PgcCs6/eYs5jZMjLUfYlh2cV2JF2CIoyiziSKsmU96g9VKh41z7RboGx4J2ig8ma16KC+xU1PnvB2EgGxgZ563m/qCsl3ITEUoK7X6dkGsy5QXnes7RO9rLtqzA73o+m5LMEi70X6B1sNXqUIJOZVslSxOWar1UCHhnPb4gLD6fqrTQTm3nIO3ab8rjjtX34jRQEqT1Um4lhXYae4Zp6h22OpQZaTLlBe6RhWCepnEnijrV51nueqlgPnfUu47UdpOdFE1ucozVoXhViWvUREenPK+itoswm7B5aeCvsnEp75xDflo3pcmUF1S2VpIbn0tmXKbVoXjNyuSVJEclazLlYe56qaJMneILdsYYKmu7KS4MnvX4ZrMuK5G4yDC/nqYJVJW1PazPTiQuKrgXQ1+TmUhCdLjfnkOaTHmY0zg52h78Iws2sVGSVcKRliN+3fsj0FS1VQFaL3U5RORmETkjItUi8tUZnv+KiLwlIm+IyMsikj/luQkROe66Pe2LeOu7h2gfGKUoyKdnAMLDbGzJT/bbD8JANeqY4Hhjb9C2RJgqzFV7569F6JpMedi5nnP0jfYFfTIFUJpVSvtwO7X9tVaHEjQqWyfrpYJ5VNMbRCQMeBS4BVgH3CUi66Zt9jpQZIzZCDwB/NOU54aNMVe6brf5ImZ3YhHstS5upYV23m4doHdozOpQgsYbjX2MOZzvTIEFu9JCOzWuJrf+RpMpDwulkYXSzFIAKlq035QnOI1T66UuXwlQbYypMcaMAb8Ebp+6gTFmvzHG3fWvHMj1cYzvUVXXQ1JMBCvT460Mw2dKCieL7CvreiyOJHi8s7hxiCTk7qSx0g9r7zSZ8jB3vVRWfJbVoXhdXkIeWXFZWjflIWd7ztI/1s/WjK1WhxKIcoCGKT83uh6bzb3As1N+jhaRKhEpF5EPz/YiEbnftV1VR0fHogKurOumuCD41lKbzcbcJCLDbX5bQByIKuu6WZkeT3Jc8CxZdinrc5KIifDP2jtNpjzIaZxUtVWFTPGwiFCaVUpFawUTzgmrwwl4oXAVqD8QkU8ARcA/T3k43xhTBNwNPCIiy2d6rTHmB8aYImNMUVpa2mXH0DEwSk3nYEjUS7lFR4RxZd4Sv/wgDEQTTsPRup6g7i81XUSYja35yX5ZN6XJlAeFUr2UW2lWKf1j/bzd87bVoQS8ytZK8hLytF7q8jQBeVN+znU99h4icj3wdeA2Y8w7hRfGmCbXnzXAAWCzN4MN9rXUZlNaaOdkcz8XRx1WhxLwTrf0MzDqCJmaO7eSQjtvt/bTNzRudSjvocmUB4VSvZSbu25Kp/oWR+ulFq0SWCkihSISCdwJvOeqPBHZDPw7k4lU+5THk0UkynU/FdgJvOXVYOt6gnottdmUFNqZcBqOXdC6qcVy1w2F0sgUTJ5DxkDVBf8andJkyoOqWqvIic8hOz7b6lB8Ji02jWVJy7QIfZHO9Zyjf6w/pBJxTzLGOIDPA88Dp4FfGWNOichDIuK+Ou+fgXjg19NaIKwFqkTkBLAfeNgY4+Vkqpsr85YE7Vpqs9myNJkwm+hUnwdU1nWTsySGnCXB3fB1uivzlhAZZvO7cyi4u3z5kLte6uq8q60OxedKs0r5bfVvGZ8YJyIswupwApLWSy2eMWYvsHfaY9+Ycv/6WV53GNjg3ejedXHUwanmPh68ZoWvDuk34qLCWZ+T5HcfhIHGGENFbQ+7V6ZaHYrPRUeEsSkvye/qpkLra5EXVfdW0zvaG5IjC6VZpQw7hjnRccLqUAJWKHTNV5OOXejBaUKvXsqttNDO8YZeRsb1opXLVds5SOfF0ZA9h0oK7Zxs6mPQj2rvNJnyEPfIQqhcyTdVUUYRgrzzd6AWxj2qqaNSoaGqrhubwJb8ZKtDsURJgZ2xCScnGnqtDiVgueulSgpD9BwqTMHhNByr95/aO02mPMRdL5UTf6nWNsEpKSqJtSlrOdKqReiXw10vpclUaKio6+aK7CTig3wttdm4R1N0qu/yVdT2YI+LZHlaaDR8nW5rfjI2gUo/Ooc0mfIA95VYoTjF51aaWcqJjhMMO4atDiXghOJVoKFqzOHk9frQWEttNkmxEazJTKDCD7tYB4rKum6K8pODfoHs2cRHhbMuO9GvzqE5kykR+bGItIvIyVmev1pE+qYsEvqNmbYLZud7z9Mz2hPSIwvFmcU4nA6Otx+3OpSAE0pd80PdyeY+Rh1OigtCc3rGrbjAzrELPTgmnFaHEnDa+keo7x4KmfX4ZlNcYOf1+l7GHP5xDs1nZOonwM1zbHNwyiKhDy0+rMASyvVSblsythAu4VS0aouEhdB6qdDinpYIpc7nMykutDM4NsHplgGrQwk47yyQHeLJVGmhnVGHkzeb+qwOBZhHMmWMeRXwn7E0P1TVVkV2XHZI1ku5xUXEsT51vfabWiB31/xQTsRDSWVdN8tS40hLiLI6FEu5u3b70zRNoKio7SYuMox1WYlWh2Ip9xcSf1n02FM1U9tF5ISIPCsiV8y2kScXCfUXxhiqWkNnPb5LKc4s5lTXKS6OXbQ6lICh9VKhw+k0VNb1hHS9lFtmUjR59hi/KiAOFJV13WzJTyY8LLRLnlPjo1iWFuc355An/jWOMblI6CbgO8BvZ9vQU4uE+hOtl3pXaVYpE2aCY+3HrA4lYFS2VoZc1/xQVd1xkb7hcYpCvF7KrbjATmVdN8YYq0MJGH1D45xpG9CE3KWkwE7VhR6cTuvPoUUnU8aYfmPMRdf9vUCEa32rkFDZpp2r3TalbSLSFqnr9M2TrscXWrTW5b1KCux0DY5xvmPQ6lACRtWFbkwIN3ydrrjATt/wOGfbra+9W3QyJSKZ4ro+U0RKXPvsWux+A0Vla2XI10u5RYdHsyl9kzbvnCd313xNpkJDZV036QlRLLXHWh2KX3Anlf5S8xIIKuq6iQgTNi9dYnUofsF9DvlDz7L5tEb4BVAGrBaRRhG5V0QeEJEHXJt8DDjpWiT028CdJkTGbbVe6v1KMkt4u/tteke0u/Fc3rkKVOulQkJlbTfFhfaQ7Q00XWFqHKnxkX5T8xIIKmu72Zi7hOiIMKtD8Qu5yTFkJkYHRjJljLnLGJNljIkwxuQaY35kjPm+Meb7rue/a4y5whizyRizzbVoaEhw10vph+G7SrNKMZh3CqvV7Nxd87VeKvg19Q7T3DdCcYguITMTEaG4wK5X9M3T8NgEbzT26RTfFCJCcaF/1N6F9uUAi+ROGHSa5l3rU9YTEx6j/abm4O4vpYl4aHCPvhRrvdR7FBfYaewZpqVPV06Yy+sNPTicJmTX45tNSUEybf2jNHRbew5pMrUIla2VZMVlab3UFBFhEWxJ36L9puag9VKhpaKum4SocNZkhnZvoOn8qebF31XW9iACW/M1IZ/K/QXF6hFOTaYukzHmnc7VWgPxXiVZJZzvO0/ncKfVofitqlZXfymttwsJlbXdbC1IJsym7xVTrc1KJD4qXIvQ56GyrpvVGQkkxURYHYpfWZU++Xdide2dJlOXqaavhu6Rbp2mmUFJZgmAXtV3CVVtk/VSOqrpOSJys4icEZFqEfnqDM9HicjjruePiEjBlOe+5nr8jIjc5Mm4egbHONd+UWtdZhBmE7bkJ+vI1BzGJ5wcq+/RthozsNmE4oJkyxNyTaYuk67HN7s19jUkRCRov6lZOI2TqtYqtmZstTqUoCEiYcCjwC3AOuAuEVk3bbN7gR5jzArgW8A/ul67DrgTuILJdUj/zbU/j6i60ANob6DZlBQkc7btIj2DY1aH4rdONfczNDahydQsigvs1HQO0jEwalkMmkxdpsrWSjLjMsmNz7U6FL8Tbgtna+ZWLUKfhXbN94oSoNoYU2OMGQN+Cdw+bZvbgZ+67j8BXOfqkXc78EtjzKgxphaodu3PIyrruokMs7ExN8lTuwwqJYUpwLtJp3o/9xRWiSbkM3LXTVVZODqlydRleKdeKkPrpWZTkllCw0ADLRdbrA7F77hHNTWZ8qgcoGHKz42ux2bcxhjjAPqAlHm+Fri89UWNMexamaq9gWaxMTeJyDCb5dM0/qyirpv8lFjSE6OtDsUvrc9OIjrCxhELp4s1mboMtX21dI9064fhJbjrpnR06v2q2qq0a36Aupz1Rb9+6zp+/Gl9r5hNdEQYm/KStG5qFk6noaquW6eJLyEy3MbmPGvrpjSZugzauXpuK5NXkhyVrMnUNNo132uagLwpP+e6HptxGxEJB5KYXPpqPq9VXlRcYOdkUx9DYw6rQ/E75zsu0jM0rlN8cygutHO6pZ+BkXFLjq/J1GWobKskIzaD3AStl5qNTWwUZRZxpOWI5Z1p/YnWS3lNJbBSRApFJJLJgvKnp23zNHCP6/7HgH2upa+eBu50Xe1XCKwE9FuADxUX2nE4DcfrdRmq6dz9k7Th66WVFNhxGjhqUe2dJlMLZIyhsrVS+0vNQ2lmKW1DbTQMNMy9cYiobNNRTW9w1UB9HngeOA38yhhzSkQeEpHbXJv9CEgRkWrgK8BXXa89BfwKeAt4DnjQGDPh698hlG3NT0YES2te/FVFbTep8VEUpOgC2ZeyeekSwmxi2VRfuCVHDWC1/VovNV8lWZN1U0daj7A0canF0fgH7ZrvPcaYvcDeaY99Y8r9EeCPZnnt3wN/79UA1awSoyNYm5moRegzqKztplQXyJ5TXFQ467MTqazVkamA4O5cXZyhydRcChILSItJ06VlXNz1UjqqqdT7lRTaeb2+l/EJp9Wh+I3GnqHJBbILdD2++SgusHO8sZdRh+8HljWZWqDK1krSY9O1XmoeRISSrBIqWiu0bop366V0ik+p9ysptDM8PsHJpj6rQ/EblVovtSDFhXbGHE7eaPT9OaTJ1AJovdTClWaW0j3Szfne81aHYjl3vZROESv1fu5L/3Wq710VtT26QPYCuM8hK9psaDK1ALX9tXSNdOkU3wJMrZsKdZWtlWTHZeuoplIzSEuIojA1jgqLal78UWWdLpC9EPa4SFamx1uSkGsytQDv1EvpyMK8uRfzDfVFj93r8Wl/KaVmV1yQTNWFbpxOLQvoujhKtS6QvWDFhXaO1vUw4eNzSJOpBahqrSI9Np28hLy5N1bvKMksobK1kgln6F5trv2llJpbcYGd3qFxqjsuWh2K5SrrJkfoSrVeakFKCuwMjDo43dLv0+NqMjVPxhgq2yopyijSeqkFKskqoX+snzM9Z6wOxTLuTvCaTCk1uxJX4qD9plwLZIfb2KALZC+Iu1jf11N9mkzNU11/HZ3DnfpheBnc6/SF8lRfVWvVO1OeSqmZLbXHkp4QRaUmU1TWdXNl3hKiwnWB7IXIWRJDzpIYTab8lTsR0GRq4dJj0ylILOBIS2gWoTuNk6q2Km2JoNQcRITiQjuVdd0h3U5lcNTBqeZ+XY/vMhUXJFNR2+PTc0iTqXmqaq0iLSaNpQnayftylGaVcrTtKONOaxahtNK5nnP0jva+c2WjUmp2pYV2WvpGaOwZtjoUyxyrnyyg1v5Sl6e40E7nxVHquoZ8dkxNpubBGENFa4X2l1qE4sxihhxDvNX1ltWh+FxVm3bNV2q+tN/UZJ8km8CWpUusDiUguUf0fDldrMnUPLj7S7lrf9TCuadHQ3FpmcrWSnLjc8mKz7I6FKX83uqMBBKjw0M+mVqXnUhCdITVoQSkFenxJMdGUOHDc0iTqXmobJmsl9Jk6vLZo+2sSl4Vcs073fVSWmun1PzYbEJRgd2SLtb+YNQxwfGGXu0vtQgik+eQLxNyTabmobKtkozYDO1cvUglmSUcbz/O2MSY1aH4zLmec/SN9mkypdQCFBfYOd8xSOfFUatD8bk3G/sYdTgpLUyxOpSAVlpo50LXEG39Iz45niZTc3Cvx1eSWaL1UotUklnC6MQoJzpOWB2Kz2h/KaUWrqQwGYCqEJzqc/fYKtHi80Xx9Tp9cyZTIvJjEWkXkZOzPC8i8m0RqRaRN0Rki+fDtM753vN0j3Trh6EHbM3cik1s7yQYoaCytZK8hDwy4zKtDkWpgLEhZwlR4baQXKfvSG03qzLiscdFWh1KQLsiO5HYyDCfTfXNZ2TqJ8DNl3j+FmCl63Y/8L3Fh+U/Ktu0v5SnJEYmsta+NmSK0J3GydG2o1pr52UiYheRF0XknOvP5Bm2uVJEykTklOtL3x9Pee4nIlIrIsddtyt9+xuo6SLDbWxeuiTkitAdE06O1nXrqJQHhIfZ2LI02X9GpowxrwKXiuZ24DEzqRxYIiJBc9lSZWsl2XHZWi/lISVZJbzR+QZD477r/2GVM91n6B/r18WNve+rwMvGmJXAy66fpxsCPmWMuYLJL4ePiMjU687/0hhzpet23Pshq7mUFNg51dzHxVGH1aH4zFst/QyOTVCi9VIeUVxg50zbAH3D3u9v6ImaqRygYcrPja7H3kdE7heRKhGp6ujo8MChvctpnFS1VumHoQeVZpbicDo43h78n1fvdM3X/lLedjvwU9f9nwIfnr6BMeasMeac634z0A6k+SxCtWDFhXacBo5dCJ2pPvcoinY+94ziwmSMgaMXvD865dMCdGPMD4wxRcaYorQ0/38fq+6tpme0R6dpPGhz+mbCJTwk6qYqWyvJT8wnIy7D6lCCXYYxpsV1vxW45F+4iJQAkcD5KQ//vWv671siEnWJ1wbUF8JAtmVpMmE2CampviO13eSnxJKZFG11KEFhc14yEWHik9o7TyRTTUDelJ9zXY8FPF2Pz/NiI2LZkLYh6JMph9NBZVulnjseIiIvicjJGW63T93OTC7GNeuCXK4ShP8CPmOMcboe/hqwBigG7MBfzfb6QPtCGMjiosK5IjsxZPpNOZ2GyrpuSrVeymNiIsNYn5Pkk4TcE8nU08CnXFf1bQP6pnxLDGiVrZXkxOeQHZ9tdShBpSSzhFNdpxgYG7A6FK852XmSwfFBtmdttzqUoGCMud4Ys36G2++ANnedpuvP9pn2ISKJwDPA1131ne59t7hqPkeB/wR0KNpPFBfYOd7Qy6hjwupQvO5s+wC9Q+NaL+VhJQV23mjsZWTcu+fQfFoj/AIoA1aLSKOI3CsiD4jIA65N9gI1QDXwH8CfeS1aH3J3rtYpPs8rySzBaZwcaztmdSheU95SjiB6/vjG08A9rvv3AL+bvoGIRAJPMXmxzBPTnnMnYsJkvdWMbWCU7xUX2Bl1OHmzsc/qULzOPQKnI1OeVVxgZ3zC8Hp9r1ePEz7XBsaYu+Z43gAPeiwiP6Gdq71nU/omIm2RHGk9wlV5V1kdjleUt5SzNmUtS6J1oVIfeBj4lYjcC1wAPg4gIkXAA8aY+1yP7QFSROTTrtd92nXl3s9FJA0Q4DjwAMovFBdMdrmoqOumKMiLso/UdpOVFE1ucozVoQSVItc5VFnXzfbl3hv1mzOZClXaudp7osKi2Jy+OWj7TQ2ND3Gi4wSfWvcpq0MJCcaYLuC6GR6vAu5z3f8Z8LNZXn+tVwNUly0lPooV6fFU1nbD1VZH4z3GGCpqu9mxPEVX2vCwJbGRrMlM8HrdlC4nM4uK1grtXO1FxZnFnOk5Q++Id4derXC07SgOp4NtWdusDkWpgFdcYKfqQg8TzlmvKwh4dV1DdAyMarNOLykusHPsQg+OCefcG18mTaZmMOGc0M7VXlaaVQq822E+mJS3lBNpi2Rz+marQ1Eq4JUUJjMw4uBMa/BesFJR2wWgixt7SXGhncGxCd5q6ffaMTSZmsFbXW8xMDbwzge+8rwrUq8gJjyGIy1HrA7F48pbytmcsZnocO0Vo9RiuResDeZ+U0dqukmJi2R5WpzVoQSlEh8seqzJ1AzKWyavmtZkynsibBFsydgSdP2mOoc7OdtzVqf4lPKQ3ORYspOiqQjmZKp2cj0+rZfyjsykaPLsMV5NyDWZmkF5Szlr7GuwR+v8tTeVZpZS21dLx1DwdJJ2F9VrfymlPKe40E5FbTeTF48Hl4buIZp6h7VeysuKC+xU1fV47RzSZGqaYccwr7e/riMLPlCSNVmTFkyjU+Ut5SRGJrLGvsbqUJQKGsUFdjoGRrnQFXwLpJedn6yX2rki1eJIgltJgZ2uwTHOdwx6Zf+aTE1zrO0Y485xHVnwgTXJa0iITAiaZMoYQ1lLGaVZpYTZwqwOR6mg4R61CcapvsPnO0mNj2RlerzVoQS14kLv1t5pMjVNeUs5EbYINmfolVjeFmYLoyijiPLm8qAYvr/Qf4HWwVYd1VTKw1akxZMcGzHZbyqIGGMoq+li2zLtL+Vty1LjSI2P9FoRuiZT05S3lLM5fTMx4dqF1hd25eyiebCZ2r5aq0NZtNeaXwNge7aOairlSTabUFRgD7or+mo6B2nrH2XHcp3i8zYRoSjfrsmUL3QNd/F299s6suBDu3N2A3Cw6aDFkSzewaaDFCQWkJeQZ3UoSgWd0kI7dV1DtPQNWx2Kxxx21Uvt8OIyJ+pd25bZaeodpt4LtXeaTE3hrt3RkQXfyYrPYsWSFRxsDOxkasQxQlVrFbtydlkdilJByT1681p1l8WReE7Z+U6yk6LJT4m1OpSQsGul6xw63+nxfWsyNUV5SzkJkQmsta+1OpSQsjtnN0fbjzI47p2rLHyhqq2K0YlRdubstDoUpYLSmswEUuIiOVzt+Q9CKzidhrLzXWxfnqr1Uj6yPC2e9IQoDnnhHNJkysUYQ1lzGaWZeiWWr+3K2YXD6XinWWogOtR0iKiwKIoyiqwORamgZLMJO1akcqi6MyguWHm7dYCeoXGd4vMhEWHXilTKznfh9PBaj5pMudQP1NMy2KL1UhbYnL6ZuIg4DjUdsjqUy3ao6RDFmcW6hIxSXrRrRQrtA6NUt1+0PGzR8wAAIABJREFUOpRFO+yaatquyZRP7VyRSvfgGKdbPbtOnyZTLmXNZQBsy9ZkytciwiLYnrWdg40HA/IbZ0N/Axf6L2i9lFJe5q6b8sY0ja+Vne+iMDWO7CV65bgvuZujHvZw7Z0mUy6Hmg6RG5/L0oSlVocSknbl7KJtqI1zveesDmXB3Fciuq9MVL4lInYReVFEzrn+TJ5luwkROe66PT3l8UIROSIi1SLyuIhE+i56tRB59ljyU2IDvgjdMeHkSG23jkpZIDMpmuVpcR5PyDWZAkYnRjnScoTdubu1ENAi7lGdQJzqO9R0iKUJS1maqIm4Rb4KvGyMWQm87Pp5JsPGmCtdt9umPP6PwLeMMSuAHuBe74arFmPnilTKa7pwTDitDuWyvdnUx8VRB9uXaTJlhV0rUqmo7WbM4blzSJMp4GjrUUYmRnSaxkIZcRmsTl4dcC0SRidGqWyt1HPHWrcDP3Xd/ynw4fm+UCa/PV0LPHE5r1e+t3N5KhdHHZxo7LM6lMt28FwnIroen1V2rEhleHyC1+t7PLZPTaaYnKaJtEVSnFlsdSghbVfOLo63H6d/zLOFgd5U0VKhibj1MowxLa77rUDGLNtFi0iViJSLiDthSgF6jTEO18+NQM5sBxKR+137qOro6PBI8Gphti9PQQReC+C6qVfPdrAhJwl7nM4oW2HbshRsHj6HNJni3SuxdAkZa12ddzUO4wio0an9DfuJCY+hJKvE6lCCmoi8JCInZ7jdPnU7M3kFw2xXMeQbY4qAu4FHRGT5QuMwxvzAGFNkjClKS0tb+C+iFs0eF8kV2YkBm0z1j4zzekMve1bq+WOVpJgINuYu4bXznqu9C/lkqmGggbr+OnbnavGw1TambSQ1JpV99fusDmVenMbJgYYD7MrZRVRYlNXhBDVjzPXGmPUz3H4HtIlIFoDrz/ZZ9tHk+rMGOABsBrqAJSIS7tosF2jy8q+jFmnnilSO1fcwNOaYe2M/c7i6kwmnYfdKneKz0s4VKRxv6GVgZNwj+wv5ZMpd8KzTNNaziY1r8q7hUNMhRidGrQ5nTqc6T9Ex3ME1eddYHUqoexq4x3X/HuB30zcQkWQRiXLdTwV2Am+5RrL2Ax+71OuVf9m1IpXxCcORmsBb+PjVc53ER4WzJX/Gi06Vj+xckcqE01DuoXNIk6mmQ+Ql5JGfmG91KAq4dum1DDmGONJyxOpQ5rS/YT9hEsae3D1WhxLqHgZuEJFzwPWunxGRIhH5oWubtUCViJxgMnl62Bjzluu5vwK+IiLVTNZQ/cin0asFKy6wEx1h48CZGQch/ZYxhlfPdrB9eQoRYSH/8Wuponw763MSGffQVaHhc28SvEYnRqloqeCOlXdYHYpyKcksIS4ijn31+/w+SdnfsJ8tGVtIikqyOpSQZozpAq6b4fEq4D7X/cPAhlleXwNo0VsAiY4IY8fyVPaf6eCbxgRMS5vazkEae4b57FULLtdTHhYZbuMPX/BceU9Ip8ZVrVWMTIxos0U/EhkWye6c3exv2M+Ec8LqcGZV319PdW+1TvEpZZFrVqdR3z1EbWfgLJD+6tnJK0D3aL1U0AnpZOpAwwGiw6K1JYKfuXbptXSPdPNm55tWhzKr/Q37ATSZUsoiV69OB+DAmcBpUXHwXCf5KbHkp8RZHYrysHklUyJys4iccS238L7uwiLyaRHpmLJUw32eD9WzjDHsb9jPjuwdujitn9mds5twW7hfX9W3r34fK5NXkpuQa3UoSoWkPHssy9LiOHA2MJKpUccEZTVdehVfkJozmRKRMOBR4BZgHXCXiKybYdPHpyzV8MMZnvcrb3W/RdtQG9cs1ZEFf/P/t3fnUXbUZcLHv0/Vvbf3PUsnnQ5ZIYFAWEIiyPuCBAwgGtwGRB0XHFHHV3yZccTx6FHPOAfP+Mq4IIrgIAgERTERIQmQOOooyJ61Y0jSIXt30vt2l6rn/aOqQyd0kyZ9+y7dz+ece2q5daue/nX17z79+/2qqjRWypIpS3hi9xM5+eDjQ92HeLHpRS4/5fJsh2LMuPa20ybx9M4j9CZyd0hAv6d3ttCT8Lh03qRsh2JGwXBaphYDr6jqTlVNACsIHt+Q19a9ug5HHC6ednG2QzGDWHbKMvZ27WXzkc3ZDuV1ntj9BIqybMaybIdizLh2yWkTSaR8/rIz92/guW7rIQqjDhfOtpapsWg4yVQdsGfA8lCPW3iviGwQkYdFpD4t0Y2i9XvWc86kc6gqtHt95KKlpywl6kR5fNfj2Q7lddY0ruHUqlOZVTEr26EYM64tnllNUdRlfUNud/WpKk9ubeKiORMojLrZDseMgnQNQP8tMENVzwKe4LWHjh4jV55rtadzD9tbt3Np/aVZi8G8sfJYORfVXcTqxtX4mjtPhz/YfZCXml/iihlXZDsUY8a9gojLW+fU8Pu/NeXkkIB+2w51sq+tl6Xzh3pspMl3w0mm9gEDW5pe97gFVT2iqv23rL4LOG+wHeXKc63WvxpeiWXjpXLalTOvpKmniRcOvZDtUI5a07gGwLr4jMkRb5s3iT0tvfztUFe2QxnSU1uDm4sutfFSY9ZwkqlngbkiMlNEYsB1BI9vOKr/uVihdwFb0xdi+q3fs565VXOpL8v53shx7eJpF1MUKWJ14+psh3LU2sa1zK+ez/Ty6dkOxRgDXD5/MiKwdvPBbIcypCe3HuKsaRVMKrcrx8eqEyZTqpoCPgusIUiSfqGqm0XkGyLyrnCzz4nI5vBRDZ8DPjpaAY/U4d7DvND0gnXx5YHiaDGXTLuEtY1rSfrpeRjlSOzp3MOGwxusVcqYHDKpvJBz6itZsyU3k6nDXXFe2tPG0nnWxTeWDWvMlKo+pqqnqupsVf1muO6rqroqnP+Sqp6hqgtV9W2q2jCaQY/EE7ufwFffxrzkiStmXkFrvJWn9z+d7VD47Y7fIgjvmPWObIdijBng7WfUsmlfB/vaerMdyuusb2hCFZbOty6+sWzc3QF99a7VzKmcw5yqOdkOxQzDRXUXUVlQycodK7Mah68+q3asYsmUJdSW1GY1FmPMsZadEfxN5mJX35rNh5haUcgZU8uzHYoZReMqmeq/2aJ10+SPmBvj6llXs+7VdbT1tWUtjucPPc++rn0sn5P3t1gzZsyZOaGEuZNKWbv5ULZDOUZnX5I/bG/migVT8uZhzObkjKtkau3utShqXXx55po515D0k/xu1++yFsOqHasoiZawdPrSrMVgjBnasjNq+WtjC63diWyHctS6hiYSKZ+rzrTW7LFuXCVTqxtXM696HjMqZmQ7FPMmnFZ9GqfXnM4j2x/Jyr1kepI9rG1cy9tPeTtFkaKMH98Yc2LLzqjF85Unt+ZO69RjGw8wubyAc6fbzaHHunGTTO3v2s+GZrsSK1+9e8672da6jS0tWzJ+7Md2PUZPqod3z313xo9tjBmeBXXl1FUW8djGA9kOBYDueIrfb2vmygVTcBzr4hvrxk0y9dsdvwWCG0Ga/HPVrKsodAv55bZfZvS4qspD2x7i1KpTOXvi2Rk9thkeEakWkSdEZHs4fV0zgIi8TUReGvDqE5FrwvfuEZFdA96zX3QeEhGuXjiFP24/TEsOdPWta2ginvK5coF18Y0H4yKZUlVW7ljJ4trF1JUO9lhBk+vKY+VcPftqHt35aEYHor/c/DINLQ1cN+86G0Cau24BnlLVucBT4fIxVHW9qp6tqmcDlwI9wNoBm3yh/31VfSkjUZu0W76wjpSvOdE69fimA0woLWDRjOpsh2IyYFwkUy82vciezj12JVaeu37e9cS9OL/a/quMHfPBhgcpjZbyjpl2b6kctpzXngf6M+CaE2z/PuBxVe0Z1ahMxs2fUsacSaWsenl/VuPo7Evy1NYmrlxQi2tdfOPCuEimVu5YSXGkmMumX5btUMwIzK2ay5LaJazYtoKUnxr14x3uPcza3WtZPmc5xdHiUT+eOWmTVbW/KeIgcKJbTV8HPHjcum+KyAYRuU1ECob6YK48rN0MTkRYvnAqf93Vwv4s3sDz8Y0Hiad83nOu9YSMF2M+mepJ9rB612rePuPt9oU4Blw//3oOdh9k3avrRv1YD2x9AM/3uO6060b9WOaNiciTIrJpkNcxzc0aXO455CWf4XNEzyR4PFa/LwHzgPOBauCLQ30+Vx7Wbob2zoVTAXh0Q/Zap371wl5mTSjh7PrKrMVgMmvMJ1Nrd6+lJ9XD8tnWxTcWXDztYqaXTeeujXeN6m0SuhJdrGhYwWWnXGa30sgBqnqZqi4Y5LUSONT/sPVw2vQGu/o74BFVPfqwR1U9oIE48F/A4tH8WczomjGhhIX1lfzmxewkU3taenhmVwvvPqfOxlmOI2M+mVrRsILZFbM5b/J52Q7FpIHruHzizE+wtWUrf9z3x1E7zkPbHqIz2cknzvzEqB3DpM0q4CPh/EeAN3r20Ac4rotvQCImBOOtNo1CjCaD3ntuHVsOdLBpX3vGj73ypX0AXHOOdfGNJ2M6mdrYvJHNRzZz7bxr7T+EMeTq2VdTV1rHj17+0ai0TvWmerlvy31cOPVCTq85Pe37N2l3K3C5iGwHLguXEZFFInJX/0YiMgOoB/77uM/fLyIbgY3ABODfMhCzGUXLF9ZREHFY8eyrGT2uqvLrF/axZGY19dU2rGQ8GdPJ1IptKyiOFPPOWe/MdigmjaJOlBvOvIGNhzfyp31/Svv+7996P0f6jnDjWTemfd8m/VT1iKouVdW5YXdgS7j+OVX9xIDtGlW1TlX94z5/qaqeGXYbfkhVuzL9M5j0qiiO8o4zp7Dyxf30JEb/YpV+T+9sYefhbt6/qD5jxzS5YcwmUy19LazetZp3zn4npbHSbIdj0uya2ddQX1bPd57/Tlqv7Gvta+XujXdzSf0lnDv53LTt1xiTWdeeX09nPMXvNmTunlM/f2Y3FUVRrj5rSsaOaXLDmE2mHtj6AEk/yfXzr892KGYURN0oN593M6+0vcKvt/86bfv98YYf05Pq4fPnfj5t+zTGZN7imdXMmlDCimf3ZOR4TZ19rNl0kPedN43CqJuRY5rcMSaTqe5kNw80PMCl0y9lVsWsbIdjRsnS6UtZNHkRP3jxB7T0tYx4f1uObOHBhgd579z3MrtydhoiNMZki4jwgcXTeX53Kxv3jv5A9F8+t5eUr1y/ZPqoH8vknjGZTD38t4fpTHRyw4Ibsh2KGUUiwr8u+Vc6k53c+tdbR7SvlJ/i63/5OlUFVdx07k1pitAYk03XLq6nJOZy9592jupxEimfnz+9mwtn1zB7og0rGY/GXDLVl+rj3s33sqR2CWdOPDPb4ZhRNrdqLjeedSOP73qcp3Y/ddL7+emmn7LlyBZuWXwLFQUVaYzQGJMt5YVRrj1/Oo9uOMCB9tG7I/qql/dzoL2Pf/jf1hMyXo25ZOrBhgdp6m3ixoV2JdZ4ccOZNzC/ej5f+Z+vsLtj95v+/HMHn+P2l27nqplXsWzGslGI0BiTLR976wx8Ve75c+Oo7N/3lR//9w7m1ZZxyal2V/zxakwlU+3xdn6y8SdcVHcR59een+1wTIZEnSi3ve02XMflpnU30ZHoGPZnG9sbufn3N1NfVs9XL/iq3Y/MmDGmvrqYK8+cwv1Pv0prdyLt+1/X0MT2pi5uvHiW1R/j2JhKpn6y4Sd0JbrsSqxxqK60jm9f/G12d+7mxrU3Diuh2tOxh089+SkAbl96OyXRktEO0xiTBTctnUt3IsWP/5DesVOqyvfWbaeusoirz5qa1n2b/DJmkqltLdv4+dafc82cazit+rRsh2OyYMmUJdx2yW00tDbwwd99kO2t24fc9tmDz/Khxz9EV7KLOy67g1PKT8lgpMaYTDp1chnvWjiVn/25kebOeNr2+/img2zY287nL5tL1B0zX6fmJIyJ376vPt94+huUx8q5+bybsx2OyaJL6i/hzsvvpDPRybWPXsutf72VbS3bSPkpkn6SF5te5JY/3sLH13ycslgZ9115H2dMOCPbYRtjRtlNS+cST3n8YN3Q/2S9GSnP59trtjF3UinvOXdaWvZp8lck2wGkwz2b72FD8wa+edE3qSyszHY4JsvOrz2fh9/1MN9/8fusaFjB/VvvxxUXTz0AiiJFfGzBx/j0wk9TFCnKcrTGmEyYNbGUDyyezn1P7+ba86dz+tTyEe3vZ3/Zzc7D3dz54fNwHRsrNd7lfTL1cvPLfP+F73P5KZfbM/jMUROKJvD1C7/O5875HH/a9yd2d+wm4kSYXTmbC6ZeQHlsZBWpMSb/fGHZaTy28QBfXbmJX9x4Ac5JJkH723r5f2u38bbTJnL56ZPTHKXJR3mdTO3t3MtN625icslkvnbh1+xKCvM6NUU1LJ+zPNthGGNyQGVxjFuunMcXf7WRe//SyEffOvNN70NV+cpvNqEK31i+wL53DJDHY6YOdB3gU09+iqSf5IdLf2gtDcYYY07o7xbVc+m8Sfz74w1s2T/826j0u+fPjTzV0MQ/LzuN+uriUYjQ5KNhtUyJyBXAdwEXuEtVbz3u/QLgXuA84Ahwrao2pjfU17zc/DI3r7+Z3lQvP7zsh8yqtLvOnhRVtLcd71Aj3v5GvOaDpI4047W04LW14Xd14ff04Pf24ffF8fviaDyJH0/hJxX1FPUVfEV9UB/wQRVQQIKX9E+d/qngRASJOjhRB4lFcGIRnIIIUliIU1SEU1aKW16BW1mJW1mDU1WDWzMZd0It7qR6pHIS4uTt/wJjhsb7kILCbIdhzLCJCP/xvrO44rt/5B8feIFfffpCqktiw/rss40t/PtjW7ls/iQ+/tYZoxuoySsnTKZExAVuBy4H9gLPisgqVd0yYLMbgFZVnSMi1wHfAq5NZ6C++vyt9W+saFjBI688wqSiyfznxT9hQnQmrzR10Zf0iKc8+pI+fckB0wHr4kmPvlT/+wO3GfB+0ifp+/i+4it4vqKqeBosB+s1XB8kCo4juCKvTfvXHbc+FnGCl+scnS8YOHUdCqMuRTGX4phLUSxCUbR/3j06f/x7BRHnaFOz39WKt28H3oFX8Q7tIdV8AO9wM6mWI3htHXgdXXidfaR6kng9Pl5CQIdopnYUJ6I4UcGJOjgxF6cgglteTLQggkQiSMRFXAdcF3HD5YgLIqjng++j/oCp56OehyaS+PEkmkjhJ1Ike3vRhI+fbMVP+viJMAMbiqNECgW32CVSVoBbVoJbWU6kugq3ZgKRSbW4k6cRmTIdt242TnXtMcmX7yu9SY+ehEdvwqMnmXptPuHRk0jRm/BIeD7xpB9OPeLHLL+2/pjllEci5ZNI+SS94PxRgiRT0XAaJp3HLCsAriNEHIeIK0Rdh4gjRFyHqCvHzQfTaHjeBK9wPhLMF8WC+YKoQ9GAc6s4Fjl6XhXHIhRHXRxHUN/Hb95Dau9OvIOvkjq0F6/pIKkjh/FaWkm1deB19JLqigfnT1w47Zk/4VTUpOGv3JjMqCkt4I4PnssH73qGj9/zLD//xBJKC97463DL/g4+fs+z1FcV8+33L7TuPXOM4bRMLQZeUdWdACKyAlgODEymlgNfC+cfBn4gIqL93w4j0NrRwvaL30p3IXQUwdwi4cvRKGX08eov/4UXC8o4HKvkQEE1+2M17I1N4ohTgYc76P6O/7IpjLoURF0KIw6VxTEKow5R18GRIBkSIUyQgqTIkeDLzpHgPVWOJlevTYMva29A0pXygy/XhBdMe3pSxAcsJ1I+8f6kLuUDIOpTnexgeqKJukQztYkWJibaqUp0UJnoojTRS1E8TiyexI37EFc0NVRrjSIFIEUuWhRDa0rwZ5SiZRVoVQ1aPRGtnoRTMxln4lSciVOIVk6gIBY7mvAFSZ+b9itXfF9J+UrK94OppyQTfaQOH8A/fJBU835SLU34LYfx21ugvRXpaMPv7ES7evC64+jhbvzeJjQ1eGziBj+/V+iQKIjSU1BAZ0ExrQWlHC6o5FBBFftjE9gbncie2CR63Ndf5ScCMbc/AQ6S2ILjkuLCqENFUTTYLuoQcRxEwkY6ASE4b4J6WF73HoCnSsrzg3Lww/kB02SYuHX5Hqnw/Ok75h8Jj6QX/OmJekz2WpmWbKYufpjaRAuTEm1U9XVQEe+mNNFLYV+CaDyJG1f8OOAPXoZOTJEiQYuiaHUp/vRS/Ipy+hIJstnZISLvJ6h/5gOLVfW5IbYbtIVdRGYCK4Aa4Hngw6qa/ltlm5yyaEY13/vAOXzm/hd43x1/5u6Pnk9d5eBX9/5xezOfuf8FSmIR7r1hMZXFw2vJMuPHcJKpOmDPgOW9wJKhtlHVlIi0E1RMhwduJCKfBD4JMH369GEFWIqw69RiSvs8Jvb4nNrm4fTE8fuaQJsH/YwT83ELwSl0cYpiuKWFuKUlRCrKcSurcEurcasn4pRX4JRVIqWVOGUVOOWVSFkVTlkVEhn52HxNxNHuNvz2I/gdLfjtrfgdbXj9y92t+B3teG3teB2dpDp78Lr68LqTeL0eXpwhW43EVZxCoNBFiwtITSgkXlRCT3EpHYUVtBRW0VxQw76CGnZHJ7FfKuj2lJ5E0GryOq3hawdAR/jaNuixXUeIunI0yUQIks1wKgPmHQma1VWDxMALkwEvTJpSvo9/wpS7PHzNCRYLw9ekAeUhUBR1mSi9zPKaqE80MyXRwsS+Fir7Oijr7aCop5tobx/FPQmK2uJU9XUwfajyjShugeAURXCLo7glhbhlxUTKSnArynGKq3CrqoMuyLIqpLQKKa/GKSlHisuR0nKcouKRnUeqaLwXv7sd7epAezrw2o7gtzbjt7fgtbfgd7Xhd3TgdXfhtYctj129eF2J4BzqAx0iORJXcYoEiiL4FcUkiouIF5fSXVxOW1EVR4qqOVAwgVdjk2mMTqTdiwQtdgOSNYBN5Vl/Htkm4D3Aj4fa4AQt7N8CblPVFSLyI4KW9jtGP2yTbcvOqOWej53PZ37+Astu+wOfvXQO1y6qp6okhqqyo7mbn/xhJw89t4dTJ5fy04+ez7QqGydlXi+jV/Op6p3AnQCLFi0aVqtVtLyKax96frB94R9pIrV/V9AdcXBvOObnMN6RFryOTryubryuPuL7OvF72/ES+4bu0jqOOIpEBozzEQEnnB4dB9Q/VkhRj2C8kA/q9Y8bGmYLTn+XVZGLWxKlYEo5bnkJbkUZkcpK3JqJuBNrcSdNI1I7HXfqTKRi4kmPGfKOdnGl6Ev49CRTxJNBy1jQeuYdbSk7ui41sGsr+DLt7wr1wwZIXzV8hb8fP2y1U8UVIRJ2TR1NxsJuqmDZCbu3gpfrOkTDrtLCqHu0i+rY+aDrqjB6bFfncKnn4TXvx9u3g9T+RrxD+/COHArGjLW3hudQH153nMShdrzGliDBHSI5GZQojgsSkdfOJwj79YIJA/8SNDiXfC84j4Z9DonixsAtcnBLYkQnlFFYXopbUU6kOvjnwZ0wmciUetypM4jUzUbKKk66qyLp+fQmg27RktjgrcCZoqpbgRP9LIO2sIvIVuBS4Ppwu58RtHJZMjVO/K+5E3n0cxfxlZWbufXxBm59vIGpFYUkPJ/DXQlirsMNF83kn95+KsWxvL4A3oyi4ZwZ+4D6AcvTwnWDbbNXRCJABcFA9FEjIrgTJuNOmAxnvWVYn1HPw287jHdoN17TPvyOVrS7E7+7Hb+7G+3uwu/twe/tQfviwZgeLwWeD7732pgf3weVYIy1G4wZ6h87JFEXcV2IxZBoAVJQiFNSgltailNahlNWjlNRg1M5Cae6FqdmCk5FVUb7311HKC2InHCMwFgnrkuktp5IbT0F5w3vM6qKdrbjNe3Faz6Ad+Rg0PrY1YZ2d6K9PfjxvvD86UMTCTSeCM6llIemfAi7iOn/nYddfv39fRKN4MRiSGEBTkFwDgUD84vD86cat3ICTuUEnJrJuNW1SHl1RgfkR92gO7y8MJqxY47QUC3sNUCbqqYGrK8baicn07puct8pNSXc+/HFbN7fzlNbm2g83E3UdTh9ajlXnlnLpDK7yMK8seF8mz4LzA3HFewDruO1/+L6rQI+AvwFeB+wLh3jpdJNXDe4IqxmMpye7WhMPhIRpLwSp7yS6JwF2Q5n3BCRJ4HaQd76sqquzFQcJ9O6bvLHGVMrOGNqRbbDMHnohMlUOAbqs8AagoGbP1XVzSLyDeA5VV0F3A3cJyKvAC0ECZcxxqSFql42wl0M1cJ+BKgUkUjYOjVYy7sxxryhYfXzqOpjwGPHrfvqgPk+4P3pDc0YY9Jm0BZ2VVURWU/Qor6CoIU9Yy1dxpixwe56aIzJayLybhHZC1wA/E5E1oTrp4rIYxC0sAP9LexbgV+o6uZwF18Ebg5b1msIWtqNMWbYxvcIZGNM3lPVR4BHBlm/H7hqwPLrWtjD9TsJrvYzxpiTYi1TxhhjjDEjYMmUMcYYY8wIWDJljDHGGDMClkwZY4wxxoyAZOvemiLSDOx+Ex+ZwHHP+ssTFndmWdyZ92ZiP0VVs/4wv3R4k3VYvv5+Le7My9fYx0PcQ9ZfWUum3iwReU5VF2U7jjfL4s4sizvz8jn2TMnXMrK4My9fYx/vcVs3nzHGGGPMCFgyZYwxxhgzAvmUTN2Z7QBOksWdWRZ35uVz7JmSr2VkcWdevsY+ruPOmzFTxhhjjDG5KJ9apowxxhhjco4lU8YYY4wxI5DzyZSIXCEi20TkFRG5JdvxDEVE6kVkvYhsEZHNInJTuL5aRJ4Qke3htCrbsQ5GRFwReVFEHg2XZ4rIM2G5PyQisWzHOBgRqRSRh0WkQUS2isgF+VDmIvJ/w/Nkk4g8KCKFuVjmIvJTEWkSkU0D1g1avhL4Xhj/BhE5N3uR5w6rwzIjH+swq79GX6bqsJxOpkTEBW4HrgROBz4gIqdnN6ohpYB/UtXTgbcA/xjGegs02ZaDAAAEsUlEQVTwlKrOBZ4Kl3PRTcDWAcvfAm5T1TlAK3BDVqI6se8Cq1V1HrCQ4GfI6TIXkTrgc8AiVV0AuMB15GaZ3wNccdy6ocr3SmBu+PokcEeGYsxZVodlVD7WYVZ/jb57yEQdpqo5+wIuANYMWP4S8KVsxzXM2FcClwPbgCnhuinAtmzHNkis08IT6lLgUUAI7ggbGez3kCsvoALYRXghxYD1OV3mQB2wB6gGImGZL8vVMgdmAJtOVL7Aj4EPDLbdeH1ZHZaxWPOuDrP6K6Mxj3odltMtU7z2S+u3N1yX00RkBnAO8AwwWVUPhG8dBCZnKaw38p/AvwB+uFwDtKlqKlzO1XKfCTQD/xU2798lIiXkeJmr6j7g28CrwAGgHXie/ChzGLp88/LvdZTlZZlYHZYRVn9lT9rrsFxPpvKOiJQCvwI+r6odA9/TINXNqXtRiMjVQJOqPp/tWE5CBDgXuENVzwG6Oa5JPEfLvApYTlCZTgVKeH0zdF7IxfI1I2N1WMZY/ZUD0lXGuZ5M7QPqByxPC9flJBGJElRC96vqr8PVh0RkSvj+FKApW/EN4a3Au0SkEVhB0Ez+XaBSRCLhNrla7nuBvar6TLj8MEHllOtlfhmwS1WbVTUJ/Jrg95APZQ5Dl29e/b1mSF6VidVhGWX1V/akvQ7L9WTqWWBueJVAjGCQ26osxzQoERHgbmCrqn5nwFurgI+E8x8hGIeQM1T1S6o6TVVnEJTvOlX9ILAeeF+4Wc7FDaCqB4E9InJauGopsIUcL3OC5vG3iEhxeN70x53zZR4aqnxXAX8fXhHzFqB9QFP6eGV12CjL1zrM6q+sSn8dlu2BYcMYOHYV8DdgB/DlbMfzBnFeRNBUuAF4KXxdRdB3/xSwHXgSqM52rG/wM1wCPBrOzwL+CrwC/BIoyHZ8Q8R8NvBcWO6/AaryocyBrwMNwCbgPqAgF8sceJBgXESS4D/pG4YqX4JBv7eHf6sbCa72yXpZZ/tldVhGf4a8qsOs/spIrBmpw+xxMsYYY4wxI5Dr3XzGGGOMMTnNkiljjDHGmBGwZMoYY4wxZgQsmTLGGGOMGQFLpowxxhhjRsCSKZMW4dPPPxPOTxWRh7MdkzHGDIfVX2ak7NYIJi3CZ3k9qsFTxI0xJm9Y/WVGKnLiTYwZlluB2SLyEsGN0Oar6gIR+ShwDcHzm+YSPCAzBnwYiANXqWqLiMwmuFnaRKAH+AdVbcj8j2GMGYes/jIjYt18Jl1uAXao6tnAF457bwHwHuB84JtAjwYP9vwL8PfhNncC/0dVzwP+GfhhRqI2xhirv8wIWcuUyYT1qtoJdIpIO/DbcP1G4KzwKfUXAr8MHvUEBI8nMMaYbLP6y5yQJVMmE+ID5v0Byz7BOegAbeF/hcYYk0us/jInZN18Jl06gbKT+aCqdgC7ROT9EDy9XkQWpjM4Y4x5A1Z/mRGxZMqkhaoeAf5HRDYB/3ESu/ggcIOIvAxsBpanMz5jjBmK1V9mpOzWCMYYY4wxI2AtU8YYY4wxI2DJlDHGGGPMCFgyZYwxxhgzApZMGWOMMcaMgCVTxhhjjDEjYMmUMcYYY8wIWDJljDHGGDMC/x8ABmZlTBEI4gAAAABJRU5ErkJggg==\n","text/plain":["
"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"-xcicTB3kY5X"},"source":["The output of the simulation gives the data matrices in the following format:\n","\n","$$X=\\begin{bmatrix} \\lvert && \\lvert && && \\lvert \\\\ x[0] && x[1] && \\dots && x[N] \\\\ \\lvert && \\lvert && && \\lvert \\end{bmatrix}$$\n","\n","\n","$$U=\\begin{bmatrix} \\lvert && \\lvert && && \\lvert \\\\ u[0] && u[1] && \\dots && u[N] \\\\ \\lvert && \\lvert && && \\lvert \\end{bmatrix}.$$\n","\n","Using the simulated data, you will implement regression algorithms to identify the system model.\n","\n","(a) Identify the model by solving the following optimization problem: \n","\n","$$\\min_{A, B}\\sum_{n=0}^{N-1}\\lVert x[n+1] - Ax[n] -Bu[n] \\rVert_2^2$$\n","\n","The function should output the matrices $A$ and $B$ that are the solutions to the above optimization problem."]},{"cell_type":"code","metadata":{"id":"q-tVXmldBXdS","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1620251848277,"user_tz":240,"elapsed":60617,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"c2c3c79c-ef3a-4de2-9335-0956fe31f105"},"source":["def sysid_2norm(X, U):\n"," n = X.shape[0]\n"," m = U.shape[0]\n"," A = np.zeros((n,n))\n"," B = np.zeros((n,m))\n"," \n"," ######### Put your Solution here ############\n"," \n"," prog = MathematicalProgram()\n"," \n"," # Create the optimization variables\n"," A_opt = prog.NewContinuousVariables(n, n, \"A_opt\")\n"," B_opt = prog.NewContinuousVariables(n, m, \"B_opt\")\n"," \n"," # Loop over all the time steps and add the equation error\n"," N = X.shape[1]\n","\n"," for n in range(N-1):\n"," # Loop over all but the last time step\n"," x_n = X[:,n].reshape((-1,1))\n"," u_n = U[:,n].reshape((-1,1))\n"," x_nPlus1 = X[:,n+1].reshape((-1,1))\n","\n"," # Add this quadratic cost contribution\n"," prog.AddQuadraticCost( (x_nPlus1 - A_opt.dot(x_n) - B_opt.dot(u_n)).T.dot(x_nPlus1 - A_opt.dot(x_n) - B_opt.dot(u_n))[0,0] )\n"," \n","\n"," result = Solve(prog)\n"," obj_value = result.get_optimal_cost()\n"," \n"," A = result.GetSolution(A_opt)\n"," B = result.GetSolution(B_opt).reshape((-1,1))\n","\n"," ##############################################\n"," \n"," return A, B\n","\n","Ahat_2norm, Bhat_2norm = sysid_2norm(X, U)\n","\n","print(\"A = \")\n","print(A)\n","print(\"Â = \")\n","print(Ahat_2norm)\n","print(\"\")\n","print(\"B = \")\n","print(B)\n","print(\"B̂ = \")\n","print(Bhat_2norm)\n","print(\"\")\n","\n","res = Ahat_2norm @ X[:,:-1] + Bhat_2norm @ U[:,:-1] - X[:,1:]\n","print(f'residual (2-norm): {np.sum(res**2)}')\n","print(f'residual (inf-norm): {np.sum(np.max(np.abs(res), axis = 0))}')\n","print(f'residual (1-norm): {np.sum(np.abs(res))}')"],"execution_count":4,"outputs":[{"output_type":"stream","text":["A = \n","[[ 0.8 -0.1 0. 0. ]\n"," [ 0. 0.2 0. 0.1 ]\n"," [ 0. -0.1 1.0001 0. ]\n"," [ 0. 0.2 0. 0.1 ]]\n","Â = \n","[[ 7.50894289e-01 -1.30709179e-01 9.14455324e-08 -7.80597484e-02]\n"," [-1.55801768e-02 1.57810806e-01 5.31155743e-08 1.08317293e-01]\n"," [ 6.23049434e-03 -7.63577519e-02 1.00010000e+00 -9.69254297e-03]\n"," [-2.58619099e-02 1.50449781e-01 1.83133458e-07 9.24043291e-02]]\n","\n","B = \n","[[ 0. ]\n"," [-0.02]\n"," [ 0.01]\n"," [-0.02]]\n","B̂ = \n","[[-0.00240788]\n"," [-0.02074546]\n"," [ 0.0103098 ]\n"," [-0.02126429]]\n","\n","residual (2-norm): 5.649444844818659e-07\n","residual (inf-norm): 0.01744300241118628\n","residual (1-norm): 0.03756163459976535\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"Fjl8k332lAiI"},"source":["(b) Identify the model by solving the following optimization problem: \n","\n","$$\\min_{A, B}\\sum_{n=0}^{N-1}\\lVert x[n+1] - Ax[n] -Bu[n] \\rVert_{\\infty}.$$\n","\n","where $L\\infty$ norm of a vector is defined as\n","\n","$$\\lVert x \\rVert_\\infty = \\max_{1\\leq i\\leq p}\\lvert x_i\\rvert.$$\n","Implement the following function that outputs the matrices $A$ and $B$ that are the solutions to the above optimization problem.\n"]},{"cell_type":"code","metadata":{"id":"QzsckPJ504MO","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1620251849912,"user_tz":240,"elapsed":62245,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"baf3a4ff-0bc8-49e6-8c2c-79b07eeaa93e"},"source":["def sysid_infnorm(X, U):\n"," n = X.shape[0]\n"," m = U.shape[0]\n"," A = np.zeros((n,n))\n"," B = np.zeros((n,m))\n"," \n"," ######### Put your Solution here ############\n","\n"," # We transform the L_infinity norm problem into a linear program to be solved\n","\n"," prog = MathematicalProgram()\n","\n"," # Create the optimization variables\n"," A_opt = prog.NewContinuousVariables(n, n, \"A_opt\")\n"," B_opt = prog.NewContinuousVariables(n, m, \"B_opt\")\n"," \n"," N = X.shape[1] # Number of time steps of data\n","\n"," # The L_infinity norm additional variables (we use one less\n"," # time step of data)\n"," t_opt = prog.NewContinuousVariables(N-1, \"t_opt\")\n","\n"," for k in range(N-1):\n"," # Loop over the time steps\n","\n"," x_k = X[:,k].reshape((-1,1))\n"," u_k = U[:,k].reshape((-1,1))\n"," x_kPlus1 = X[:,k+1].reshape((-1,1))\n","\n"," # Get the equation error for this step\n"," eqn_error_k = x_kPlus1 - A_opt.dot(x_k) - B_opt.dot(u_k)\n","\n"," # Add the linear cost\n"," prog.AddLinearCost(t_opt[k])\n","\n"," # Add the linear inequality constraints\n"," for i in range(n):\n"," prog.AddLinearConstraint(eqn_error_k[i,0] <= t_opt[k])\n"," prog.AddLinearConstraint(-eqn_error_k[i,0] <= t_opt[k])\n","\n"," result = Solve(prog)\n"," obj_value = result.get_optimal_cost()\n","\n"," A = result.GetSolution(A_opt)\n"," B = result.GetSolution(B_opt).reshape((-1,1))\n","\n"," ##############################################\n","\n"," return A, B, obj_value\n","\n","Ahat_infnorm, Bhat_infnorm, obj_infnorm = sysid_infnorm(X, U)\n","\n","print(\"A = \")\n","print(A)\n","print(\"Â = \")\n","print(Ahat_infnorm)\n","print(\"\")\n","print(\"B = \")\n","print(B)\n","print(\"B̂ = \")\n","print(Bhat_infnorm)\n","print(\"\")\n","\n","res = Ahat_infnorm @ X[:,:-1] + Bhat_infnorm @ U[:,:-1] - X[:,1:]\n","print(f'residual (2-norm): {np.sum(res**2)}')\n","print(f'residual (inf-norm): {np.sum(np.max(np.abs(res), axis = 0))}')\n","print(f'residual (1-norm): {np.sum(np.abs(res))}')"],"execution_count":5,"outputs":[{"output_type":"stream","text":["A = \n","[[ 0.8 -0.1 0. 0. ]\n"," [ 0. 0.2 0. 0.1 ]\n"," [ 0. -0.1 1.0001 0. ]\n"," [ 0. 0.2 0. 0.1 ]]\n","Â = \n","[[ 7.10517098e-01 -1.61977079e-01 -1.39488096e-07 -1.36670543e-01]\n"," [-4.01339167e-02 9.49105438e-02 -1.18314633e-08 1.17665633e-01]\n"," [ 4.52705450e-02 -1.98170348e-02 1.00010004e+00 2.37805758e-02]\n"," [-2.69634430e-02 1.58016717e-01 2.96967645e-07 8.22120043e-02]]\n","\n","B = \n","[[ 0. ]\n"," [-0.02]\n"," [ 0.01]\n"," [-0.02]]\n","B̂ = \n","[[-0.00440027]\n"," [-0.02192573]\n"," [ 0.01232544]\n"," [-0.02132459]]\n","\n","residual (2-norm): 5.726520018607925e-07\n","residual (inf-norm): 0.017389491837741355\n","residual (1-norm): 0.03771602466127823\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"ftxFrKrqlKXW"},"source":["(c) Identify the model by solving the following optimization problem: \n","\n","$$\\min_{A, B}\\sum_{n=0}^{N-1}\\lVert x[n+1] - Ax[n] -Bu[n] \\rVert_1.$$\n","where the $L1$ norm of a vector is defined as\n","$$\\lVert x \\rVert_1 = \\sum_{i=1}^p \\lvert x_i\\rvert.$$\n","The function should output the matrices $A$ and $B$ that are the solutions to the above optimization problem.\n"]},{"cell_type":"code","metadata":{"id":"fdWlLTbtE-Eq","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1620251851295,"user_tz":240,"elapsed":63621,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"7c933545-24b3-466e-8928-452c430f4d32"},"source":["def sysid_1norm(X, U):\n"," n = X.shape[0]\n"," m = U.shape[0]\n"," A = np.zeros((n,n))\n"," B = np.zeros((n,m))\n","\n"," ######### Put your Solution here ############\n","\n"," # We transform the L1 optimization problem into a linear program\n"," prog = MathematicalProgram()\n","\n"," A_opt = prog.NewContinuousVariables(n, n, \"A_opt\")\n"," B_opt = prog.NewContinuousVariables(n, m, \"B_opt\")\n"," \n"," N = X.shape[1] # Number of time steps of data\n","\n"," # Slack variables\n"," t_opt = prog.NewContinuousVariables(N-1, n, \"t_opt\")\n","\n"," for k in range(N-1):\n"," # Loop over the time steps\n","\n"," x_k = X[:,k].reshape((-1,1))\n"," u_k = U[:,k].reshape((-1,1))\n"," x_kPlus1 = X[:,k+1].reshape((-1,1))\n","\n"," # Get the equation error for this step\n"," eqn_error_k = x_kPlus1 - A_opt.dot(x_k) - B_opt.dot(u_k)\n","\n"," # Add the linear cost + slack variables for each term in eqn_error_k\n"," # expanded using the L1 norm\n","\n"," for i in range(n):\n"," # Linaer cost term\n"," prog.AddLinearCost(t_opt[k, i])\n","\n"," # Linear inequality constraints\n"," prog.AddLinearConstraint(eqn_error_k[i,0] <= t_opt[k, i])\n"," prog.AddLinearConstraint(-eqn_error_k[i,0] <= t_opt[k, i])\n","\n","\n"," result = Solve(prog)\n"," obj_value = result.get_optimal_cost()\n","\n"," A = result.GetSolution(A_opt)\n"," B = result.GetSolution(B_opt).reshape((-1,1))\n","\n"," ##############################################\n"," return A, B, obj_value\n","\n","Ahat_1norm, Bhat_1norm, obj_1norm = sysid_1norm(X, U)\n","\n","print(\"A = \")\n","print(A)\n","print(\"Â = \")\n","print(Ahat_1norm)\n","print(\"\")\n","print(\"B = \")\n","print(B)\n","print(\"B̂ = \")\n","print(Bhat_1norm)\n","print(\"\")\n","\n","res = Ahat_1norm @ X[:,:-1] + Bhat_1norm @ U[:,:-1] - X[:,1:]\n","print(f'residual (2-norm): {np.sum(res**2)}')\n","print(f'residual (inf-norm): {np.sum(np.max(np.abs(res), axis = 0))}')\n","print(f'residual (1-norm): {np.sum(np.abs(res))}')"],"execution_count":6,"outputs":[{"output_type":"stream","text":["A = \n","[[ 0.8 -0.1 0. 0. ]\n"," [ 0. 0.2 0. 0.1 ]\n"," [ 0. -0.1 1.0001 0. ]\n"," [ 0. 0.2 0. 0.1 ]]\n","Â = \n","[[ 7.09508973e-01 -2.01707629e-01 6.69076865e-07 -9.66822311e-02]\n"," [-3.57198891e-02 1.41048710e-01 1.35775982e-07 7.94538419e-02]\n"," [-5.44877390e-03 -1.07436650e-01 1.00009980e+00 -3.39734164e-03]\n"," [-2.88790980e-02 1.31311604e-01 -2.17061964e-07 1.04553337e-01]]\n","\n","B = \n","[[ 0. ]\n"," [-0.02]\n"," [ 0.01]\n"," [-0.02]]\n","B̂ = \n","[[-0.00437861]\n"," [-0.02176161]\n"," [ 0.00976769]\n"," [-0.02142048]]\n","\n","residual (2-norm): 5.70208400482061e-07\n","residual (inf-norm): 0.017476074620300847\n","residual (1-norm): 0.037480535035774754\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"LfApAgGr_9iM"},"source":["Let's try LQR controller with the identified models. Using the estimated parameters, $\\hat{A}$ and $\\hat{B}$, we solve discrete-time LQR. The controller is used to stabilize the original linear system defined by the parameters, $A$ and $B$. If the estimate was accurate, we expect the controller to work well for the original system."]},{"cell_type":"code","metadata":{"id":"yEyue1Xb61S9","colab":{"base_uri":"https://localhost:8080/","height":500},"executionInfo":{"status":"ok","timestamp":1620251852262,"user_tz":240,"elapsed":64581,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"70eb75b8-2fa9-43f1-8dab-1697c2724cb8"},"source":["\n","def test_LQR(A_hat, B_hat, Q = None, R = None):\n"," Q = np.identity(A.shape[0]) if Q is None else Q\n"," R = np.identity(B.shape[1]) if R is None else R\n"," \n"," # Define a Linear system\n"," sys = LinearSystem(A, B, C, D, time_period = 0.1)\n"," sys_hat = LinearSystem(A_hat, B_hat, C, D, time_period = 0.1)\n","\n"," builder = DiagramBuilder()\n"," plant = builder.AddSystem(sys)\n","\n"," controller = builder.AddSystem(LinearQuadraticRegulator(sys_hat, Q, R))\n","\n"," builder.Connect(controller.get_output_port(), plant.get_input_port())\n"," builder.Connect(plant.get_output_port(), controller.get_input_port())\n","\n"," logger = LogOutput(plant.get_output_port(), builder)\n"," log_ctrl = LogOutput(controller.get_output_port(), builder)\n","\n"," diagram = builder.Build()\n"," simulator = Simulator(diagram)\n"," context = simulator.get_mutable_context()\n"," context.SetDiscreteState(0,[10.,5.,5.,1.])\n","\n"," simulator.AdvanceTo(50)\n","\n"," t = logger.sample_times()\n"," U = log_ctrl.data()\n"," X = logger.data()\n","\n"," return t, U, X\n","\n","t, U_2norm, X_2norm = test_LQR(Ahat_2norm, Bhat_2norm)\n","t, U_infnorm, X_infnorm = test_LQR(Ahat_infnorm, Bhat_infnorm)\n","t, U_1norm, X_1norm = test_LQR(Ahat_1norm, Bhat_1norm)\n","\n","fig, ax = plt.subplots(2, 3, figsize=(16, 8))\n","ax[0,0].plot(t, X_2norm.T)\n","ax[1,0].plot(t, U_2norm.T)\n","ax[0,1].plot(t, X_infnorm.T)\n","ax[1,1].plot(t, U_infnorm.T)\n","ax[0,2].plot(t, X_1norm.T)\n","ax[1,2].plot(t, U_1norm.T)\n","ax[0,0].set_ylabel(\"state\")\n","ax[1,0].set_ylabel(\"control\")\n","ax[0,0].set_title(\"2-norm solution\")\n","ax[0,1].set_title(\"$\\infty$-norm solution\")\n","ax[0,2].set_title(\"1-norm solution\")\n","plt.show()\n"],"execution_count":7,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"abZopvSHcQdP"},"source":["You can also test the model with increased noise in the data. You can play around with different values of 'noise_level' to vary the intensity of the noise in the measurement."]},{"cell_type":"code","metadata":{"id":"J0-AEpbjXAj1","colab":{"base_uri":"https://localhost:8080/","height":500},"executionInfo":{"status":"ok","timestamp":1620251855765,"user_tz":240,"elapsed":68075,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"7000e600-4390-4399-f935-8c9bf59c7a48"},"source":["t, U_noisy, X_noisy = generate_data(A, B, C, D, noise_level = 0.5)\n","\n","Ahat_noisy_2norm, Bhat_noisy_2norm = sysid_2norm(X_noisy, U_noisy)\n","t, U_2norm, X_2norm = test_LQR(Ahat_noisy_2norm, Bhat_noisy_2norm)\n","\n","Ahat_noisy_infnorm, Bhat_noisy_infnorm, obj_infnorm_noisy = sysid_infnorm(X_noisy, U_noisy)\n","t, U_infnorm, X_infnorm = test_LQR(Ahat_noisy_infnorm, Bhat_noisy_infnorm)\n","\n","Ahat_noisy_1norm, Bhat_noisy_1norm, obj_1norm_noisy = sysid_1norm(X_noisy, U_noisy)\n","t, U_1norm, X_1norm = test_LQR(Ahat_noisy_1norm, Bhat_noisy_1norm)\n","\n","fig, ax = plt.subplots(2, 3, figsize=(16, 8))\n","ax[0,0].plot(t, X_2norm.T)\n","ax[1,0].plot(t, U_2norm.T)\n","ax[0,1].plot(t, X_infnorm.T)\n","ax[1,1].plot(t, U_infnorm.T)\n","ax[0,2].plot(t, X_1norm.T)\n","ax[1,2].plot(t, U_1norm.T)\n","ax[0,0].set_ylabel(\"state\")\n","ax[1,0].set_ylabel(\"control\")\n","ax[0,0].set_title(\"2-norm solution\")\n","ax[0,1].set_title(\"$\\infty$-norm solution\")\n","ax[0,2].set_title(\"1-norm solution\")\n","plt.show()\n"],"execution_count":8,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"r-u5rO8EJP-d"},"source":["## Autograding\n","You can check your work by running the following cell:"]},{"cell_type":"code","metadata":{"id":"_5f0OBtcJPGj","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1620251856016,"user_tz":240,"elapsed":68318,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}},"outputId":"d9d228c9-7e5c-4f62-ca74-8fa8922f9067"},"source":["from underactuated.exercises.sysid.linear_sysid.test_linear_sysid import TestLinearSysid\n","from underactuated.exercises.grader import Grader\n","Grader.grade_output([TestLinearSysid], [locals()], 'results.json')\n","Grader.print_test_results('results.json')\n"],"execution_count":9,"outputs":[{"output_type":"stream","text":["Total score is 9/9.\n","\n","Score for Test L1 regression is 3/3.\n","\n","Score for Test L2 regression is 3/3.\n","\n","Score for Test L infinite regression is 3/3.\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"g4FuuJDN6Dak","executionInfo":{"status":"ok","timestamp":1620251856017,"user_tz":240,"elapsed":68313,"user":{"displayName":"Manmeet Bhabra","photoUrl":"","userId":"11686790358753401934"}}},"source":[""],"execution_count":9,"outputs":[]}]}