{ "metadata": { "language": "Julia", "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "This is an IJulia \"notebook\", in which we can combine code, results, graphics, formatted text, etcetera to describe a computational study.\n", "\n", "In this case, the computation will be focused on solving the scalar-wave (Helmholtz) scattering problem $-\\nabla^2 u = \\omega^2/c^2 n^2(r) u$ for a set of $N$ concentric nested cylinders with (complex) refractive indices $n_j$, given some superposition of incoming cylindrical waves $H^{(2)}(k_{N+1}r) e^{im\\theta -i\\omega t}$, for $m\\in\\mathbb{Z}$ and $k_{N+1}=n_{N+1}\\omega/c$ for the outermost medium $n_{N+1}$. We will choose natural units where $c=1$, for convenience, or equivalently specify the \"wavenumber\" $k=\\omega/c$ instead of $\\omega$.\n", "\n", "See also: A. Ishimaru, *Electromagnetic Wave Propagation, Radiation, and Scattering* (Prentice Hall, Englewood Cliffs NJ, 1991); and J. J. Bowman et al., *Electromagnetic and Acoustic Scattering by Simple Shapes* (Wiley, New York, 1969). " ] }, { "cell_type": "heading", "level": 1, "metadata": {}, "source": [ "Julia introduction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like Python, Julia is a dynamic language that allows you to type commands interactively, with a syntax that is superficially somewhat Matlab-like:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x = linspace(0,10,100)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 1, "text": [ "100-element Array{Float64,1}:\n", " 0.0 \n", " 0.10101 \n", " 0.20202 \n", " 0.30303 \n", " 0.40404 \n", " 0.505051\n", " 0.606061\n", " 0.707071\n", " 0.808081\n", " 0.909091\n", " 1.0101 \n", " 1.11111 \n", " 1.21212 \n", " \u22ee \n", " 8.88889 \n", " 8.9899 \n", " 9.09091 \n", " 9.19192 \n", " 9.29293 \n", " 9.39394 \n", " 9.49495 \n", " 9.59596 \n", " 9.69697 \n", " 9.79798 \n", " 9.89899 \n", " 10.0 " ] } ], "prompt_number": 1 }, { "cell_type": "markdown", "metadata": {}, "source": [ "It has lots of built-in functions, similar to Matlab. For example, the Bessel functions $J_m(x)$ and $Y_m(x)$ are built-in:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "y = besselj(4,x)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 2, "text": [ "100-element Array{Float64,1}:\n", " 0.0 \n", " 2.70961e-7 \n", " 4.32874e-6 \n", " 2.18584e-5 \n", " 6.88368e-5 \n", " 0.000167287\n", " 0.000344941\n", " 0.000634806\n", " 0.00107466 \n", " 0.00170643 \n", " 0.00257559 \n", " 0.00373036 \n", " 0.00522097 \n", " \u22ee \n", " -0.257128 \n", " -0.264824 \n", " -0.27028 \n", " -0.273466 \n", " -0.274369 \n", " -0.272996 \n", " -0.269371 \n", " -0.263537 \n", " -0.255555 \n", " -0.245506 \n", " -0.233484 \n", " -0.219603 " ] } ], "prompt_number": 2 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plotting is accomplished by external **plotting packages**. There are [several to choose from](http://julialang.org/downloads/#Graphics.in.Julia). For example, PyPlot, is a wrapper around Python's Matplotlib." ] }, { "cell_type": "code", "collapsed": false, "input": [ "Pkg.add(\"PyPlot\") # this only needs to be done once on your machine, to install PyPlot" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stderr", "text": [ "INFO: Nothing to be done" ] }, { "output_type": "stream", "stream": "stderr", "text": [ "\n" ] }, { "output_type": "stream", "stream": "stderr", "text": [ "INFO: METADATA is out-of-date \u2014 you may not have the latest version of PyPlot\n", "INFO: Use `Pkg.update()` to get the latest versions of your packages\n" ] } ], "prompt_number": 3 }, { "cell_type": "code", "collapsed": false, "input": [ "using PyPlot # analogous to from PyPlot import * in Python." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Loading help data...\n" ] } ], "prompt_number": 4 }, { "cell_type": "code", "collapsed": false, "input": [ "title(L\"Bessel function $J_4(x)$\") # We use L\"...\" instead of \"...\" if we have embedded LaTeX equations $...$ in the string\n", "plot(x,y)\n", "xlabel(L\"$x$\")" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAIyCAYAAADYC0JmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3Xt8zuXjx/HXvY2NiJCy5ZSvFcoxWVHRQVFyiLGQSUQlx4ZOjonS1xyir2SZJIdUTv1IkpIodKK1VEuYlFMOs2w+vz+u7/ZtNux077oP7+fjcT/GZ5/Pfb9nDm/XfX2uy+U4joOIiIiIiBcKsB1ARERERCS/VGZFRERExGupzIqIiIiI11KZFRERERGvpTIrIiIiIl5LZVZEREREvJbKrIiIiIh4LZVZEREREfFaKrMiIiIi4rVUZkVERETEa6nMioiIXzl9+nS+rvv7778LOYmIFAaVWRHxW0lJSQQEBNCzZ888XTd16lRq165NiRIlCAgIYMqUKW5K6D75/dq93eLFi3nzzTfzde2ECRP45JNPCjmRiBSUyqyIZBMQEJDtERISQvXq1YmOjiYhIcF2xELlcrlyfe5bb73FwIEDKVmyJIMHD2bUqFHccMMNbkyXP7ktq3n52m346quvaNmyJU2aNMn8vdigQQNee+21PD/XunXr2LRpEz169MhXlqeeeoqJEyeyY8eOfF0vIu4RZDuAiHgml8vFyJEjM39+9OhRNm/eTHx8PG+//Taffvop9erVs5jQjhUrVmR+vPzyyy2nObeMknqusnrFFVeQkJBAmTJlijJWntWvX581a9YAUKFCBWrUqMHmzZvz/DxHjx5lxIgRbNiwId9ZAgMDmTlzJu3bt2fTpk0UK1Ys388lIoVHZVZEzunZZ5/Nduzxxx9n+vTpxMbGEhcXZyGVXfv27cPlcnl0kQVwHCfLx7MFBQURHh5elJEK5Ntvv+XQoUP069cvX9ePHz+e7t27ExwcXKAclStXpm7durz++uv07t27QM8lIoVD0wxEJE/uuOMOAP78889sn9u8eTMdO3bk8ssvJzg4mCpVqtC3b1+Sk5NzfK5ly5Zx2223UalSJUJCQggLC6N58+bMnDkzX+flJ0NujRo1ioCAANavX4/jOFmmYACsX7+egIAARo8eneP11apVo3r16pk//+c0gKSkJLp06UKFChUoUaIEjRs3ZuXKlefMsmXLFjp37kxYWBghISGEhoZy5513snjx4sysV155JQBz587NknXu3LnZXv9sixYt4uabb6ZMmTKULFmSunXrMmHChBxvgCrI15EX69evB6B58+Z5vvbEiRPMnj2bbt26FUqW/v37M3HixEJ5LhEpOI3MikierF27FoDrrrsuy/E5c+bQp08fSpQowb333kvlypVJTExk9uzZLF++nM8//5zKlStnnj9r1iz69u1LpUqVaNu2LRUqVODAgQN8/fXXvP7665kjcLk9Lz8Z8qJFixa4XC5ef/11fv31V0aNGpXjeeebg5rT53799VeaNGlCjRo16NGjBwcPHmThwoW0bduWtWvXZitvr776Kv369aNYsWLce++91KxZk99//50vv/ySmTNn0qlTJ1q0aMHRo0eZMmUK9evXp127dpnXN2jQ4LyZnnzySSZMmMCll15Kt27dKFWqFKtWreLJJ59k9erVrFmzJse31/P6deTVRx99RPHixWnatGmer12xYgVXXnklZcuWLVCGDPXq1ePQoUNs374926+niFjgiIicxeVyOS6Xyxk1apQzcuRIZ+TIkc6gQYOcZs2aOQEBAc69997rHD9+PPP8H374wSlWrJhTs2ZNZ9++fVme68MPP3QCAwOd9u3bZznesGFDJyQkxPnjjz+yvf7BgwfzfF5+Mvzyyy+Oy+VyevbsmYtfFeOWW25xAgICsh3/6KOPHJfL5YwePTrH66pWrepUr14922u7XC5nzJgxWc5dvXq143K5nNatW2c5vmPHDicoKMgpX768s3PnzmyvsXfv3swfJyUlnfdry+lr/+yzzxyXy+VUrVrV+f333zOPp6WlOW3atHFcLpczfvz4HJ8nL19HXp05c8YpX76806xZs3xd/9BDDzmPP/54jp/bvHmzM2DAAGfw4MFOhw4dnEOHDjnPP/+8M2zYMKdbt27OTz/9lON1bdq0cZ5//vl85RGRwqWRWRE5p5zeMq9duzZdunThoosuyjw2c+ZM0tLSmDJlCpUqVcpy/q233kqbNm1Yvnw5J06cyHJdYGAgQUHZ/xoqV65clp/n5rz8ZrCtWrVqPP3001mOtWzZksqVK/PFF19kOT5z5kzS09N55plnqFWrVrbnCg0Nzfyxc465suczZ84cAJ5++mkqVqyYeTwwMJCXXnqJVatWMXv2bEaMGFGgryOvvvnmGw4dOpTv0d3t27fz8MMPZzu+a9cu4uPjmT59OgDR0dFEREQQHx9PWloaN998Mw0bNmTQoEHZrg0PD+frr7/OVx4RKVwqsyKSI5fLRXp6eubPU1JS+O677xg+fDhdu3Zlx44djBs3DoBNmzYBZl5jTneaHzhwgPT0dH744QcaNmwIQLdu3RgyZEhmOb755ptp2rQpl156aZZrc3tefjJ4gvr16+c4/aBy5crZvo7PP/8cgFatWrkly7Zt23C5XNx6663ZPlezZk3CwsJISkri2LFjlC5dOsvn8/J15NVHH30E5G++LJgpEDlNMZg8eTIvvPBC5s+PHz9OuXLlaNKkCXv27GHIkCFER0fn+JyXXHIJn376ab7yiEjhUpkVkVzJuKFn6dKlXHHFFbzwwgv069ePsLAwDh48CMCLL754zutdLhcnTpzI/PmgQYOoUKECM2bMYOrUqcTGxuJyubjlllt48cUXadSoUZ7Oy08GT3CueZxBQUGcOXMmy7EjR47gcrkICwtzS5ajR48CZBvZzlCpUiX27NnDkSNHspXZvHwdebV+/fp8z5cF83XllC8mJibLKP2mTZt48MEHATJ/j59L+fLlM3+9RMQurWYgInlSpkwZwsPDSUtLY9u2bZnHXC4Xf/31F2fOnMnxkZ6ezk033ZTlubp3786mTZs4ePAgK1eupFevXmzYsIE777wzy2oJuTkvvxkKS8aqBmlpaTl+/siRIwV+jYxCtmfPngI/V04y1pw918oPGceLcm3aM2fOsGHDBho3bkxISEi+nsPlcuVYqKtWrZr544SEBJKTk2nRokWuc+VnKoeIFD6VWRHJs8OHDwNkFoQbbrgBx3HyvSB9mTJlaNWqFbNmzSI6OppDhw7luG3o+c4raIaCuuSSSwDYvXt3ts/t2rWLv/76q8CvkfE1vv/++xc8NzAwECDLVJELadiwIY7jZC6D9U+7du1iz549VK9enYsvvjjXz5kXmzZtokKFCvz73//OPPbVV19x5MiRHKc+ZBgyZAgbN2485+fLli3LoUOHzvva69atyzb6+/PPP5/z/EOHDhXa6ggiUjAqsyKSJ++++y5JSUkUL16cG2+8EYDHHnuMYsWKMWjQIH788cds1/z999/ZymnGPMiz/f777wCULFkyT+flJ0NhqlWrFhdffDHvvfcef/zxR+bxlJQUHn/88UJ5jX79+hEUFMTYsWP5/vvvs33+nyO2GeX6119/zfXzZ7zFPm7cuCwj4+np6QwdOhTHcejVq1d+41/Q/PnzOXz4cJaR33nz5lGsWLFzrhH78ccfM3/+/POW9urVq2dOQ8mQkpJCTEwM3333HQAffPAB9evXz9xU4cyZM+edZnDo0KHMtXxFxC7NmRWRHDmOw+jRozPfSj1x4gQ7d+7k/fffx+VyMX78+MybsK666irmzJnDgw8+SJ06dbjrrruoWbMmp0+fZvfu3XzyySdcdtll7Ny5M/P527dvT+nSpYmIiKBq1ao4jsMnn3zCl19+yXXXXcftt9+ep/Pyk6EgvzZnCwoKYsCAAYwdO5YGDRrQrl070tLSWLt2LWFhYYSGhub5bemzz69VqxYzZsygb9++NGjQgLZt2/Kvf/2LgwcP8sUXX1CmTBnWrVsHQKlSpYiIiOCTTz6hW7du1KxZk8DAQNq2bcu1116b4+vdcMMNxMTE8MILL3DNNdfQsWNHSpYsyfvvv8+OHTu46aabeOKJJ/L0NeT0dZxLrVq1mDBhQmZhXrFiBTNmzGDKlCnUrFkz2/lHjx7lm2++yXFlh39q1qxZtu/7qlWrmDRpEo0aNSIoKIiffvopy0jrc889l+OGEhl27tyZuYGIiFhmYTkwEfFwLpfLCQgIyFw/1OVyOUFBQU5oaKjTrl07Z+3atTle9+233zrR0dFO1apVneDgYKd8+fLOtdde6/Tt29f56KOPspz7yiuvOO3bt3euvPJKp2TJkk65cuWchg0bOi+++GKWNWxze15+MuRnndnmzZvnuM5shgkTJjg1atRwihcv7lStWtUZNmyYc/LkSadatWo5rjN7rtc+3+ts2rTJue+++5yKFSs6xYsXd8LCwpxWrVo5b7/9dpbzdu3a5bRp08YpX768ExAQ4AQEBDhz58694Ou/9dZbTrNmzZzSpUs7ISEhzjXXXOOMHz/eSU1NzXZuQb6Os6WnpztPP/20M3ToUOfRRx912rRp46xfv/6c57/44otOamqq07x5c+fjjz8+53kffPCBU6dOnSzH/vzzT6dnz57OE0884QwbNsw5ceKE06NHD+fhhx92+vfvf87f445j1t0tXbq08/XXX+fq6xIR93I5jmawi4iId1m+fDk1atSgdu3atGjRgtGjR3PzzTfneG5qaiphYWF8++2351ypIS82bdpE7969M6coiIhdbp0zm5qayrBhwwgNDaVkyZJERERkboWZF7179yYgIIA2bdq4IaWIiHiTffv2ceTIEWrXrp157HzjMsHBwTz22GNMnTq1UF4/NjaWIUOGFMpziUjBubXMRkdHM3nyZLp3787UqVMJDAykdevW573r9Gxffvklc+fOJSQk5Lx7nouIiH9Ys2YNe/fuZeLEiUycOJHExETefPNNVq1adc5rYmJiWLVqVYGXSEtMTOTnn38+52YKIlL03DbNYMuWLURERDBp0iQGDx4MmJHaa665hooVK+aq0DqOQ9OmTalTpw5r167l2muvZdmyZe6IKyIiXqp69erMnTv3nNMMMnzxxRe8+OKLLFy4MF+DI6mpqbRp04bp06cTHh6e37giUsjcNjK7ZMkSgoKC6NOnT+ax4OBgevXqxaZNm9i7d+8Fn2PevHns3LmTcePGaXFqERHJYu/evcTExLB//35eeuklVq5ced7zGzduTO/evXn55Zfz9XrPP/88zz33nIqsiIdx28jsHXfcQXJycrYJ8h9++CF33HEHy5cv5+677z7n9ceOHSM8PJxBgwYRExNDtWrVqFu3rkZmRURERCST29aZTU5OzvGu0Yxj+/btO+/1Y8aM4aKLLmLQoEG5fs0///yT1atXU61aNUqUKJG3wCIiIiLidikpKSQlJXHnnXdSoUKFAj+f28psSkpK5k4q/5Sxt3ZKSso5r01MTGTq1Km89dZbFCtWLNevuXr16nPuEiMiIiIinuONN96ga9euBX4et5XZEiVKkJqamu34qVOnMj9/LgMGDKBp06a0b98+T69ZvXp1wPziXGhHGPENAwcOJDY21nYMKSL6fp/b3r2wYQN89x18+635OUC5cnD11VCqFBQvbh7FipmPgYGQnAw//QRJSZCWZq4pUwYaNoS774Zmzcz5Nuj77V/0/fYf33//Pd26dcvsbQXltjJbqVKlHKcSJCcnAxAaGprjdevWrWP16tUsXbqUpKSkzONpaWmcPHmSX3/9lXLlylG6dOls12aM+taqVYuGDRsWwlchnq5s2bL6XvsRfb+zOn0ali2DWbNgzRpTUBs1gk6dICLCPKpUgdzcuJ+WBrt2wY4dphAvXw5Dh0L58tClC/ToAdddl7vnKiz6fvsXfb/9T0ZvKyi3ldkGDRqwfv16jh07lqV4bt68GYD69evneN3u3bsB6NChQ7bP7du3j+rVqxMbG8vjjz/uhtQiIp7v559h9myYMwd+/x1uuAHi4iAyEkqWzN9zBgWZEdyrr4b77oORI02xjY+HN96Al1+GWrWgVy945BHQbQki4inctjRXx44dSU9PZ9asWZnHUlNTiYuLIyIigrCwMAD2799PQkICaf99f+u2227j3XffzfJ45513uPTSS2ncuDHvvvsu99xzj7tii4h4rB9+gLZtoUYNmDHDlNdvvoHPPoPo6PwX2XOpUwcmToTdu83Ib8OGMGKEKbWLFoFWTBQRT+C2kdnrr7+eTp06MWLECA4cOECNGjWYO3cuu3fvJi4uLvO84cOHEx8fT1JSElWqVKFy5cpUrlw52/MNGDCAyy67jHvvvdddkUVEPNLhwzBmDEyfDldcYUZkO3cu/PJ6LoGBcMcd5jFypJl+0LkzTJsGsbFmaoOIiC1u3c42Pj6egQMHMm/ePAYMGEB6ejorVqygWbNmmee4XK5c7cSirWwlJ1FRUbYjSBHyt+93WpoZga1Z00wrGDMGvv8eevYsuiJ7tpo14b33zEjt4cPQuLHJ89/bIQqVv32//Z2+35Jfbts0wYZt27bRqFEjtm7dqknkIuLVPvwQBg4081ajo+G55yCHpbutSkuDV1+FZ56B1FT4z3/g/vttpxIRT1fYfc2tI7MiIpI3qakwYADcfjuULQtffGGmFXhakQVz01i/fmYVhHbtoGtX6N8f/v7bdjIR8SdumzMrIiJ58+OPZhms776DqVPhsceKdims/Cpb1qx6cOONpohv3WpuELviCtvJRMQfaGRWRMQDzJ9vVgv46y/YtMmMcHpDkc3gcplR2k8+gd9+M1/LunW2U4mIP1CZFRGx6MQJePBB6NbNLLu1bZspgt6qSRPzNdSta1Y/mDhRS3iJiHupzIqIWJKYaFYDWLjQbHowbx7ksLmh17n0Uli9GoYNg+HDTVlPT7edSkR8lebMiohY8PnncM89pvh9+aXZiMCXBAbC+PFm44UHHjArH8TFmZvGREQKk/5aEREpYsuWmRu9GjUya7aWK2c7kft07QrFipklu9LSzOizCq2IFCb9lSIiUoT+8x945BFo3x7eeANCQmwncr/ISDNS26WLmW4wf74puCIihUFzZkVEioDjwLPPQt++pswuXOgfRTbDfffBkiXw7rtmK1ytRSsihUVlVkTEzU6fhl69YOxYc3f/1KlmpNLftG0LS5fCypXQsaPZIEJEpKBUZkVE3Oj0aTMSOW+eecTEeNf6sYXtnnvM6OyaNebXRasciEhBqcyKiLhJWppZP3bFCnjnHfNjgVat4O23Yflys3yXiEhBqMyKiLjBmTNmfdW33zbzY++5x3Yiz3L33TB5Mrz0EsyebTuNiHgzrWYgIlLIzpyBhx82d+2/+aZZuUCy698fvv/ebINbowa0aGE7kYh4I43MiogUIseBAQPgtdfMJgGdO9tO5LlcLnMzXPPmZrWDxETbiUTEG6nMiogUEseBJ56A6dPNerIPPGA7kecrVgwWL4bLLoM2beDQIduJRMTbqMyKiBSSkSPNHNBp06B3b9tpvEfZsuYmuYMHzZJdp0/bTiQi3kRlVkSkELz66v/WkX3sMdtpvE+NGmYN2k8/hUcftZ1GRLyJyqyISAF98IG5iemRR8w0A8mfm2+GV14x/zF44w3baUTEW6jMiogUwHffmbfG77wTpkzx7w0RCsODD5r1eB95BH7+2XYaEfEGKrMiIvmUnAytW0P16vDWWxCkxQ4Lxcsvw6WXQlSU5s+KyIWpzIqI5MOJE+bu+/R0c/NS6dK2E/mOiy826/Nu2wajRtlOIyKeTmVWRCSP0tPh/vshIQFWroQrrrCdyPc0aQJjxsDzz8NHH9lOIyKeTGVWRCSPhg41o7GLFkH9+rbT+K6YGLOhQvfuZtkuEZGcqMyKiORBXBzExpqdq1q3tp3GtwUGwrx5kJICDz1kNqUQETmbyqyISC5t22aW4OrVS2uhFpWwMLM18Lvvml3VRETOpjIrIpILBw/CfffBNdeY7Wql6LRrB337wqBBZp6yiMg/qcyKiFxAejp07QrHjsHbb0NIiO1E/uell8yNdn36wJkzttOIiCdRmRURuYDRo2HNGliwAKpWtZ3GP5UsaaYZfPIJzJljO42IeBKVWRGR81i+HMaOhXHj4I47bKfxb7feCtHRZsvg/fttpxERT6EyKyJyDrt2mWWh2raF4cNtpxGASZPMTmuDBtlOIiKeQmVWRCQHJ05Ahw5QsSLMnQsB+tvSI5QvD5Mnm+2DV62ynUZEPIH+ehYRycGAAfDTT7B0KZQpYzuN/FPXrmbKxyOPmP90iIh/U5kVETnLokVmbdNp08xSXOJZXC6YORN+/x1GjrSdRkRsU5kVEfmHpCSz/FNkJPTsaTuNnEuNGjBqlJlysG2b7TQiYpPKrIjIf6Wlmbewy5Y1y0C5XLYTyfkMHmxGznv3Nt87EfFPKrMiIv81Zgxs3gxvvmkKrXi2YsXg1Vdh+3Z4+WXbaUTEFpVZERHg44/huefMW9c33mg7jeTW9debaSGjRpkth0XE/6jMiojfO3gQunWDm26CESNsp5G8GjPGbDk8erTtJCJig8qsiPg1x4GHHoKTJ+GNNyAw0HYiyauKFeGpp2DGDEhIsJ1GRIqayqyI+LVZs+Ddd81SXFdcYTuN5NeAAVC5stnqVkT8i8qsiPitn34yd8T36QPt2tlOIwUREgITJ8KKFbB2re00IlKUVGZFxC+lp0OPHnDZZfDSS7bTSGHo1MncvDdkiPn+ioh/UJkVEb80eTJ89hnMnQulStlOI4XB5TLf12++gbg422lEpKiozIqI39mxw9wwNHiwWcFAfMf115uNL55+Go4ds51GRIqCyqyI+JXTp+GBB8x2qOPG2U4j7jB+PBw9ChMm2E4iIkVBZVZE/Mr48fD11xAfb24aEt9TpQoMHWrmQv/6q+00IuJuKrMi4je2bjWjsU89BdddZzuNuNOwYXDJJfDkk7aTiIi7qcyKiF84dcpML7j2WlNmxbeVKmV2BFuwAL77znYaEXEnlVkR8QvPPgu7dpnpBcWL204jRaFnT6hWDUaOtJ1ERNxJZVZEfN6WLWb+5JgxcM01ttNIUSlWzPwnZulS2L7ddhoRcReVWRHxaX//Db16QYMGZjF98S/dukF4uCm1IuKbVGZFxKdNmAAJCfDaaxAUZDuNFLWgIDPNYMUK2LzZdhoRcQeVWRHxWTt2mNULhg2DevVspxFbOneG2rXhmWdsJxERd1CZFRGflJ5uphfUqGF2gxL/FRhoVjb44AP45BPbaUSksLm9zKampjJs2DBCQ0MpWbIkERERrF279oLXbdiwgXvvvZcqVapQokQJLrvsMm677Tbef/99d0cWER8wbZq58Wv2bG2OINChgxmdf+YZcBzbaUSkMLm9zEZHRzN58mS6d+/O1KlTCQwMpHXr1mzcuPG81/34448EBQXRr18/ZsyYQUxMDIcOHeLuu+9m/vz57o4tIl7sl1/MWrKPPQZNm9pOI54gIMCsZvHxx7Bune00IlKYXI7jvv+jbtmyhYiICCZNmsTgwYMBM1J7zTXXULFixQsW2rOlpKRw5ZVXEh4ezscff5zt89u2baNRo0Zs3bqVhg0bFsrXICLexXGgZUtITDRzZkuVsp1IPIXjQJMm5qawjRvB5bKdSMQ/FXZfc+vI7JIlSwgKCqJPnz6Zx4KDg+nVqxebNm1i7969eXq+EiVKUKFCBYoVK1bYUUXER7z+OqxdC//5j4qsZOVywdixsGkT/N//2U4jIoXFrWV2+/bthIeHU+qsf1EaN24MwFdffXXB5/jrr7/4888/SUhI4MknnyQxMZEhWixSRHKwfz8MHmy2rb3rLttpxBO1bGmmnmjurIjvcOuqi8nJyVSqVCnb8Yxj+/btu+BzREZGsmbNGgAuuugiFi1aRKtWrc57zcCBAylbtmyWY1FRUURFReU2uoh4ocGDzVvI//637STiqVwus7LB7bfD6tX6T4+Iuy1YsIAFCxZkOXbkyJFCfQ23ltmUlBSCg4OzHQ/5763FKSkpF3yOiRMn8sQTT7B7925eeeUVunTpwrJly7jjjjvOeU1sbKzmzIr4mdWrYcECmDsXype3nUY82a23wvXXmw01VGZF3CunwcSMObOFxa1ltkSJEqSmpmY7furUqczPX0i9f6x03q1bNxo2bMijjz5KYmJi4QUVEa+WkgKPPAItWkD37rbTiKdzuWD4cLNc16ZNcMMNthOJSEG4dc5spUqVcpxKkJycDEBoaGienq9YsWK0adOGXbt2FfoQtYh4r3HjYM8eeOUV3aEuudO2LVx9tRmdFRHv5tYy26BBAxITEzl27FiW45v/u0F2/fr18/ycGVMTAgK0eZmImOW3XngBnnwSwsNtpxFvERBgtjletgy++852GhEpCLc2wo4dO5Kens6sWbMyj6WmphIXF0dERARhYWEA7N+/n4SEBNLS0jLPO3DgQLbnO3LkCG+//TbXXnstF198sTuji4gXOHMG+vaFK680bxuL5MX990PlyjBxou0kIlIQbp0ze/3119OpUydGjBjBgQMHqFGjBnPnzmX37t3ExcVlnjd8+HDi4+NJSkqiSpUqALRq1YrKlStz/fXXU7Fixcxr/vjjD15//XV3xhYRLzFnDnz6qdnRKYd7TUXOq3hxGDLEPMaOhWrVbCcSkfxw+3v18fHxDBw4kHnz5jFgwADS09NZsWIFzZo1yzzH5XLhOmuiW69evTh06BCxsbE88sgjvPrqq0RERPDZZ59x6623uju2iHi4AwcgJgZ69DA3fonkx0MPQdmyMGmS7SQikl9u3c62qGk7WxH/0b07vP8+JCRAhQq204g3GzsWxo+HX3+FihVtpxHxfV61na2IiDt8+CG88Qa8+KKKrBTco4+azTamTLGdRETyQ2VWRLxKaqopHzfdBNHRttOILyhXDh5+GF5+Gf76y3YaEckrlVkR8Sr//jfs2mWKh9aUlcIyaBCcPGnWKhYR76IyKyJe49dfzfzGAQPg2mt593PEAAAgAElEQVRtpxFfEhZmbiacPBn+u0mliHgJlVkR8RoDB8Ill8CoUbaTiC964gn4/XczH1tEvIfKrIh4hVWr4N13zTSD0qVtpxFfFB4ObdpAbCz4zjo/Ir5PZVZEPF5KCvTvD7ffDpGRttOILxs0yGyR/OGHtpOISG6pzIqIx5s4EX77DaZP101f4l633AL16pnRWRHxDiqzIuLRfvoJJkyAoUPhqqtspxFf53KZudkrV0Jiou00IpIbKrMi4rEcx0wvuOwyeOop22nEX3TpYnYCmzrVdhIRyQ2VWRHxWO+9Z7asnTIFLrrIdhrxFyEh0K8fxMXB4cO204jIhajMiohHOnnSvN3bqhW0bWs7jfibvn0hLQ1mz7adREQuRGVWRDzSxImQnGxGZXXTlxS1yy+HqCiYNs2UWhHxXCqzIuJxfv7ZlNmhQ6FmTdtpxF8NHGhW0XjnHdtJROR8VGZFxOMMGgSXXgpPPmk7ifiz+vWheXMt0yXi6VRmRcSjvP8+LFtmdvrSTV9i28CB8NlnsGWL7SQici4qsyLiMVJTYcAAuPVW6NjRdhoRuOceuPJKM3dbRDyTyqyIeIzJk+GXX8xNN7rpSzxBYCA8/jgsWgR799pOIyI5UZkVEY+wZw+MHWuKQ+3attOI/E/PnlCiBMyYYTuJiOREZVZEPMLQoVC6NIwcaTuJSFYXXwzR0WbN2b//tp1GRM6mMisi1n30ESxcCC++aIqDiKfp2xcOHIClS20nEZGzqcyKiFWnT0P//tC0KXTrZjuNSM5q1zbLdM2caTuJiJxNZVZErJo5E3bu1E1f4vn69YMNG+C772wnEZF/UpkVEWv++AOefRb69IEGDWynETm/du3gssvglVdsJxGRf1KZFRFrnnrKjMaOG2c7iciFFS8OvXtDfDwcP247jYhkUJkVESu2bjV3h48dCxUq2E4jkjt9+sCJEzB/vu0kIpJBZVZEityZM+amr2uuMXeJi3iLypXNrmAzZ4Lj2E4jIqAyKyIWzJ8PmzbB1KkQFGQ7jUje9OsHX38Nn39uO4mIgMqsiBSxY8cgJgYiI81SRyLepmVLuPJK7Qgm4ilUZkWkSI0bB0ePmg0SRLxRQICZHrNoEfz5p+00IqIyKyJFJjERJk+GESOgShXbaUTyr2dPsxJHXJztJCKiMisiRcJxYOBACAuDoUNtpxEpmAoVzFSZV14xNzSKiD0qsyJSJFauhPffh5deghIlbKcRKbh+/eDnn2HNGttJRPybyqyIuF1qKgwaBLffDu3b204jUjgiIqBePbNMl4jYozIrIm4XGwu//AJTpph5hiK+wOUyN4KtWAF799pOI+K/VGZFxK2Sk80KBo89BrVr204jUriioiA4GObOtZ1ExH+pzIqIWw0fDiEhMGqU7SQiha9MGXMj2Guv6UYwEVtUZkXEbT7/HOLjYfx4KFvWdhoR93joIXMj2Pr1tpOI+CeVWRFxizNnoH9/aNAAHnzQdhoR92naFK66CmbPtp1ExD+pzIqIW7z+Onz5JUybBoGBttOIuI/LZUZnly6FQ4dspxHxPyqzIlLojh41u3zdf78ZtRLxdQ88AOnpMH++7SQi/kdlVkQK3ZgxcPw4TJxoO4lI0ahYEe69F1591ex2JyJFR2VWRApVQgJMnQpPPQVXXGE7jUjReegh+PZbM71GRIqOyqyIFBrHgQEDoEoVGDzYdhqRotWypfkPnG4EEylaKrMiUmiWLzf71E+ebNaWFfEngYFm5Y4FC+DECdtpRPyHyqyIFIpTp2DQIDM61aaN7TQidvTsaeaLL15sO4mI/1CZFZFCMXky7N4NsbFmqSIRf1StGtxxh6YaiBQllVkRKbA9e2DcOHj8cahVy3YaEbt69YKNG+H7720nEfEPKrMiUmDDhkGpUvDss7aTiNjXti2ULw+vvWY7iYh/UJkVkQL59FN4802YMAHKlLGdRsS+4GCzicLcufD337bTiPg+lVkRybf0dOjfHxo3hh49bKcR8Ry9esGff8LKlbaTiPg+lVkRybfZs+Grr2DaNAjQ3yYimerUgUaNzOisiLiX/vkRkXw5dMjs8hUdDU2a2E4j4nmio83I7B9/2E4i4ttUZkUkX0aONPMBn3/edhIRzxQVZZape/NN20lEfJvby2xqairDhg0jNDSUkiVLEhERwdq1ay943YcffsiDDz5IeHg4F110ETVq1KB3797s37/f3ZFF5AK+/hpmzDCrF1x+ue00Ip6pfHmzgcjrr9tOIuLb3F5mo6OjmTx5Mt27d2fq1KkEBgbSunVrNm7ceN7rhg0bxoYNG7jvvvuYNm0aXbp0YdGiRTRo0IDff//d3bFF5Bwcx9z0FR5u1pUVkXPr0cPMK//mG9tJRHxXkDuffMuWLSxcuJBJkyYxePBgALp3784111xDTEzMeQttbGwszZo1y3Lsrrvu4pZbbmH69OmMHTvWndFF5BwWLIBPPoE1a6B4cdtpRDxbq1Zw6aXmRrCXXrKdRsQ3uXVkdsmSJQQFBdGnT5/MY8HBwfTq1YtNmzaxd+/ec157dpEFuOmmmyhXrhwJCQluySsi53f8ODzxBHToYLbsFJHzK1YMunaFN96A06dtpxHxTW4ts9u3byc8PJxSpUplOd64cWMAvvrqqzw93/Hjxzl27BgVKlQotIwiknvjxplVDDTCJJJ7PXrAgQOwerXtJCK+ya1lNjk5mUqVKmU7nnFs3759eXq+2NhYTp8+TefOnQsln4jk3g8/wL//DSNGQLVqttOIeI/69aFePd0IJuIubp0zm5KSQnBwcLbjISEhmZ/PrQ0bNjB69Gg6d+5M8+bNz3vuwIEDKVu2bJZjUVFRREVF5fr1ROR/HAcGDICwMDPNQETypkcPGD4cDh40qxyI+IsFCxawYMGCLMeOHDlSqK/h1jJbokQJUlNTsx0/depU5udzIyEhgfbt21O3bl1mz559wfNjY2Np2LBh3sKKyDktW2beIn33XcjlH1sR+YeuXSEmBt56Cx591HYakaKT02Ditm3baNSoUaG9hlunGVSqVCnHqQTJyckAhIaGXvA5fvvtN1q2bMkll1zCqlWruOiiiwo9p4icW0oKDBoEd94J995rO42Id6pY0axsoO1tRQqfW8tsgwYNSExM5NixY1mOb968GYD69euf9/qDBw/SsmVLTp8+zerVq7nsssvcllVEcvbii7BnD0yZYnYzEpH8iY6GL76AnTttJxHxLW4tsx07diQ9PZ1Zs2ZlHktNTSUuLo6IiAjCwsIA2L9/PwkJCaSlpWWed+LECVq3bk1ycjKrVq2iRo0a7owqIjlISjLb1Q4aBFddZTuNiHe7+24oV06jsyKFza1zZq+//no6derEiBEjOHDgADVq1GDu3Lns3r2buLi4zPOGDx9OfHw8SUlJVKlSBYCuXbvyxRdf8OCDD7Jjxw527NiReX7p0qVp27atO6OLCDBwoLlZ5ZlnbCcR8X7BwXD//TBvHjz3HAS59V9gEf/h9j9K8fHxPPPMM8ybN4/Dhw9Tr149VqxYkWVTBJfLheus9y+//vprXC4Xc+bMYc6cOVk+V61aNZVZETdbuRLeew8WLYKzlooWkXzq0QOmT4e1a+Guu2ynEfENLsdxHNshCkvG3XFbt27VagYiBXDqFNSpA1deabat1VxZkcLhOObPVsOGZlcwEX9U2H3NrXNmRcQ7vfAC/PYbTJumIitSmFwu6NYN3nnHbA8tIgWnMisiWfz8s7npa8gQuPpq22lEfM/998PJk2bdZhEpOJVZEcli4EC49FJ4+mnbSUR8U7VqcPPNmmYgUlhUZkUk0/Ll5jF5Mmh/EhH36dYNPvgA9u+3nUTE+6nMighgdvoaMABatoQOHWynEfFtHTuapbnO2rJeRPJBZVZEAJg40ez0pZu+RNzvkkvgnns01UCkMKjMigg//QQTJsATT0B4uO00Iv6hWzfYtk3b24oUlMqsiJ9zHHj0Ubj8cnjySdtpRPxH69ZQtizMn287iYh3U5kV8XNLlsDq1WZ6gW76Eik6wcEQGWnK7JkzttOIeC+VWRE/9tdf5qavdu2gTRvbaUT8T7du8OuvsHGj7SQi3ktlVsSPPfOMKbRTpthOIuKfmjaFqlV1I5hIQajMivipbdtg+nQYNQqqVLGdRsQ/BQRA166waBGkptpOI+KdVGZF/FB6OvTtC3XqmGkGImJP165w5AisWmU7iYh3UpkV8UOzZsEXX8Arr0CxYrbTiPi32rWhYUNNNRDJL5VZET+zfz+MGAEPPQQ33mg7jYiAuRFsxQo4fNh2EhHvozIr4meGDDGjsRMm2E4iIhm6dIG0NLNUnojkjcqsiB/58EN4802YNAnKl7edRkQyVKoEt9+uDRRE8kNlVsRPpKTAww/DzTfDAw/YTiMiZ4uKgg0bYM8e20lEvIvKrIifGDsWfvvN3PzlctlOIyJna98eiheHhQttJxHxLiqzIn7gm2/gxRfh6afhqqtspxGRnJQpA3ffDQsW2E4i4l1UZkV8XHo69O4N4eEwbJjtNCJyPlFRsHUrJCbaTiLiPVRmRXzcjBmwZQu8+qp5C1NEPNfdd0Pp0hqdFckLlVkRH/bbb/Dkk9Cvn9aUFfEGJUqYubMLFoDj2E4j4h1UZkV8lOPAo4/CxRfD88/bTiMiuRUVBT/8ANu3204i4h1UZkV81Ntvw/LlMH26ubFERLzDbbdBhQqaaiCSWyqzIj7o8GHo3x/atTNvWYqI9yhWDCIj4a234MwZ22lEPJ/KrIgPGjYMTpwwo7Ii4n2ioszmCZ9+ajuJiOdTmRXxMevWmZULJk6EsDDbaUQkP268ESpX1lQDkdxQmRXxIcePw0MPQfPmZutaEfFOAQFmdHbxYjh92nYaEc+mMiviQ556Cvbvh9mzzT+GIuK9oqLg4EH44APbSUQ8m/65E/ERn34K06bB+PFQo4btNCJSUPXqwdVXa6qByIWozIr4gJQUePBBuOEGs4qBiHg/lwvuvx/eeQdOnrSdRsRzqcyK+ICRI2H3bnjtNQgMtJ1GRApLVJRZmWTFCttJRDyXyqyIl9u8GV56CUaPNm9Jiojv+Ne/4Lrr4M03bScR8VwqsyJeLDXVTC9o2BCGDLGdRkTcISoK3n8fjhyxnUTEM6nMinixcePgxx9hzhwICrKdRkTcITIS/v4b3nvPdhIRz6QyK+KlvvwSnn8enn4arr3WdhoRcZcrroBmzcz2tiKSncqsiBdKSYEHHoD69WHECNtpRMTdunSBtWvNurMikpXKrIgXeuop+PlniI+HYsVspxERd+vYEc6cgaVLbScR8TwqsyJeZv16mDzZbI5Qu7btNCJSFC67zGxTrakGItmpzIp4kb/+guhouOUWGDjQdhoRKUpdupj/zP7+u+0kIp5FZVbEiwwaZObMvf46BOhPr4hf6dDB/LlfssR2EhHPon8ORbzE8uVmCa7YWKhWzXYaESlq5cvDHXdoqoHI2VRmRbzAH3/AQw/BPfeYTRJExD917gyffgp79thOIuI5VGZFPJzjQL9+kJ4Or74KLpftRCJiS7t2ULw4LF5sO4mI51CZFfFw8+bB22/DK6/A5ZfbTiMiNpUpA61aaaqByD+pzIp4sF274NFHoUcPs86kiEjnzrBlC/zyi+0kIp5BZVbEQ/39N9x/vxmNnTbNdhoR8RRt2kCJErBoke0kIp5BZVbEQ40cCdu3w5tvQunSttOIiKcoVcrcDKqpBiKGyqyIB1q3DiZOhHHjoHFj22lExNN07gxffQU//GA7iYh9KrMiHubPP6F7d2jRAp54wnYaEfFErVubEdqFC20nEbFPZVbEgzgO9OoFqakQH69dvkQkZyVKQNu2KrMioDIr4lFeeQWWLYPXXoOwMNtpRMSTdekCO3fCd9/ZTiJil8qsiIfYsQMGD4ZHHjEjLiIi53PHHWbdWa1qIP5OZVbEAxw/Dp06QY0aMGmS7TQi4g2Cg82OYIsWmSlKIv7K7WU2NTWVYcOGERoaSsmSJYmIiGDt2rUXvG7//v0MHz6cFi1aULp0aQICAvj444/dHVekyDkO9O0Lu3ebLSpLlLCdSES8RWSkWdHg229tJxGxx+1lNjo6msmTJ9O9e3emTp1KYGAgrVu3ZuPGjee9LiEhgRdeeIHk5GTq1q0LgEub0osPevVVmD8fZs2CWrVspxERb3L77XDJJZpqIP7NrWV2y5YtLFy4kAkTJjBx4kQeeugh1q1bR9WqVYmJiTnvtddddx2HDh0iISGBQYMGuTOmiDXbtsHjj5uR2fvvt51GRLxN8eLQvr2mGoh/c2uZXbJkCUFBQfTp0yfzWHBwML169WLTpk3s3bv3nNeWKlWKsmXLujOeiFVHjph5snXqwOTJttOIiLeKjIQff4Svv7adRMQOt5bZ7du3Ex4eTqlSpbIcb/zfLY2++uord768iMdyHOjZEw4eNPNkQ0JsJxIRb3XrrVCunKYaiP8KcueTJycnU6lSpWzHM47t27fPLa87cODAbKO6UVFRREVFueX1RPJq8mR4913zuPJK22lExJsVKwYdOpgNFJ57DnR7iXiSBQsWsGDBgizHjhw5Uqiv4dYym5KSQnBwcLbjIf8dhkpJSXHL68bGxtKwYUO3PLdIQX32GQwbBkOHaj1ZESkckZEwe7aZh9+oke00Iv+T02Ditm3baFSIv1HdOs2gRIkSpKamZjt+6tSpzM+L+JPkZDNPtkkTGD/edhoR8RUtWkD58ppqIP7JrWW2UqVKOU4lSE5OBiA0NNSdLy/iUVJT4b77zI8XLzZvDYqIFIagIPP3i1Y1EH/k1jLboEEDEhMTOXbsWJbjmzdvBqB+/frufHkRj+E48OijsHUrLF0KOUwlFxEpkMhISEqCL7+0nUSkaLm1zHbs2JH09HRmzZqVeSw1NZW4uDgiIiIICwsDzG5fCQkJpKWluTOOiDUzZsBrr5mNEZo0sZ1GRHzRLbfApZdqqoH4H7feAHb99dfTqVMnRowYwYEDB6hRowZz585l9+7dxMXFZZ43fPhw4uPjSUpKokqVKpnHx40bB8COHTsAiI+PZ8OGDQA8/fTT7owuUmg+/hgGDoQBA6BHD9tpRMRX/XOqwQsvaFUD8R9uLbNgCugzzzzDvHnzOHz4MPXq1WPFihU0a9Ys8xyXy5XjVrXPPvssLpcLx3FwuVzMmTMn83yVWfEGv/4KHTvCzTfDpEm204iIr4uMhFdegS1b9C6Q+A+X4/jOVPGMpR62bt2qpbnEupMnoWlTs9PXF19AhQq2E4mIr0tPh9BQ6NYNXnrJdhqRnBV2X3PrnFkRf+U40KsXJCbCe++pyIpI0QgMNO8GLV4MZ87YTiNSNFRmRdxg1Ch46y14/XWoW9d2GhHxJ5GR8Ntv8PnntpOIFA2VWZFC9vrrMGYMPP+82SBBRKQoNWsGl1+uVQ3Ef6jMihSiDz+E3r3NY9gw22lExB9lTDVYskRTDcQ/qMyKFJLvvoMOHeC22+Dll7UsjojY06kT7N2rqQbiH1RmRQpBcjLcfTdUr66takXEvqZNNdVA/IfKrEgBHT8O99xjlsRZsQJKl7adSET8naYaiD9RmRUpgLQ06NLFLMG1ciVccYXtRCIihqYaiL9QmRXJJ8eBvn3h//7PTC2oV892IhGR/2naFCpV0lQD8X0qsyL54DgwdCi89hrExcFdd9lOJCKSVWAg3HefphqI71OZFcmH556Df/8bpk2D7t1tpxERyZmmGog/UJkVyaPp0+GZZ2DsWHjsMdtpRETOTVMNxB+ozIrkwbx50L8/DB4MTz1lO42IyPlpqoH4A5VZkVx67z3o2RN69YJJk7Qpgoh4h8hITTUQ36YyK5ILH35o/kFo3x7+8x8VWRHxHppqIL5OZVbkAj74wGyKcOut8MYb5m07ERFvERCgqQbi21RmRc7j//4P2rSBFi3gnXcgONh2IhGRvNNUA/FlKrMi57ByJbRtCy1bmiIbEmI7kYhI/miqgfgylVmRHCxbZubHtm5t3prTiKyIeLOAAOjYUVMNxDepzIqc5Z13zPyytm3NKEbx4rYTiYgUnDZQEF+lMivyD4sXm7/wO3aEBQugWDHbiURECoemGoivUpkV+a9XXoEuXcxj3jwICrKdSESk8GiqgfgqlVnxe44Dzz4L/fqZ7Wnj41VkRcQ3aaqB+CKVWfFraWnQuzeMHQsTJ0JsrBm9EBHxRZpqIL5I/2yL3zp50qxYMHeuecTEaGcvEfFt2kBBfJHKrPilgwfhttvgo49g+XJ44AHbiUREioY2UBBfozIrfmfXLvNW208/mTJ71122E4mIFJ2MqQaLF9tOIlI4VGbFr6xZA40bm7fXNm40PxYR8SeaaiC+RmVW/ILjwOTJ0KoVRETAli1Qs6btVCIidnTqBHv2aKqB+AaVWfF5p05BdDQMHgxDhsCKFVC2rO1UIiL2NG0Kl1+uqQbiG1Rmxaft3Qs332yWoXnjDXjhBQgMtJ1KRMSuwEBtoCC+Q2VWfNYnn8B110Fysvlx1662E4mIeI6MqQabN9tOIlIwKrPic9LTYcwYaN7czIv94gtTakVE5H801UB8hcqs+JQ9e8z6saNHw9NPw7p15i9rERHJKjDQrGqweLGmGoh3U5kVn7FsGdSrZ9aRXbfOFNqgINupREQ8l6YaiC9QmRWvd+oUPP44tG1r3jb7+mu45RbbqUREPF+zZppqIN5PZVa82pYtZj7sf/4DU6fCe+9B+fK2U4mIeIeMqQZa1UC8mcqseKWTJ2HoULjhBggJMTd59e8PLpftZCIi3qVTJ/jtNzM4IOKNVGbF66xfD3Xrwssvw4QJZgebunVtpxIR8U7NmsFll5n1uEW8kcqseI2jR+Hhh6FFCwgNNXNjn3hCN3mJiBSENlAQb6cyKx7vzBmIj4dateDNN2HGDDM6Gx5uO5mIiG/QVAPxZiqz4tE++wwiIqBHD7jpJtixA/r1gwD9zhURKTQZqxpoqoF4I1UC8Ui//Qb332+W2kpPhw0bYOFCqFLFdjIREd+jDRTEm6nMikf56y8YORKuugo++gjmzDErFdx0k+1kIiK+LTJSGyiId1KZFY/w11/w3HNQrRpMnAgDBkBiIvTsqSkFIiJFoWlTqFRJUw3E+6gmiFX/LLFjxkDXrvDTT/D881C6tO10IiL+Q1MNxFupzIoVR45kL7E//wzTpkFYmO10IiL+KTIS9u4163eLeAut0ClF6vvvTWGdOxfS0qBPHxg+XAVWRMQT/HOqwY032k4jkjsamRW3O3MGVq6EO++E2rVh6VKIiYFff9VIrIiIJwkIMBsoaKqBeBOVWXGb/fvhpZfMygT33AOHDsG8eabEjhxp1jQUERHPEhkJ+/bBpk22k4jkjqYZSKE6eRLee8/s2LVmjdlqtkMH8/OICHC5bCcUEZHzufFGs2X4okVm2oGIp9PIrBRYWppZE7ZXLzPaev/9cOwYzJxpRmcXLIAbblCRFRHxBhlTDZYs0VQD8Q4qs5Ivx46Zv+i6d4eKFeHWW2H9ehgyBHbtgk8/NTd3XXKJ7aQiIpJXGVMNPvvMdhKRC9M0A8kVxzHrv37wASxbBuvWwd9/w7XXwqOPwr33wnXXafRVRMQX3HCDuTl30SJo1sx2GpHzc/vIbGpqKsOGDSM0NJSSJUsSERHB2rVrc3XtkSNH6NOnD5deeimlSpXi1ltvZfv27W5OLBmSkiAuzoy+VqkCNWtC//6Qmmp26frpJ/jmGxg7Fho3VpEVEfEVmmog3sTtI7PR0dG8/fbbDBo0iJo1axIXF0fr1q356KOPaHqemeVnzpzh7rvv5ptvviEmJoby5cszY8YMmjdvztatW/nXv/7l7uh+5cQJ2L4dvvgCvvzSvLWUlGQKaoMG0LkzNG8ON90EZcrYTisiIu4WGQlTpsDGjebvfhFP5dYyu2XLFhYuXMikSZMYPHgwAN27d+eaa64hJiaGjRs3nvPaJUuWsGnTJpYsWUKHDh0AiIyMJDw8nJEjRzJ//nx3RvdZjgPJyWbzgp07/1dgd+40//sOCTHltV07U15vvlnzXkVE/FFEBFxxhZlqoDIrnsytZXbJkiUEBQXRp0+fzGPBwcH06tWLJ598kr179xJ2jhXzlyxZwuWXX55ZZAEqVKhAZGQkb7zxBqdPn6ZYsWLujO+1HMes6ZqUZB6//AIJCaaw7twJR4+a84oXhzp1zDIsAwaYOa916oB+WUVEJGOqwVtvQWwsBAbaTiSSM7eW2e3btxMeHk6pUqWyHG/cuDEAX3311TnL7Pbt22nYsGG2440bN2bWrFkkJiZSp06dwg/twRwHUlLgzz/NklfJyeZjxo/37ftfgT127H/XXXQRXH212X2rTRvzsXZtqF7drAMrIiKSk8hIU2Q//RRuucV2GpGcubXKJCcnU6lSpWzHM47t27fvvNc2b978vNd6Spl1HPNITzdrrp4+nfPj1Knsj5QUOH486+PYMfPxyBEzwnr4sPl46JC5+eqfAgLM0liVKpk1Xps1MzdsVatmymq1alC+vG7OEhGRvGvSBCpXhoULVWbFc7m1zKakpBAcHJzteEhISObnz+XUqVP5vrZJk4EEBJQ967ooQkKicjzfcc790XHMXNKzf5yebn6c8bGgLroISpUyj9Klzc/LljWFtGFDKFfOPC65xJTTSpXMo0IFvfUjIiLuERBgRmfnzYOpU/VunuTdggULWLBgQZZjR44cKdTXcOtvyxIlSpB69lAipqhmfN4d1/bpE0toaPYpCnDuEcqM4zl9DAgwH//5CAw0j4CArD8OCjJzTs9+FC9ubq4qUcJ8/OejZElzrYiIiKfp3Bleegk+/hhuu812GvE2UVFRREVlHUzctm0bjRo1KrTXcGuZrVSpUo5TCZKTkwEIDQ11y7W9epnRTBERESmY664z7xIuXChUjPkAACAASURBVKgyK57JreOBDRo0IDExkWP/vBsJ2Lx5MwD169c/57X169dn27ZtOBnv+f/j2osuuojw8PDCDywiIiJZuFxmqsHbb5v7P0Q8jVvLbMeOHUlPT2fWrFmZx1JTU4mLiyMiIiJzJYP9+/eTkJBAWlpalmt///13li5dmnnszz//ZPHixbRp00bLcomIiBSRzp3NTcjr1tlOIpKdW6cZXH/99XTq1IkRI0Zw4MABatSowdy5c9m9ezdxcXGZ5w0fPpz4+HiSkpKoUqUKYMpsREQEPXv2ZOfOnZk7gDmOw+jRo90ZW0RERP6hfn2zpfnChXDnnbbTiGTl9tuO4uPjGThwIPPmzWPAgAGkp6ezYsUKmjVrlnmOy+XCddadWQEBAaxatYrOnTszdepUYmJiqFixIuvWraNmzZruji0iIiL/5XKZ0dl33oG//7adRiQrl3P2pFQvlnF33NatW3PccEFERETy57vv4NprYflyuOce22nEmxV2X9OCUCIiInJBdepArVqwaJHtJCJZqcyKiIjIBWVMNXj3XbODpYinUJkVERGRXOnc2Wy5/n//ZzuJyP+ozIqIiEiuXH011K1rVjUQ8RQqsyIiIpJrnTubm8BOnrSdRMRQmRUREZFci4yEEydg1SrbSUQMlVkRERHJtX/9Cxo21FQD8RwqsyIiIpInnTvDypVw/LjtJCIqsyIiIpJHkZGQkmLmzorYpjIrIiIieVKtGjRpAm+9ZTuJiMqsiIiI5ENUFLz/Phw+bDuJ+DuVWREREcmzTp0gLc3sCCZik8qsiIiI5FloKDRvDgsW2E4i/k5lVkRERPKlSxf48EM4cMB2EvFnKrMiIiKSL/fdBwEBsHix7STiz1RmRUREJF/Kl4eWLbWqgdilMisiIiL51qULfPop7N5tO4n4K5VZERERybe2bSEkBBYtsp1E/JXKrIiIiOTbxRfD3XdrVQOxR2VWRERECiQqCrZtg8RE20nEH6nMioiISIG0bg2lS+tGMLFDZVZEREQKpEQJaNfOTDVwHNtpxN+ozIqIiEiBdekCCQnwzTe2k4i/UZkVERGRArv9dihXTlMNpOipzIqIiEiBFS/O/7d373FVlYn+x78bVETMC0ggNomlpOPRvKSR03HIcZI0zDGEUMO8pKWJeuaoTb8mp4tT2s3bMS9p6EmpEbVmzMlOYWplpMnJysFLeYcgaygNMIL1+2ONnAirje61n703n/frxStfz157rS9tL1+Xz3oeJSfbZZapBvAmyiwAAPCI226TjhyRcnNNJ0F9QpkFAAAe0bev1Lo1a87CuyizAADAI4KDpdRU6cUXpe++M50G9QVlFgAAeMzw4VJRkZSTYzoJ6gvKLAAA8JhrrpE6dJDWrDGdBPUFZRYAAHiMyyWNGCFt2CCVlppOg/qAMgsAADxqxAjpzBnpb38znQT1AWUWAAB4VPv2Uu/eTDWAd1BmAQCAx40YIf3979IXX5hOgkBHmQUAAB6XmmrvBLZunekkCHSUWQAA4HFRUVL//kw1gPMoswAAwBEjRkhvvSUdPWo6CQIZZRYAADhiyBApNFRau9Z0EgQyyiwAAHDEJZdIt9xiTzWwLNNpEKgoswAAwDEjRkgffyzt3Ws6CQIVZRYAADhmwAApIoIHweAcyiwAAHBMw4ZSSoqUlSVVVZlOg0BEmQUAAI4aMUI6cULavt10EgQiyiwAAHBUnz5SbCxTDeAMyiwAAHCUyyUNHy5lZ0vl5abTINBQZgEAgONGjpRKSqRXXjGdBIGGMgsAABzXqZPUq5e0apXpJAg0lFkAAOAV6enS3/8uFRebToJAQpkFAABecdtt9vzZF14wnQSBhDILAAC8olUradAgafVq00kQSCizAADAa9LTpffft7e4BTyBMgsAALxm4EApPJy7s/AcyiwAAPCakBB77uzzz0uVlabTIBBQZgEAgFeNGiUVFEg5OaaTIBBQZgEAgFf16iVddRVTDeAZjpfZkpISjR8/XpGRkWratKn69eunvLw8t967f/9+TZs2TX369FHjxo0VFBSkY8eOOZwYAAA4yeWyHwTbsEE6fdp0Gvg7R8tsVVWVBg0apKysLGVkZGju3LkqLi5WQkKCDh069LPv37lzpxYuXKhvvvlGv/zlL+VyuZyMCwAAvGTkSKm0VFq/3nQS+DtHy2x2drZ27typVatW6Y9//KMmTpyoN998U8HBwZo1a9bPvv+WW27RV199pQ8++EDDhw+XZVlOxgUAAF5y+eXSDTcw1QAXz/EyGx0draFDh1aPtWrVSikpKXr55ZdVUVHxk+9v2bKlwsLCnIwIAAAMGTVK2rpVOnrUdBL4M0fLbF5ennr06FFrvFevXiotLdWBAwecvDwAAPBhQ4dKTZpIa9aYTgJ/1sDJkxcWFiohIaHWeOvWrSVJBQUF6ty5s8evO3XqVLVo0aLGWFpamtLS0jx+LQAAcGEuucQutKtXS3/4g/1gGAJLVlaWsrKyaoyVlJR49Bpul1nLsnT27Fm3jm3cuLEkqby8XCEhIT/6ellZmbuXr5N58+ad944wAADwLenp9gYKublSfLzpNPC0891M3LNnj3r27Omxa7g9zWDbtm1q0qSJW1/npg+EhoaetwCXl5dXvw4AAOqvfv2kX/xCeu4500ngr9y+M9upUydlZma6dWx0dLQkezpBQUFBrdcLCwslSTExMe5eHgAABKDgYOmOO6R586SnnpJ47ht15XaZjYqKUnp6ep1O3q1bN+3YsUOWZdVYIzY3N1dhYWGKi4ur0/kAAEDgGT1aevhhe83ZOlYNwNnVDJKTk1VUVKQNGzZUj506dUrr1q1TUlKSGjZsWD1+7Ngx5efnOxkHAAD4oHbt7OkGK1aYTgJ/5OhqBsnJyYqPj9fo0aO1b98+RUREaPHixbIsSw8++GCNY9PT07V9+3ZVVVVVj3399ddasGCBJOntt9+WJC1cuFDNmzdXy5YtNWnSJCfjAwAALxk7VhoxQjp4UOrQwXQa+BNHy2xQUJA2b96s6dOna8GCBSorK1Pv3r21evVqdfjBz1SXy1Vru9ovv/xSDzzwQI1jnnzySUlSbGwsZRYAgADxu99JzZvbD4L9+c+m08CfOFpmJalFixZavny5li9f/pPHbd26tdZYbGxsjTu1AAAgMIWG2ndmV62SHnpIauB4Q0GgcHTOLAAAgLvGjJEKCqQtW0wngT+hzAIAAJ/Qo4fUtau0cqXpJPAnlFkAAOATXC77QbC//lUqLjadBv6CMgsAAHzGiBFSUJC9xS3gDsosAADwGRER0pAh9pqzlmU6DfwBZRYAAPiUMWOkffuk994znQT+gDILAAB8Sv/+0i9+wY5gcA9lFgAA+JTgYOmOO6QXXpC++cZ0Gvg6yiwAAPA5o0dLp09L2dmmk8DXUWYBAIDPadfOnm6wbJnpJPB1lFkAAOCT7rpLeucdae9e00ngyyizAADAJw0eLEVHS0uXmk4CX0aZBQAAPqlhQ2ncOOm//1s6c8Z0GvgqyiwAAPBZd95pr2iQlWU6CXwVZRYAAPisyy+XBg6UnnmGHcFwfpRZAADg0+66S8rLk3bvNp0EvogyCwAAfFpion2HdskS00ngiyizAADApwUHS+PH2/NmS0pMp4GvocwCAACfN2aMVFFhr2wAfB9lFgAA+LzWraUhQ+ypBjwIhu+jzAIAAL9w113Svn3SW2+ZTgJfQpkFAAB+4YYbpPbteRAMNVFmAQCAXwgKkiZMkLKzpc8/N50GvoIyCwAA/MYdd9j/zcw0mQK+hDILAAD8RqtW0rBh9lSDykrTaeALKLMAAMCvZGRIn34qvfKK6STwBZRZAADgV3r3lq69Vpo/33QS+ALKLAAA8DtTpkg5OdKHH5pOAtMoswAAwO8kJ0sxMdKCBaaTwDTKLAAA8DsNG0oTJ0rPPy+dOmU6DUyizAIAAL80fry9te3y5aaTwCTKLAAA8EuRkdKIEdLixVJFhek0MIUyCwAA/NaUKdKJE9LGjaaTwBTKLAAA8Ftdu0oJCSzTVZ9RZgEAgF+bMkV65x1p927TSWACZRYAAPi1pCQpNpa7s/UVZRYAAPi14GDpnnukF1+UCgtNp4G3UWYBAIDfGztWatRIWrLEdBJ4G2UWAAD4vRYtpFGj7DJbXm46DbyJMgsAAALC1KnS559Lq1ebTgJvoswCAICA0KGDdOut0ty5UmWl6TTwFsosAAAIGDNnSp98Iq1fbzoJvIUyCwAAAsY110j9+0tz5kiWZToNvIEyCwAAAsq990p79kivv246CbyBMgsAAAJKv35Sz57SY4+ZTgJvoMwCAICA4nLZd2dzcqRdu0yngdMoswAAIOD87nf26gZz5phOAqdRZgEAQMAJDpZmzJA2bJD27zedBk6izAIAgIB0++1SdLT0+OOmk8BJlFkAABCQQkKkadPsHcFOnjSdBk6hzAIAgIA1YYLUpIn09NOmk8AplFkAABCwmjWTJk2Sli6V/vlP02ngBMosAAAIaBkZUmUld2cDFWUWAAAEtKgo++7svHnSF1+YTgNPc7zMlpSUaPz48YqMjFTTpk3Vr18/5eXlufXeDRs2KDU1VVdccYXCwsLUsWNH/ed//qe++uorh1MDAIBAMmOGVFXFygaByNEyW1VVpUGDBikrK0sZGRmaO3euiouLlZCQoEOHDv3s+ydMmKD9+/crPT1dCxcuVGJiohYtWqTrrrtO5eXlTkYHAAABJDJSmjJFWrhQKioynQae1MDJk2dnZ2vnzp3Kzs7W0KFDJUkpKSmKi4vTrFmztGbNmp98//r169W3b98aYz179tSoUaO0Zs0ajR071rHsAAAgsPz+99KiRfauYE89ZToNPMXRO7PZ2dmKjo6uLrKS1KpVK6WkpOjll19WRUXFT77/h0VWkoYMGSJJys/P92xYAAAQ0MLDpf/4D+mZZ1h3NpA4Wmbz8vLUo0ePWuO9evVSaWmpDhw4UOdzfvbZZ5LsUgwAAFAXU6dKoaHSn/9sOgk8xdEyW1hYqNatW9caPzdWUFBQ53POmTNHDRo0UHJy8kXnAwAA9Uvz5tL06dLy5dLRo6bTwBPcnjNrWZbOnj3r1rGNGzeWJJWXlyskJORHXy8rK3P38pKktWvXauXKlZo5c6auvPLKHz1u6tSpatGiRY2xtLQ0paWl1el6AAAg8EyebK85+8gjdqmFc7KyspSVlVVjrKSkxKPXcLvMbtu2Tf369XPr2Pz8fMXFxSk0NPS8BfjcSgShoaHuXl47duzQ2LFjlZiYqNmzZ//ksfPmzTvv9AYAAICmTaV777WX67r3Xukn7o/hIp3vZuKePXvUs2dPj13D7TLbqVMnZWZmunVsdHS0JHs6wfmmEhQWFkqSYmJi3DrfBx98oMGDB6tr167Kzs5WUBB7PQAAgAt3993SE09IDz0krVplOg0uhttlNioqSunp6XU6ebdu3bRjxw5ZliWXy1U9npubq7CwMMXFxf3sOT755BMlJiYqOjpamzdvVpMmTeqUAQAA4IdCQ6X77rPXnv3DH6SOHU0nwoVy9BZncnKyioqKtGHDhuqxU6dOad26dUpKSlLDhg2rx48dO1Zrua3PPvtMN954oxo0aKAtW7YoIiLCybgAAKAeufNOqU0b6f/9P9NJcDEc3TQhOTlZ8fHxGj16tPbt26eIiAgtXrxYlmXpwQcfrHFsenq6tm/frqqqquqxxMREHT58WDNmzND27dtrHB8dHa3+/fs7GR8AAASwkBDp0UelkSOlbdukX//adCJcCEfLbFBQkDZv3qzp06drwYIFKisrU+/evbV69Wp16NChxrEul6vGVARJ2rt3r1wul+bOnVvr3AkJCZRZAABwUdLS7C1up06Vdu+WgoNNJ0JdOVpmJalFixZavny5lv/M2hdbt26tNfb9u7QAAACeFhQkzZsnXXedlJkpjR1rOhHqimUBAABAvRYfLw0fbs+d/fpr02lQV5RZAABQ7z32mF1kH33UdBLUFWUWAADUe7/4hb2JwlNPSZ9+ajoN6oIyCwAAIGn6dCky0i618B+UWQAAAElhYfZ0g/Xr7aW64B8oswAAAP8yfLjUu7c0bZpUWWk6DdxBmQUAAPiXoCBp/nwpL09atcp0msB09Khnz0eZBQAA+J5zS3Xde6906pTpNIGlqkr6wSawF40yCwAA8ANPPil995093QCes2iR9MEHnj0nZRYAAOAHoqOlp5+Wnn9e2rzZdJrA8Omn0h/+IKWkePa8lFkAAIDzSE+XBgyQJkxgZ7CLVVUljRtnL302ebJnz02ZBQAAOA+XS1q6VCopkWbONJ3Gvy1fLm3dKj37rNSkiWfPTZkFAAD4EW3b2mvPLlnC2rMX6tgxe0OKO++U+vf3/PkpswAAAD/h7rulX/3K/mfysjLTafyLZUnjx0vNm0uPP+7MNSizAAAAPyEoSFqxQjp+XJo1y3Qa/7JqlbRliz1do3lzZ65BmQUAAPgZV10l/elP9pJdu3ebTuMfjh+3lzZLT5cGDnTuOpRZAAAAN/z+99LVV0tjxkhnz5pO49u+/dZegqtZM2nePGevRZkFAABwQ8OG0nPPSfv328UWP+7ee6X335f+8hepZUtnr0WZBQAAcNPVV0vz50v/9V/Siy+aTuObNmywN5x44gnp2mudvx5lFgAAoA4mTJDS0uzVDfbvN53Gt3zyiTR6tHTrrZ7fHOHHUGYBAADqwOWSli2TLrtMSk6WSktNJ/IN5eXSsGHSpZfaqz+4XN65LmUWAACgjpo2lbKz7TuRkyaZTuMbpk6V9u2T1q1zbhmu86HMAgAAXIDOne2dwTIz7QfD6rM1a+y1ZBculLp18+61KbMAAAAXKD3dnjs7caK0d6/pNGZ8/LG9y9ftt9v/L7yNMgsAAHARFiywN1VITpa+/tp0Gu86flxKTJSuvFJ65hnvzZP9PsosAADARQgNteeJFhdLv/ud/SBUffDll9KAAVJwsPTqq1JYmJkclFkAAICL1KGD9Ne/Su+8Iw0fLn33nelEziotlW6+Wfr8c2nLFikmxlwWyiwAAIAH9O1r73j1179Kd90lWZbpRM6oqLCX4Nq7V9q82Z5iYRJlFgAAwEOSkuyVDVassLd0DTSWZT/k9T//Y+/01auX6URSA9MBAAAAAsntt9vzSadOlSIipBkzTCfynJkzpdWrpbVrpRtvNJ3GRpkFAADwsClTpFOn7PIXHm5mySpPsizpscekxx+X5s2zt/P1FZRZAAAABzz0kF1oJ0ywdwy77TbTiS5MZaV9l3nRImnWLLuo+xLKLAAAgANcLrsAnjlj38k8fNieR2tiLdYL9c039uoMmzbZu51NmGA6UW2UWQAAAIcEB0urVklXXCHdd5+Uny8tWyaFhJhO9vOKiuwH2vbtk/72N2ngQNOJzo8yCwAA4KCgIOnBB+0lrMaMkT79VNq4UWrVynSyH5efL910k70BxPbtUo8ephP9OJbmAgAA8ILhw6WtW6UDB6Teve07nr5oxw6pTx+pSRPp3Xd9u8hKlFkAAACvue46KTfX3vr1uuukv//ddKL/U1Zmz+m94QapWzfp7beltm1Np/p5lFkAAAAvio21i+L119vzUEeOlAoKzGbKyZG6dJGeflr605+kV1+VWrQwm8ldlFkAAAAva9bMfqhq5UppyxZ7Pu2TT9pbxXrTl19KY8dKv/mN1KaNvUXt/fdLjRp5N8fFoMwCAAAYEBQkjR5tz6G94w57p7Bu3ex5tU6rqpJefFHq1Elav15autS+7lVXOX9tT6PMAgAAGNSypbRwofT++/aP+/WTUlKkN9+0S6cnFRVJc+bYpfW22+ypDvv2SePH2+XaH/lpbAAAgMDSrZu9ksDq1dKuXfaDWJdfLv3+99Lu3faWsheiqkp67TVp2DDpssvsXbzi4+0lt9avl2JiPPt9eBvrzAIAAPgIl0u6/Xb7obCdO6WsLOn556WnnpI6dLDvpnbvLrVubZfQ6Oia81vPnrXXsd2/356+sH+/PX3g8GGpc2d7Xu7IkVJ4uLnv0dMoswAAAD7G5bLXeu3Tx15hICfHLrbz50tff13z2IgIu9iWltql9dzUhEsusacT9O9vz82Nj/evrXTdRZkFAADwYQ0aSDfeaH+tWCF98YVUWGgv51VY+H8/Dgmxy+u5r6iowCyvP0SZBQAA8BNBQVJkpP3VtavpNL6BB8AAAADgtyizAAAA8FuUWQAAAPgtyiwAAAD8FmUWAAAAfosyCwAAAL9FmQUAAIDfoswCAADAb1FmAQAA4LccLbMlJSUaP368IiMj1bRpU/Xr1095eXluvXfjxo0aMGCA2rRpo8aNG6tNmzYaPHiwdu7c6WRk+JmsrCzTEeBFfN71C593/cLnjQvlWJmtqqrSoEGDlJWVpYyMDM2dO1fFxcVKSEjQoUOHfvb9H330kSIiIjR16lQ988wzmjRpkvbt26e+fftq27ZtTsWGn+E3v/qFz7t+4fOuX/i8caEaOHXi7Oxs7dy5U9nZ2Ro6dKgkKSUlRXFxcZo1a5bWrFnzk+//4x//WGts3Lhxuuyyy7Ry5Ur9+te/diQ3AAAA/Idjd2azs7MVHR1dXWQlqVWrVkpJSdHLL7+sioqKOp8zMjJSoaGhatiwoSejAgAAwE85Vmbz8vLUo0ePWuO9evVSaWmpDhw44NZ5SkpK9Pnnn+vDDz/UuHHjZFmWJk2a5Om4AAAA8EOOTTMoLCxUQkJCrfHWrVtLkgoKCtS5c+efPU98fHx18Y2MjNSWLVvUvXv38x5bXl4uSfrHP/5xganhb0pKSrRnzx7TMeAlfN71C593/cLnXX+c62llZWUeOZ9bZdayLJ09e9atEzZu3FiSXSxDQkJ+9HV3v4HMzEydPn1an3zyiebPn6+bb75ZOTk5uvrqq2sde/jwYUnSyJEj3To3AkPPnj1NR4AX8XnXL3ze9Qufd/1y5MgR/epXv7ro87hVZrdt26Z+/fq5dcL8/HzFxcUpNDT0vAX43N3T0NBQt84XHx8vSfrtb3+r2267TZ06ddL06dP12muv1Tp2wIABev755xUbG+v2+QEAAOA95eXlOnz4sAYMGOCR87lVZjt16qTMzEy3ThgdHS3Jnk5QUFBQ6/XCwkJJUkxMjJsR/0+LFi10ww036JVXXjnv661atdKIESPqfF4AAAB4T58+fTx2LrfKbFRUlNLT0+t04m7dumnHjh2yLEsul6t6PDc3V2FhYYqLi6tb0n8pKytTcHDwBb0XAAAAgcWx1QySk5NVVFSkDRs2VI+dOnVK69atU1JSUo3ltY4dO6b8/Pwa7y8uLq51ziNHjuiNN97Qv//7vzsVGwAAAH7EZVmW5cSJq6qqdP311+ujjz7S9OnTFRERocWLF+vEiRPatWuXOnToUH1sQkKCtm/frqqqquqxqKgo9e/fX1dffbVatmypgwcPasWKFaqsrNTbb7/t1koIAAAACGyO3ZkNCgrS5s2blZqaqgULFmjGjBm69NJLlZOTU6PISpLL5aoxFUGSJk6cqIMHD2rOnDmaNGmSXnjhBSUlJen999+vVWTPnj2rmTNnKiYmRk2aNFF8fLxef/11p741GLRr1y7dc8896ty5s5o2baq2bdsqNTVVBw8eNB0NXjJ79mwFBQWpS5cupqPAIXv27NHgwYMVERGhsLAwdenSRQsXLjQdCw7YvXu3brnlFsXExCgsLEydOnXSww8/7LElm2DGN998o1mzZikxMVHh4eEKCgrSqlWrznvsP/7xDyUmJuqSSy5RRESE0tPTderUqTpdz7E7s96Ulpam9evXa9q0aerQoYOee+457dq1S1u3bvXIkg/wHcnJydq5c6eGDRumrl27qrCwUIsWLdKZM2f07rvvcsc+wJ04cUJXXXWVgoKC1K5dO+3du9d0JHjYa6+9pqSkJPXs2VOpqalq2rSpDh06JMuy9Nhjj5mOBw/68MMP1atXL8XExOiuu+5SeHi43nnnHWVmZmrw4MF66aWXTEfEBTpy5IiuuOIKtW3bVu3atdObb76pzMzMWs9fnThxQt27d1fLli2VkZGh06dP64knntDll1+u9957z/0dXy0/l5uba7lcLuvJJ5+sHisvL7fat29v9enTx2AyOOGdd96xKioqaowdPHjQaty4sTVy5EhDqeAtqampVv/+/a2EhATr3/7t30zHgYd99dVXVlRUlHXrrbeajgIvuO+++yyXy2Xt27evxvioUaMsl8tllZSUGEqGi3X27FmrqKjIsizL2r17t+VyuaxVq1bVOu7uu++2wsLCrOPHj1ePvf7665bL5bKWLVvm9vUcm2bgLdnZ2WrQoIHGjx9fPRYSEqKxY8dq586dOnnypMF08LTrrrtODRrUXISjffv2+uUvf1nrIUIElu3bt2v9+vWaN29erVVSEBjWrl2r4uJizZ49W5L9T5Xff5YCgeXcevCXXnppjfHo6GgFBwerUaNGJmLBAxo1alT9uVo/MQFg/fr1uvnmm3XZZZdVj/3mN79RXFyc/vKXv7h9Pb8vs3l5eYqLi1PTpk1rjPfq1UuS9L//+78mYsGLLMtSUVGRWrVqZToKHFJZWanJkyfrzjvvZCpJAHv99dfVrFkzHT9+XFdddZUuueQSNW/eXBMnTnR7F0r4jzFjxigqKkpjx47VBx98oOPHj+vFF1/UkiVLlJGRweZHAe7kyZP6/PPPdc0119R6rVevXsrLy3P7XG6tM+vLCgsL1bp161rj58bOt3EDAsuaNWtUUFCgRx55xHQUOGTJkiU6duyYcnJyTEeBgw4ePKjvvvtOQ4YM0bhx4zRnzhxt3bpVCxcuVElJidauXWs6IjwoJiZGb7/9tgYOHKju3btXj99///166KGHDCaDN5zbROvHOtyXX36piooKt+bN+n2ZLSsrU0hISK3xxo0bV7+OMvjdogAABc9JREFUwJWfn69JkyapT58+GjVqlOk4cMAXX3yhBx54QA888IAiIiJMx4GDzpw5o9LSUt19992aN2+eJGnIkCH69ttvtXTpUj300ENq37694ZTwlKKiIt10002SpOXLlysiIkKbNm3S7NmzFRUVpUmTJhlOCCed62c/1+HqRZkNDQ097z8/lZeXV7+OwPTZZ59p0KBBatmypbKzs5lDGaDuv/9+tWrVSpMnTzYdBQ479/t1WlpajfG0tDQtXbpU7777LmU2gDz88MM6efKkDhw4UL3F/ZAhQ1RVVaWZM2cqLS1N4eHhhlPCKed+vXuiw/n9nNnWrVufdyrBudvX536BILB89dVXuummm/T111/r1VdfVXR0tOlIcMDBgwe1fPlyTZ48WSdOnNCRI0d05MgRlZeX69tvv9XRo0f1z3/+03RMeMi536+joqJqjJ97kITPOrC89dZb6t69e60/p5OSklRaWsozLwHu3PSCc33t+woLCxUREeH20lx+X2a7d++uAwcO6PTp0zXGc3NzJUndunUzEQsOKi8vV1JSkg4dOqRNmzapY8eOpiPBISdPnlRVVZUyMjJ0xRVXVH+99957OnDggNq1a6eHH37YdEx4yLkHQU6cOFFj/NwNi8jISK9ngnMqKipUWVl53nFJ+u6777wdCV7Upk0bRUZGateuXbVee++99+rU3/y+zCYnJ6uyslLLli2rHjt79qyee+45xcfHq02bNgbTwdMqKyuVmpqq3NxcrVu3Ttdee63pSHBQly5dtHHjRr300kvVXxs3blTnzp3Vtm1bvfTSSxo7dqzpmPCQlJQUSdKKFStqjD/77LNq2LChEhISDKSCU3r06KE9e/bU2sExKytLwcHB6tq1q6Fk8JZbb71VmzZtqvEX2DfeeEMHDx7UsGHD3D5PQOwAlpqaqo0bN2ratGm68sortWrVKu3evVtvvPGGrr/+etPx4EFTp07VggULlJSUdN6f6CNHjjSQCt6WkJCgL774Qh9++KHpKPCwcePGaeXKlUpJSVHfvn315ptvKjs7W/fddx8rlgSYvXv3Kj4+Xs2aNdM999yj8PBwbdq0Sa+++qruvPNOLV261HREXIRFixappKREBQUFWrJkiYYOHVp9tzUjI0PNmjWr3gGsRYsWmjJlik6fPq3HH39cl19+uXbt2lV/dgCzLHvHr+nTp1utW7e2GjdubF177bXWa6+9ZjoWHJCQkGAFBQVZLper1ldQUJDpePCShIQEq0uXLqZjwAEVFRXWgw8+aMXGxlqNGjWy4uLirPnz55uOBYfk5uZaiYmJVrNmzaxGjRpZHTt2tB599FGrsrLSdDRcpNjY2Bp/Pp/7szsoKMg6evRo9XEff/yxNWDAACssLMwKDw+3br/9dqu4uLhO1wqIO7MAAACon/x+ziwAAADqL8osAAAA/BZlFgAAAH6LMgsAAAC/RZkFAACA36LMAgAAwG9RZgEAAOC3KLMAAADwWw1MBwAA1FZRUaGnn35aLpdLe/bs0ezZs5WZmakzZ87ommuu0fDhw01HBACfQJkFAB+0ePFipaSkKDY2VjNmzNCAAQO0d+9e/fa3v1VBQQFlFgD+hTILAD6oUaNGio2NlSSdOnVKSUlJCg0N1eLFi9WmTRuz4QDAh7gsy7JMhwAA/LhOnTpp9uzZGjp0qOkoAOBzKLMA4MOKi4sVHR2tzz77TJdeeqnpOADgc1jNAAB8TEVFhXJyciRJO3bsUGxsbHWR3bJli/Lz803GAwCfQpkFAB/z7LPPauDAgSorK9OmTZuqi+y3336rnJwcdezY0XBCAPAdTDMAAB/z0Ucf6ZFHHlH79u01bNgwLVu2TOHh4bIsSxkZGUw3AIDvocwCAADAbzHNAAAAAH6LMgsAAAC/RZkFAACA36LMAgAAwG9RZgEAAOC3KLMAAADwW5RZAAAA+C3KLAAAAPwWZRYAAAB+izILAAAAv0WZBQAAgN/6/1GYrjKs0Cw6AAAAAElFTkSuQmCC", "text": [ "Figure(PyObject )" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 5, "text": [ "PyObject " ] } ], "prompt_number": 5 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the IJulia notebook can contain graphics as well as code, results, and formatted text." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "String concatenation in Julia is the `*` operator, not `+`:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "\"a\" * \"b\"" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 6, "text": [ "\"ab\"" ] } ], "prompt_number": 6 }, { "cell_type": "code", "collapsed": false, "input": [ "\"a\" + \"b\"" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "no method +(ASCIIString, ASCIIString)\nwhile loading In[7], in expression starting on line 1", "output_type": "pyerr", "traceback": [ "no method +(ASCIIString, ASCIIString)\nwhile loading In[7], in expression starting on line 1" ] } ], "prompt_number": 7 }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, we can define new functions for String object, and we can define a `+` if we want. There are already lots of `+` definitions:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "methods(+)" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "121 methods for generic function +:" ], "metadata": {}, "output_type": "pyout", "prompt_number": 8, "text": [ "# 121 methods for generic function \"+\":\n", "+(x::Bool) at bool.jl:36\n", "+(x::Bool,y::Bool) at bool.jl:39\n", "+(y::FloatingPoint,x::Bool) at bool.jl:49\n", "+(A::BitArray{N},B::BitArray{N}) at bitarray.jl:890\n", "+(x::Union(DenseArray{Bool,N},SubArray{Bool,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)}),y::Union(DenseArray{Bool,N},SubArray{Bool,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)})) at array.jl:812\n", "+{S,T}(A::Union(DenseArray{S,N},SubArray{S,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)}),B::Union(DenseArray{T,N},SubArray{T,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)})) at array.jl:756\n", "+{T<:Union(Int16,Int32,Int8)}(x::T<:Union(Int16,Int32,Int8),y::T<:Union(Int16,Int32,Int8)) at int.jl:16\n", "+{T<:Union(Uint16,Uint32,Uint8)}(x::T<:Union(Uint16,Uint32,Uint8),y::T<:Union(Uint16,Uint32,Uint8)) at int.jl:20\n", "+(x::Int64,y::Int64) at int.jl:33\n", "+(x::Uint64,y::Uint64) at int.jl:34\n", "+(x::Int128,y::Int128) at int.jl:35\n", "+(x::Uint128,y::Uint128) at int.jl:36\n", "+(x::Float32,y::Float32) at float.jl:124\n", "+(x::Float64,y::Float64) at float.jl:125\n", "+(z::Complex{T<:Real},w::Complex{T<:Real}) at complex.jl:108\n", "+(x::Real,z::Complex{T<:Real}) at complex.jl:118\n", "+(z::Complex{T<:Real},x::Real) at complex.jl:119\n", "+(x::Rational{T<:Integer},y::Rational{T<:Integer}) at rational.jl:112\n", "+(x::Bool,B::BitArray{N}) at bitarray.jl:901\n", "+(x::Bool,y::Union(DenseArray{Bool,N},SubArray{Bool,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)})) at array.jl:806\n", "+(B::BitArray{N},x::Bool) at bitarray.jl:894\n", "+(x::Union(DenseArray{Bool,N},SubArray{Bool,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)}),y::Bool) at array.jl:809\n", "+(x::Char,y::Char) at char.jl:23\n", "+(x::Char,y::Integer) at char.jl:28\n", "+(x::Integer,y::Char) at char.jl:29\n", "+(a::Float16,b::Float16) at float16.jl:125\n", "+(x::BigInt,y::BigInt) at gmp.jl:164\n", "+(a::BigInt,b::BigInt,c::BigInt) at gmp.jl:187\n", "+(a::BigInt,b::BigInt,c::BigInt,d::BigInt) at gmp.jl:193\n", "+(a::BigInt,b::BigInt,c::BigInt,d::BigInt,e::BigInt) at gmp.jl:200\n", "+(x::BigInt,c::Uint64) at gmp.jl:212\n", "+(c::Uint64,x::BigInt) at gmp.jl:216\n", "+(c::Unsigned,x::BigInt) at gmp.jl:217\n", "+(x::BigInt,c::Unsigned) at gmp.jl:218\n", "+(x::BigInt,c::Signed) at gmp.jl:219\n", "+(c::Signed,x::BigInt) at gmp.jl:220\n", "+(x::BigFloat,c::Uint64) at mpfr.jl:139\n", "+(c::Uint64,x::BigFloat) at mpfr.jl:143\n", "+(c::Unsigned,x::BigFloat) at mpfr.jl:144\n", "+(x::BigFloat,c::Unsigned) at mpfr.jl:145\n", "+(x::BigFloat,c::Int64) at mpfr.jl:149\n", "+(c::Int64,x::BigFloat) at mpfr.jl:153\n", "+(x::BigFloat,c::Signed) at mpfr.jl:154\n", "+(c::Signed,x::BigFloat) at mpfr.jl:155\n", "+(x::BigFloat,c::Float64) at mpfr.jl:159\n", "+(c::Float64,x::BigFloat) at mpfr.jl:163\n", "+(c::Float32,x::BigFloat) at mpfr.jl:164\n", "+(x::BigFloat,c::Float32) at mpfr.jl:165\n", "+(x::BigFloat,c::BigInt) at mpfr.jl:169\n", "+(c::BigInt,x::BigFloat) at mpfr.jl:173\n", "+(x::BigFloat,y::BigFloat) at mpfr.jl:320\n", "+(a::BigFloat,b::BigFloat,c::BigFloat) at mpfr.jl:331\n", "+(a::BigFloat,b::BigFloat,c::BigFloat,d::BigFloat) at mpfr.jl:337\n", "+(a::BigFloat,b::BigFloat,c::BigFloat,d::BigFloat,e::BigFloat) at mpfr.jl:344\n", "+(x::MathConst{sym},y::MathConst{sym}) at constants.jl:18\n", "+{T<:Number}(x::T<:Number,y::T<:Number) at promotion.jl:188\n", "+{T<:FloatingPoint}(x::Bool,y::T<:FloatingPoint) at bool.jl:46\n", "+(x::Number,y::Number) at promotion.jl:158\n", "+(x::Real,r::Range{T<:Real}) at range.jl:368\n", "+(x::Real,r::Range1{T<:Real}) at range.jl:369\n", "+(r::Ranges{T},x::Real) at range.jl:370\n", "+(r1::Ranges{T},r2::Ranges{T}) at range.jl:382\n", "+() at operators.jl:54\n", "+(x::Integer,y::Ptr{T}) at pointer.jl:61\n", "+(x::Number) at operators.jl:60\n", "+(x::Ptr{T},y::Integer) at pointer.jl:59\n", "+(B::BitArray{N},x::Number) at bitarray.jl:897\n", "+(A::SparseMatrixCSC{Tv,Ti<:Integer},B::Union(Number,Array{T,N})) at sparse/sparsematrix.jl:552\n", "+(A::Union(Number,Array{T,N}),B::SparseMatrixCSC{Tv,Ti<:Integer}) at sparse/sparsematrix.jl:553\n", "+(A::SymTridiagonal{T},B::SymTridiagonal{T}) at linalg/tridiag.jl:42\n", "+(A::Tridiagonal{T},B::Tridiagonal{T}) at linalg/tridiag.jl:214\n", "+(A::Tridiagonal{T},B::SymTridiagonal{T}) at linalg/special.jl:98\n", "+(A::SymTridiagonal{T},B::Tridiagonal{T}) at linalg/special.jl:97\n", "+(Da::Diagonal{T},Db::Diagonal{T}) at linalg/diagonal.jl:22\n", "+(A::Bidiagonal{T},B::Bidiagonal{T}) at linalg/bidiag.jl:86\n", "+(A::Diagonal{T},B::Bidiagonal{T}) at linalg/special.jl:88\n", "+(A::Bidiagonal{T},B::Diagonal{T}) at linalg/special.jl:89\n", "+(A::Diagonal{T},B::Tridiagonal{T}) at linalg/special.jl:88\n", "+(A::Tridiagonal{T},B::Diagonal{T}) at linalg/special.jl:89\n", "+(A::Diagonal{T},B::Triangular{T<:Number}) at linalg/special.jl:88\n", "+(A::Triangular{T<:Number},B::Diagonal{T}) at linalg/special.jl:89\n", "+(A::Diagonal{T},B::Array{T,2}) at linalg/special.jl:88\n", "+(A::Array{T,2},B::Diagonal{T}) at linalg/special.jl:89\n", "+(A::Bidiagonal{T},B::Tridiagonal{T}) at linalg/special.jl:88\n", "+(A::Tridiagonal{T},B::Bidiagonal{T}) at linalg/special.jl:89\n", "+(A::Bidiagonal{T},B::Triangular{T<:Number}) at linalg/special.jl:88\n", "+(A::Triangular{T<:Number},B::Bidiagonal{T}) at linalg/special.jl:89\n", "+(A::Bidiagonal{T},B::Array{T,2}) at linalg/special.jl:88\n", "+(A::Array{T,2},B::Bidiagonal{T}) at linalg/special.jl:89\n", "+(A::Tridiagonal{T},B::Triangular{T<:Number}) at linalg/special.jl:88\n", "+(A::Triangular{T<:Number},B::Tridiagonal{T}) at linalg/special.jl:89\n", "+(A::Tridiagonal{T},B::Array{T,2}) at linalg/special.jl:88\n", "+(A::Array{T,2},B::Tridiagonal{T}) at linalg/special.jl:89\n", "+(A::Triangular{T<:Number},B::Array{T,2}) at linalg/special.jl:88\n", "+(A::Array{T,2},B::Triangular{T<:Number}) at linalg/special.jl:89\n", "+(A::SymTridiagonal{T},B::Triangular{T<:Number}) at linalg/special.jl:97\n", "+(A::Triangular{T<:Number},B::SymTridiagonal{T}) at linalg/special.jl:98\n", "+(A::SymTridiagonal{T},B::Array{T,2}) at linalg/special.jl:97\n", "+(A::Array{T,2},B::SymTridiagonal{T}) at linalg/special.jl:98\n", "+(A::Diagonal{T},B::SymTridiagonal{T}) at linalg/special.jl:106\n", "+(A::SymTridiagonal{T},B::Diagonal{T}) at linalg/special.jl:107\n", "+(A::Bidiagonal{T},B::SymTridiagonal{T}) at linalg/special.jl:106\n", "+(A::SymTridiagonal{T},B::Bidiagonal{T}) at linalg/special.jl:107\n", "+{T<:Number}(x::AbstractArray{T<:Number,N}) at abstractarray.jl:320\n", "+{S,T<:Real}(A::Union(DenseArray{S,N},SubArray{S,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)}),B::Ranges{T<:Real}) at array.jl:764\n", "+{S<:Real,T}(A::Ranges{S<:Real},B::Union(DenseArray{T,N},SubArray{T,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)})) at array.jl:773\n", "+(x::Number,B::BitArray{N}) at bitarray.jl:904\n", "+{T}(A::Number,B::Union(DenseArray{T,N},SubArray{T,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)})) at array.jl:786\n", "+{T}(A::Union(DenseArray{T,N},SubArray{T,N,A<:DenseArray{T,N},I<:(Union(Range1{Int64},Range{Int64},Int64)...,)}),B::Number) at array.jl:793\n", "+{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},B::SparseMatrixCSC{Tv,Ti}) at sparse/sparsematrix.jl:462\n", "+{TvA,TiA,TvB,TiB}(A::SparseMatrixCSC{TvA,TiA},B::SparseMatrixCSC{TvB,TiB}) at sparse/sparsematrix.jl:454\n", "+{T}(a::HierarchicalValue{T},b::HierarchicalValue{T}) at pkg/resolve/versionweight.jl:19\n", "+(a::VWPreBuildItem,b::VWPreBuildItem) at pkg/resolve/versionweight.jl:82\n", "+(a::VWPreBuild,b::VWPreBuild) at pkg/resolve/versionweight.jl:120\n", "+(a::VersionWeight,b::VersionWeight) at pkg/resolve/versionweight.jl:164\n", "+(a::FieldValue,b::FieldValue) at pkg/resolve/fieldvalue.jl:41\n", "+(a::Vec2,b::Vec2) at graphics.jl:60\n", "+(bb1::BoundingBox,bb2::BoundingBox) at graphics.jl:123\n", "+(x::LCHuv,y::LCHuv) at /Users/stevenj/.julia/Color/src/Color.jl:1099\n", "+(a,b,c) at operators.jl:71\n", "+(a,b,c,xs...) at operators.jl:72" ] } ], "prompt_number": 8 }, { "cell_type": "code", "collapsed": false, "input": [ "import Base: + # tell Julia that we want to add new definitions to + from the Base module (all built-in functions)\n", "+(x::String, y::String) = x * \" \" * y\n", "\"hello\" + \"world\"" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 9, "text": [ "\"hello world\"" ] } ], "prompt_number": 9 }, { "cell_type": "heading", "level": 1, "metadata": {}, "source": [ "Scatterer geometry" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's make a data structure `Scatterer` to describe $N$ layers of (complex) indices $n_j$ for $j=1,\\ldots,N$, and an outermost (real) index $n_{N+1}$. The *outer* radius of index $n_j$ will have radius $R_j$." ] }, { "cell_type": "code", "collapsed": false, "input": [ "# The Scatterer type is \"parameterized\" by a real type T. Typically, we will use T = Float64, for double-precision\n", "# floating-point arithmetic (about 15 decimal digits), but maybe at some point we will try more accurate arithmetic types.\n", "type Scatterer{T<:Real}\n", " n::Vector{Complex{T}} # the complex indices of each layer 1:N+1, with n[N+1] being the outermost medium.\n", " R::Vector{T} # R[j] is the radius of the interface between n[j] and n[j+1], for j=1:N\n", " \n", " # define a \"constructor\" function to create an object, performing some simple type-checking, where n0\n", " # is the outermost medium.\n", " function Scatterer(n0::T, n::Vector{Complex{T}}, R::Vector{T})\n", " if length(n) != length(R)\n", " throw(ArgumentError(\"n and R must have the same length\"))\n", " end\n", " if any(R .<= 0) || any(diff(R) .< 0)\n", " throw(ArgumentError(\"R must be positive and monotonic nondecreasing\"))\n", " end\n", " new([n, n0],R)\n", " end\n", "end\n", "\n", "# For convenience, we also define a constructor that accepts arbitrary numeric types, converting\n", "# everything to the same type T as needed. T is selected by \"promoting\" the constituent types\n", "# to the \"lowest common denominator\".\n", "function Scatterer{Tn<:Number,Tr<:Real}(n0::Real, n::Vector{Tn}, R::Vector{Tr})\n", " T = promote_type(typeof(real(complex(one(promote_type(typeof(n0),Tn))))), Tr)\n", " Scatterer{T}(convert(T, n0), copy!(Array(Complex{T},length(n)), n), copy!(Array(T,length(R)), R))\n", "end" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 10, "text": [ "Scatterer{T<:Real} (constructor with 1 method)" ] } ], "prompt_number": 10 }, { "cell_type": "code", "collapsed": false, "input": [ "s = Scatterer(3.0, [4,5,7], [8,9,11])" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 11, "text": [ "Scatterer{Float64}(Complex{Float64}[4.0+0.0im,5.0+0.0im,7.0+0.0im,3.0+0.0im],[8.0,9.0,11.0])" ] } ], "prompt_number": 11 }, { "cell_type": "code", "collapsed": false, "input": [ "Scatterer(3.0, [4,5,7], [8,7,11])" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "ArgumentError(\"R must be positive and monotonic nondecreasing\")\nwhile loading In[12], in expression starting on line 1", "output_type": "pyerr", "traceback": [ "ArgumentError(\"R must be positive and monotonic nondecreasing\")\nwhile loading In[12], in expression starting on line 1", " in Scatterer at In[10]:14", " in Scatterer at In[10]:25" ] } ], "prompt_number": 12 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Julia includes a standard function `length(A)` to get the length of an array and similar types. We will add a new method to this type in order to get the number of layers ($N$) in the scatterer." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import Base: length # the import statement is needed to add new methods to a built-in function (from the Base module)\n", "length(s::Scatterer) = length(s.R)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 13, "text": [ "length (generic function with 38 methods)" ] } ], "prompt_number": 13 }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is also convenient to define a `show` method for `Scatterer` objects, in order to print them in a nice format." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import Base: show\n", "function show{T}(io::IO, s::Scatterer{T})\n", " println(io, \"Scatterer{$T} with \", length(s), \" layers surrounded by n = \", real(s.n[end]), \":\")\n", " println(io, \" n: \", join(s.n[1:end-1], \", \"))\n", " println(io, \" R: \", join(s.R, \", \"))\n", "end" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 14, "text": [ "show (generic function with 88 methods)" ] } ], "prompt_number": 14 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, if we look at `s` (defined above), it will print more nicely:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "s" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 15, "text": [ "Scatterer{Float64} with 3 layers surrounded by n = 3.0:\n", " n: 4.0 + 0.0im, 5.0 + 0.0im, 7.0 + 0.0im\n", " R: 8.0, 9.0, 11.0\n" ] } ], "prompt_number": 15 }, { "cell_type": "heading", "level": 1, "metadata": {}, "source": [ "Scattering-amplitude computation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Julia defines `hankelh1` and `hankelh2` for the Hankel functions $H^{(1)}_m(x) = J_m(x) + iY_m(x)$ and $H^{(2)}_m(x) = J_m(x) - iY_m(x)$, respectively, which represent outgoing and incoming cylindrical waves solutions to a constant-coefficient Helmholtz equation, respectively (also denoted $H^\\pm$):" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x = linspace(2, 20)\n", "plot(x, abs(hankelh1(3, x)), \"r--\")\n", "plot(x, real(hankelh1(3, x)), \"b-\")\n", "legend([L\"$|H^{(1)}_3(x)|$\", L\"$\\operatorname{Re} \\left[ H^{(1)}_3(x) \\right]$\"])\n", "xlabel(L\"$x$\")\n", "grid()" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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", "text": [ "Figure(PyObject )" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will also define functions `hankel1d`, `besseljd`, etcetera, for the derivatives of the Bessel functions, using the identity $Z_m'(x) = [Z_{m-1}(x) - Z_{m+1}(x)]/2$ for $Z \\in \\{J, Y, H^{(1)}, H^{(2)}\\}$. Since this is the same formula repeated several times, we will use a clever feature of Julia called *metaprogramming*: Julia allows us to write a program to write a program, in this case a loop to construct and evaluate (via `@eval`) several related function definitions:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "for f in (:besselj, :bessely, :hankelh1, :hankelh2)\n", " fd = symbol(string(f, \"d\"))\n", " @eval $fd(m, x) = ($f(m-1,x) - $f(m+1,x))*0.5\n", "end" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 17 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's do a quick check to make sure our derivative is correct, by comparing it to a finite-difference approximation:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x = 0.3; m = 2; dx=1e-8\n", "hankelh1d(m, x), (hankelh1(m, x+dx) - hankelh1(m, x-dx))/(2dx)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 18, "text": [ "(0.07387973661267101 + 94.24085493796042im,0.0738797618568543 + 94.2408545867579im)" ] } ], "prompt_number": 18 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we can write a function to compute the scattering amplitude, the amplitude $1+2V$ of the outgoing wave $(1+2V) H^{(1)}(k_{N+1}r)$ for a unit-amplitude incoming wave $S H^{(2)}(k_{N+1}r)$. (It is critically important to compute $V$ rather than $1+2V$, because $V\\to 0$ for $m\\to\\infty$ and $1+2V$ is therefore subject to extreme roundoff errors.) We iteratively construct the amplitude by adding the effect of one layer at a time, starting with the scattering amplitude of the innermost interface:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "function scat_amplitude(s::Scatterer, \u03c9::Number, m::Integer)\n", " # base case for inner layer\n", " k1R = \u03c9*s.n[1]*s.R[1]\n", " k2R = \u03c9*s.n[2]*s.R[1]\n", " # handle the limiting case of infinite n_1, e.g. a perfect-metal interior\n", " if isinf(abs(k1R))\n", " V = -besselj(m,k2R) / hankelh1(m,k2R)\n", " else\n", " \u03b1 = s.n[1]/s.n[2] * besseljd(m,k1R)/besselj(m,k1R)\n", " V = (\u03b1*besselj(m,k2R) - besseljd(m,k2R)) / (hankelh1d(m,k2R) - \u03b1*hankelh1(m,k2R))\n", " end\n", " for j = 2:length(s)\n", " k1R = \u03c9*s.n[j]*s.R[j]\n", " k2R = \u03c9*s.n[j+1]*s.R[j]\n", " \u03b1 = s.n[j]/s.n[j+1] * (besseljd(m,k1R) + V*hankelh1d(m,k1R)) / (besselj(m,k1R) + V*hankelh1(m,k1R))\n", " V = (\u03b1*besselj(m,k2R) - besseljd(m,k2R)) / (hankelh1d(m,k2R) - \u03b1*hankelh1(m,k2R))\n", " end\n", " return V\n", "end" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 119, "text": [ "scat_amplitude (generic function with 1 method)" ] } ], "prompt_number": 119 }, { "cell_type": "markdown", "metadata": {}, "source": [ "(Note that the alternative \"transfer-matrix\" approach, which constructs the transfer matrix M relating the amplitudes of the Bessel functions in the innermost layer to those in the outermost layer, is problematic because it can yield extremely ill-conditioned matrices.)\n", "\n", "Let's do a quick check to make sure it gives some kind of result without encountering an error:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "scat_amplitude(s, 0.3, 3)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 121, "text": [ "-0.24349548255735684 - 0.4291916035193559im" ] } ], "prompt_number": 121 }, { "cell_type": "markdown", "metadata": {}, "source": [ "For real indices $n$, we must have $|1+V_m| = 1$ to conserve energy (the scattering matrix is unitary), up to roundoff errors:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "abs(1+2*scat_amplitude(s, 0.3, 3))" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 120, "text": [ "0.9999999999999984" ] } ], "prompt_number": 120 }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a consequence of symmetry, which makes $H_m(x) = (-1)^m H_{-m}(x)$, the scattering amplitudes are equal for $\\pm m$:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "scat_amplitude(s, 0.3, -3)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 122, "text": [ "-0.24349548255735684 - 0.4291916035193559im" ] } ], "prompt_number": 122 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another sanity check is that the scattering amplitudes should go to 0 as $m \\to \\infty$:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "scat_amplitude(s, 0.3, 30)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 123, "text": [ "2.4707060062781136e-37 + 2.164961838917851e-23im" ] } ], "prompt_number": 123 }, { "cell_type": "heading", "level": 1, "metadata": {}, "source": [ "Planewave scattering" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To solve for the scattering of a planewave $e^{i(kx-\\omega t)}$ ($k = n_{N+1}\\omega/c$) off of the cylinder, we use the Jacobi-Anger identity to expand the planewave in cylindrical waves:\n", "\n", "* $e^{ikx} = e^{ikr\\cos\\theta} = \\sum_{m\\in\\mathbb{Z}} i^m J_m(kr) e^{im\\theta} = \\sum_{m\\in\\mathbb{Z}} i^m \\frac{H^{(1)}_m(kr) + H^{(2)}_m(kr)}{2} e^{im\\theta}$\n", "\n", "and hence the total (incident + scattered) wave solution (*outside* the scatterer) is:\n", "\n", "* $\\sum_{m\\in\\mathbb{Z}} i^m \\left( J_m(kr) + V_m H^{(1)}_m(kr) \\right) e^{im\\theta}$\n", "\n", "where $V_m$ is the scattering amplitude for $H^{(2)}_m(kr)$ from above.\n", "\n", "We also need only compute the series for non-negative $m$ because of the $V_{-m} = V_m$ symmetry mentioned above. Assuming $k$ is real, this gives:\n", "\n", "* $J_0(kr) + V_0 H^{(1)}_0(kr) + \\sum_{m>0} \\left( J_m(kr) + V_m H^{(1)}_m(kr) \\right) 2\\begin{cases} \\operatorname{Re} \\left[i^m e^{im\\theta}\\right] & \\mbox{even } m \\\\ i \\operatorname{Im} \\left[i^m e^{im\\theta}\\right] & \\mbox{odd } m \\end{cases}$\n", "\n", "Although the exact solution involves an infinite series, the terms converge exponentially to zero for $m \\gg kR$, where $R$ is the outermost radius, so we can truncate the series once the terms fall below some desired tolerance `tol`. \n", "\n", "The exponential convergence results from the asymptotic expansion $J_m(x) \\approx \\frac{1}{\\sqrt{2\\pi m}} \\left(\\frac{e z}{2m}\\right)^{m}$, and can be demonstrated with a simple plot:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "semilogy(0:20, abs(besselj(0:20, 1)), \"ro\")\n", "ms = linspace(1,20,200)\n", "semilogy(ms, (e./(2ms)).^ms ./ sqrt(2\u03c0*ms), \"b-\")\n", "legend([L\"$|J_m(1)|$\", \"asymptotic form\"])\n", "xlabel(L\"Bessel order $m$\")" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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", "text": [ "Figure(PyObject )" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 24, "text": [ "PyObject " ] } ], "prompt_number": 24 }, { "cell_type": "code", "collapsed": false, "input": [ "# Return (M,V), where M is an array of the m >= 0 and V is an array of the corresponding scattering amplitudes,\n", "# computing enough amplitudes until the remaining terms contribute less than tol up to a radius r\n", "function scat_amplitudes{T}(s::Scatterer{T}, \u03c9::Number, r::Real=s.R[end], tol=sqrt(eps(T)))\n", " M = [0]\n", " V = [scat_amplitude(s, \u03c9, 0)]\n", " abs_kr = abs(s.n[end]*\u03c9*r)\n", " m = 1\n", " while (e*abs_kr/(2m))^m ./ sqrt(2\u03c0*m) > tol\n", " push!(M, m)\n", " push!(V, scat_amplitude(s, \u03c9, m))\n", " m += 1\n", " end\n", " return (M,V)\n", "end" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 124, "text": [ "scat_amplitudes (generic function with 4 methods)" ] } ], "prompt_number": 124 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's do a quick check to see how many $m$'s are needed for a typical structure, and plot the phase $\\arg(1+2V_m)$ versus $m$ as well as $|V_m|$:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "M,V = scat_amplitudes(s, 0.3)\n", "\n", "subplot(1,2,1)\n", "plot(M, angle(1+2V)/\u03c0, \"ro-\")\n", "xlabel(L\"$m$\")\n", "title(L\"$\\arg (1+2V_m) / \\pi$\")\n", "grid()\n", "\n", "subplot(1,2,2)\n", "semilogy(M, abs(V), \"ro-\")\n", "xlabel(L\"$m$\")\n", "title(L\"$|V_m|$\")\n", "grid()" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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", "text": [ "Figure(PyObject )" ] } ], "prompt_number": 125 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, let's define a function for plotting the total wave solution outside the scatterer, returning a 2d array of the wave amplitudes on a grid of `x` and `y` coordinates:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "function wavesolution{T}(X::AbstractVector, Y::AbstractVector, s::Scatterer{T}, \u03c9::Real)\n", " U = Array(Complex{T}, length(X), length(Y))\n", " M,V = scat_amplitudes(s, \u03c9, hypot(maximum(abs(X)), maximum(abs(Y))))\n", " k = real(s.n[end])*\u03c9\n", " R = s.R[end]\n", " for ix = 1:length(X)\n", " x = X[ix]\n", " for iy = 1:length(Y)\n", " y = Y[iy]\n", " r = hypot(x, y)\n", " if r >= R\n", " \u03b8 = atan2(y, x)\n", " kr = k*r\n", " u = besselj(0, kr) + V[1] * hankelh1(0, kr)\n", " for i in 2:length(M) # m > 0 terms\n", " m = M[i]\n", " phase = im^m * complex(cos(m*\u03b8), sin(m*\u03b8))\n", " u += 2*(besselj(m, kr) + V[i] * hankelh1(m, kr)) * (iseven(m) ? real(phase) : im*imag(phase))\n", " end\n", " U[ix,iy] = u\n", " else\n", " U[ix,iy] = 0.0 # don't try to compute interior solution\n", " end\n", " end\n", " end\n", " return U\n", "end" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 128, "text": [ "wavesolution (generic function with 1 method)" ] } ], "prompt_number": 128 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's try a simple example scattering off a perfect-metal ($n = i \\infty$) cylinder of radius 1 in air ($n=1$) with a frequency $\\omega/c = 2\\pi/0.5$ (wavelength $\\lambda = 2\\pi c / \\omega = 0.5$):" ] }, { "cell_type": "code", "collapsed": false, "input": [ "s0 = Scatterer(1, [Inf*im], [1])\n", "x = linspace(-4, 4, 200)\n", "y = x\n", "U = wavesolution(x, y, s0, 2\u03c0/0.5)\n", "pcolormesh(y, x, real(U)', cmap=\"RdBu\")\n", "axis(\"equal\")\n", "colorbar()" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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", "text": [ "Figure(PyObject )" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 135, "text": [ "PyObject " ] } ], "prompt_number": 135 }, { "cell_type": "code", "collapsed": false, "input": [], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 81 } ], "metadata": {} } ] }