From c0946bdde97ab2be06a5b1dad3eba00a7523857f Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 24 Aug 2023 12:21:47 +0100 Subject: [PATCH 01/49] Added Will's example Class for tension calculator --- tension_calculator.py | 48 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 tension_calculator.py diff --git a/tension_calculator.py b/tension_calculator.py new file mode 100644 index 00000000..c6b32c5e --- /dev/null +++ b/tension_calculator.py @@ -0,0 +1,48 @@ +class tension_calculator(dict): + """Class for computing tension metrics + + Parameters + ---------- + samples : dict + Dictionary of NestedSamples + nsamples : int + Number of samples to use for computing statistics + """ + def __init__(self, samples, nsamples=1000): + for k, v in tqdm.tqdm(samples.items()): + self[k] = v.stats(nsamples) + + def union(self, A, B): + A_ = set(A.split('_')) + B_ = set(B.split('_')) + return '_'.join(sorted(list(A_.union(B_)))) + + def intersection(self, A, B): + A_ = set(A.split('_')) + B_ = set(B.split('_')) + return '_'.join(sorted(list(A_.intersection(B_)))) + + def stat(self, A, B, stat): + union = self.union(A, B) + intersection = self.intersection(A, B) + return self[union][stat] - self[A][stat] - self[B][stat] + self[intersection][stat] + + def logR(self, A, B): + return self.stat(A, B, 'logZ') + + def logS(self, A, B): + return self.stat(A, B, 'logL_P') + + def d(self, A, B): + return self.stat(A, B, 'd_G') + + def D_KL(self, A, B): + return self.stat(A, B, 'D_KL') + + def p(self, A, B, d=None): + logS = self.logS(A, B) + if d is None: + d = self.d(A, B) + else: + d = np.ones_like(logS)*d + return scipy.stats.chi2.sf(d[d>0]-2*logS[d>0], d[d>0]) \ No newline at end of file From 70c0aa44e8eeeb59d12d1057d1f8edfb84fd9b4e Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 24 Aug 2023 12:37:11 +0100 Subject: [PATCH 02/49] Changed Version from 2.3.0 to 2.4.0 --- README.rst | 2 +- anesthetic/_version.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index 04cfefd9..3e58c60f 100644 --- a/README.rst +++ b/README.rst @@ -2,7 +2,7 @@ anesthetic: nested sampling post-processing =========================================== :Authors: Will Handley and Lukas Hergt -:Version: 2.3.0 +:Version: 2.4.0 :Homepage: https://github.com/handley-lab/anesthetic :Documentation: http://anesthetic.readthedocs.io/ diff --git a/anesthetic/_version.py b/anesthetic/_version.py index 82190396..ba9b9133 100644 --- a/anesthetic/_version.py +++ b/anesthetic/_version.py @@ -1 +1 @@ -__version__ = '2.3.0' +__version__ = '2.4.0' From ee1db5b0489e08103e4467770e598b6af2e61b62 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 31 Aug 2023 20:40:07 +0100 Subject: [PATCH 03/49] Added Class tension --- .DS_Store | Bin 0 -> 6148 bytes tension.py | 6 ++++++ tension_calculator.py | 2 ++ tests/.DS_Store | Bin 0 -> 8196 bytes tests/example_data/.DS_Store | Bin 0 -> 6148 bytes tests/test_tension.py | 5 +++++ 6 files changed, 13 insertions(+) create mode 100644 .DS_Store create mode 100644 tension.py create mode 100644 tests/.DS_Store create mode 100644 tests/example_data/.DS_Store create mode 100644 tests/test_tension.py diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8c3328dadf43943bbbc40b2fbbba5be87249e4be GIT binary patch literal 6148 zcmeHK%}T>S5T0$TCW_F5qIg>HS~0a%6fdFH7cim+m73V1!I+gMwTDp1Rng}Wd=Q_< zncZ!%Ry~U74$OZ0Gn4Rr8+J1Qz#6@F6`%|N7CK?U#^w{Fb@B--=$R5Clg~)u3ObNN z2p1F4X5u$0Kzla}KE$|h3GUoz|AKyU8$=?&^_So_3X{}vURj}7nwp-mENjj>^R7hS zOZ~K$H2m%fjShu~f??kej>1mARbJQ=aq5S0rz;b}b_YXFkHfev`VG;G+lkEe)PiN( zcB{OSWouQZ>Qs2$*&bAQwzEO~+SXuTTZ^mfy9cf7=q47AN>YYjpR{?6LwLf@r|j;$ zZXAjD64xnr3YjbZ$vfW9KhAq8%j%mIUfXoOA$_mdeM$OZoX`iVD%rF~0i(b_S3sYd z*4#hW!O%Af7zHL3p!0#F6S^96h4SdYMwS4G^cyJ+`&3I%4%g^v%oXAa8dIr=DwXLH zgQ;|!=Q_^Sm@8E2z;yA!^qZNkP?&r>KA+2QV6H;b8U>63;|dhjuuS*={@3;Yc#;_z z1&jiJN&!}Cdd&t>(s%0wIl5~(`Z+oo#pMb|DcF%$F~-tWyo@dl=Q(u{U5&XyoIx`` N0#XLk7zKV*fj6RIit+#e literal 0 HcmV?d00001 diff --git a/tension.py b/tension.py new file mode 100644 index 00000000..5d9c98cb --- /dev/null +++ b/tension.py @@ -0,0 +1,6 @@ +class TensionCalculator: + def __init__(self,A,B,AB,nsamples): + self.nsamples = nsamples + self.A = A.stats(nsamples) + self.B = B.stats(nsamples) + self.AB = AB.stats(nsamples) \ No newline at end of file diff --git a/tension_calculator.py b/tension_calculator.py index c6b32c5e..a21c1b54 100644 --- a/tension_calculator.py +++ b/tension_calculator.py @@ -1,3 +1,5 @@ +import tension + class tension_calculator(dict): """Class for computing tension metrics diff --git a/tests/.DS_Store b/tests/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..6bf44c15db677ba3c20a14fd99049dffacff0aaa GIT binary patch literal 8196 zcmeHMU2GIp6u#fIzzm(S)0Rs4DP3sPMq6ns0>yyKw)`}Jt?c#>&}DXKq!XtzWoNcU zo5uPVjf&yTAN0Y*7&Vb-6u~#+iyB^tRwF!M`YEGukdHE+=j2NFMy}ts#aEq z6&%%NJm7nUpffZav}t{zr5Al`zeS7NV^$Y!;pu$fR_1-PpI(O~uoz|X|_0s<5vTB%8DleS3rOS{Dfmr5x#RPr#AcN5NgL{JJvM}%}@o)p@- zYv=Cnn>mFpRPv-*R(tF6y0tu$HgDa2opOSqB~t#C>>~GRiq6 zw5@2-)abTji>m77lzU=k+Zr0OXpripMR+F3|CZC|*fhJyF0)_R6)-HqQmnu_G~sSy za1tr(z)tKU7Vk#}eIb(#;;{(}E=GyVKCyWcPvA*Bg{Scnj^ky#LX19%H}EFj!Mk`5 z@8e^f#u=Q&XZQl=a2^+C@pjKl-s0kocsrIZxQ^!@A)ONMXPPg7QJL_uj@SP?=KuYF z0YoBpF^<5(jR4BK(p@R?f4-BD*V+lX4%5XO*P9X;not*(`lc4S&ey5G!|D^!_fACLUI$RV0 literal 0 HcmV?d00001 diff --git a/tests/example_data/.DS_Store b/tests/example_data/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..b2e0fe8e1cab31a37f66466d83e29e91e67a1355 GIT binary patch literal 6148 zcmeHKUrWO<5Kp$LDMRRk!X5*@4%{CZh%cqiFJMIwWM>v$eCkCxmE=``}5HK@k?q+z%JGXk96lMztPB*U7Y; zxCiGdE5an3E_6Z?Pa)*)Cdpz|`f8cQxy}uYLpY8zaXYJ3e>CjM!JxnH%GK$h*Oe#3 z(R%HO!=vM~%gJ*(%hanOlLOaU_AS=%28!OxOR&gNl|6!8$JQ}~!~iis3=jjvfUOOp zO;ivA!~ikyjR8C#Bs4_NVr5Vt9nj(R8T~Cp6wvW4fha9{7Au3`0pTVU(4=zv#NZ|! z#-)w(ELH|hI^%j}n8&VMKVGvTZ6 N2xvm6BL;qffls*=NSFWs literal 0 HcmV?d00001 diff --git a/tests/test_tension.py b/tests/test_tension.py new file mode 100644 index 00000000..769697a3 --- /dev/null +++ b/tests/test_tension.py @@ -0,0 +1,5 @@ +import anesthetic.examples.perfect_ns +import numpy as np + +params = ['logZ', 'D_KL', 'logL_P', 'd_G'] +stats = anesthetic.examples.perfect_ns.correlated_gaussian(100,0,np.array([1,1],[1,1])) \ No newline at end of file From a3d06b561bebce1a0c06924fc18ae7cb4a304f89 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Fri, 29 Sep 2023 17:20:58 -0700 Subject: [PATCH 04/49] version bump to 2.5.0 --- README.rst | 2 +- anesthetic/_version.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index 3e58c60f..764d2f1d 100644 --- a/README.rst +++ b/README.rst @@ -2,7 +2,7 @@ anesthetic: nested sampling post-processing =========================================== :Authors: Will Handley and Lukas Hergt -:Version: 2.4.0 +:Version: 2.5.0 :Homepage: https://github.com/handley-lab/anesthetic :Documentation: http://anesthetic.readthedocs.io/ diff --git a/anesthetic/_version.py b/anesthetic/_version.py index ba9b9133..e59b17b4 100644 --- a/anesthetic/_version.py +++ b/anesthetic/_version.py @@ -1 +1 @@ -__version__ = '2.4.0' +__version__ = '2.5.0' From 4a5d4b57d0b6eff32b2920cd609b198b5cb8ddc2 Mon Sep 17 00:00:00 2001 From: dilyong Date: Fri, 13 Oct 2023 16:58:24 +0100 Subject: [PATCH 05/49] Created a function called tension_stats for tension statistics calculation and testing it with correlated gaussian likelihoods. Found a problem with the function anesthetic.examples.perfect_ns.correlated_gaussian. The generated likelihood gaussian in the parameters is not normalised and the evidence is not unity. Need to take into account the LogLmax. --- .DS_Store | Bin 6148 -> 6148 bytes Interactive - tension_stats.py.ipynb | 99 + Interactive - tension_stats_2.py.ipynb | 4978 ++++++++++++++++++++++++ tension.py | 26 +- tension_stats.py | 40 + tension_stats_2.py | 93 + tension_stats_3.py | 93 + tension_stats_4.py | 114 + tension_stats_4.py.zip | Bin 0 -> 1721 bytes tension_stats_5.py | 113 + tension_stats_5.py.zip | Bin 0 -> 1358 bytes tension_stats_6.py | 122 + tests/test_tension.py | 50 +- 13 files changed, 5724 insertions(+), 4 deletions(-) create mode 100644 Interactive - tension_stats.py.ipynb create mode 100644 Interactive - tension_stats_2.py.ipynb create mode 100644 tension_stats.py create mode 100644 tension_stats_2.py create mode 100644 tension_stats_3.py create mode 100644 tension_stats_4.py create mode 100644 tension_stats_4.py.zip create mode 100644 tension_stats_5.py create mode 100644 tension_stats_5.py.zip create mode 100644 tension_stats_6.py diff --git a/.DS_Store b/.DS_Store index 8c3328dadf43943bbbc40b2fbbba5be87249e4be..384f92258c4c2b23d09a087d6d0410bd6ec5c557 100644 GIT binary patch delta 72 zcmZoMXffEJ&dj)bvH??}mUMNsuA!l+k&c3qfkCZ~LbaixnT3vmxv_C=EhmSlvc7dt ce0EN5UViW7{mk-=eVgwytFUZl=lIJH0N5B5+W-In delta 49 zcmZoMXffEJ&dj)dvH?>emw0uxiK&i)v8lo2bxhKXos&;7$uo9se$1@GGO>YWGdss$ FegJZ14=Mlv diff --git a/Interactive - tension_stats.py.ipynb b/Interactive - tension_stats.py.ipynb new file mode 100644 index 00000000..f64fed7b --- /dev/null +++ b/Interactive - tension_stats.py.ipynb @@ -0,0 +1,99 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "isInteractiveWindowMessageCell": true + }, + "source": [ + "Connected to myenv (Python 3.8.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from anesthetic.samples import Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nsamplees = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " #samples.['logR']" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "nsamplees = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " return samples\n", + " #samples.['logR']" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'samples' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samples\n", + "\u001b[0;31mNameError\u001b[0m: name 'samples' is not defined" + ] + } + ], + "source": [ + "samples" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Interactive - tension_stats_2.py.ipynb b/Interactive - tension_stats_2.py.ipynb new file mode 100644 index 00000000..352aa741 --- /dev/null +++ b/Interactive - tension_stats_2.py.ipynb @@ -0,0 +1,4978 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "isInteractiveWindowMessageCell": true + }, + "source": [ + "Connected to myenv (Python 3.8.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'correlated_gaussian' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 7\n\u001b[1;32m 11\u001b[0m covA \u001b[39m=\u001b[39m [[\u001b[39m.01\u001b[39m, \u001b[39m0.009\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0.009\u001b[39m, \u001b[39m.01\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m0.1\u001b[39m]]\n\u001b[1;32m 12\u001b[0m bounds \u001b[39m=\u001b[39m [[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]\n\u001b[0;32m----> 13\u001b[0m samplesA \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanA, cov, bounds) \u001b[39m# output is Nested sampling run\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[39m#samplesA.gui()\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[39m#plt.show()\u001b[39;00m\n\u001b[1;32m 17\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n", + "\u001b[0;31mNameError\u001b[0m: name 'correlated_gaussian' is not defined" + ] + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, cov, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, cov, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "\n", + "nsamples = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples\n", + "samples = tension_stats(samplesA,samplesB)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from anesthetic.samples import Samples\n", + "from anesthetic.examples.perfect_ns import correlated_gaussian\n", + "from anesthetic import read_chains, make_2d_axes\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'cov' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 7\n\u001b[1;32m 11\u001b[0m covA \u001b[39m=\u001b[39m [[\u001b[39m.01\u001b[39m, \u001b[39m0.009\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0.009\u001b[39m, \u001b[39m.01\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m0.1\u001b[39m]]\n\u001b[1;32m 12\u001b[0m bounds \u001b[39m=\u001b[39m [[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]\n\u001b[0;32m----> 13\u001b[0m samplesA \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanA, cov, bounds) \u001b[39m# output is Nested sampling run\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[39m#samplesA.gui()\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[39m#plt.show()\u001b[39;00m\n\u001b[1;32m 17\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n", + "\u001b[0;31mNameError\u001b[0m: name 'cov' is not defined" + ] + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, cov, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, cov, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "\n", + "nsamples = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples\n", + "samples = tension_stats(samplesA,samplesB)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from anesthetic.samples import Samples\n", + "from anesthetic.examples.perfect_ns import correlated_gaussian\n", + "from anesthetic import read_chains, make_2d_axes\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "tension_stats() missing 2 required positional arguments: 'AB' and 'nsamples'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 37\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n\u001b[0;32m---> 39\u001b[0m samples \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB)\n", + "\u001b[0;31mTypeError\u001b[0m: tension_stats() missing 2 required positional arguments: 'AB' and 'nsamples'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "\n", + "nsamples = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples\n", + "samples = tension_stats(samplesA,samplesB)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from anesthetic.samples import Samples\n", + "from anesthetic.examples.perfect_ns import correlated_gaussian\n", + "from anesthetic import read_chains, make_2d_axes\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy import linalg" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "covA_inv = linalg.inv(covA)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 526.31578947 -473.68421053 -0. ]\n", + " [-473.68421053 526.31578947 -0. ]\n", + " [ 0. 0. 10. ]]\n" + ] + } + ], + "source": [ + "print(covA_inv)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating mock datasets A, B and AB\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "covA_inv = linalg.inv(covA)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 526.31578947 -473.68421053 -0. ]\n", + " [-473.68421053 526.31578947 -0. ]\n", + " [ 0. 0. 10. ]]\n" + ] + } + ], + "source": [ + "print(covA_inv)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.01 , 0.009, 0. ],\n", + " [0.009, 0.01 , 0. ],\n", + " [0. , 0. , 0.1 ]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "t = linalg.inv(covA_inv)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.01 , 0.009, 0. ],\n", + " [0.009, 0.01 , 0. ],\n", + " [0. , 0. , 0.1 ]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.10526316, -1.06578947, -0. ],\n", + " [-1.70526316, 1.31578947, -0. ],\n", + " [ 0. , 0. , 0.3 ]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 38\u001b[0m \u001b[39m# Creating mock dataset AB\u001b[39;00m\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[0;32m---> 40\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 41\u001b[0m samplesAB\u001b[39m.\u001b[39mplot_2d(axes)\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG5CAYAAAByehWbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADoCUlEQVR4nOydeXwU5f3H33skm/vgCgFCuG855VAREbwqCqJ40OL1o1XRllarVdpavPFqsSpaq9SqKGo9UVBREJQbOeW+Q4BwBMidbPaY3x9PZnd2s2cym90kz/v14jVLdvaZZ3dn5/nM9zQoiqIgkUgkEolE0kQwRnsCEolEIpFIJHoixY1EIpFIJJImhRQ3EolEIpFImhRS3EgkEolEImlSSHEjkUgkEomkSSHFjUQikUgkkiaFFDcSiUQikUiaFFLcSCQSiUQiaVKYoz2BaGC329m0aRNZWVkYjVLfSaKP3W5n27ZtnHfeecTFxUV7OhIJDoeDffv20a1bN0wmU7SnI5EAoCgKpaWltGvXLuD63SzFzaZNmxg2bFi0pyGRSCQSiaQO5Ofn06FDB7/PN0txk5WVBcC6devIzs6O8mwkEtizZw9jx44lPz+ftLS0aE9HomXD27BmDoy4B4bcEu3ZNBhHjhyhb9++kTknm+lnKqk/JSUl5OTkkJqaGnC/ZiluVFNWdnZ2QOUnkTQUpaWlAKSlpUlxE2ts/hdYj4ntxb+N9mwaDPU8jMg52Uw/U4l+GAyGgM/LgBOJRCIJxMh7IT1HbCX6ID9TSYRplpYbiUQiCZmhU8U/iX7Iz1QSYaTlRiKRSCQSSZNCihuJRCKRSCRNCiluJBKJRCKRNCmkuJFIJBKJRNKkkOJGIpE0PtbPhdn9xLYhXieJHRr6O5TnTKNEipsgHCuqZNq8DZzzyDeM/fsyXv/hADaHM9rTkmipPAuf3wPPdYfXx8De76I9I0mkWTEbivPFtiFeJ4kdGvo7lOdMo0SKmwAcPl3BxFdW8tW245RW2dl/qpwnF+3kV2+spaTKFu3pSUAIm/9eDZvmQflJOLoB5t8I+7+P9swkeqK9e14/F6rLICHTf50Uf3fbsr5K48P7u/T1HYZjXQnXEiPPmUaJQVEUJdqTaGiOHDlCTk5OwN4UdoeT619bzabDRXRvk8JjE/pxsLCcWYt2Umq1c25uJu/+ZjgWs2woFzUUBf53K+z4HJLbwJXPwfZPxP8TW8D0TZCYEe1ZhsTOnTvp06cPxcXFskKxL2b3E3fP6Tni/+rje7cF39/fPpKAqNfJqJ+ToXyX4Xzf8txo1JSUlJCenh70vJSWGz+8syaPTYeLSE0w89//G8Z5XVvyy+EdmX/HCFITzPyUd5ZHv9gR7Wk2b1QhYzTDLz+AvtfAta9Dq55QeQZW/CPaM5R4U9f4Be3dc85wMJjENpT9JY2LUCw13gTbRzumPDeaBdJy48NyU1Jl46Jnv+dshY0nJ/bjV8NzPZ5fvucUt/5nHQDv/Xo453dr1SDzlmioLoeXh0LJUbjoIbh4hvu5Pd/AezeAOQHu3QHJLaM3zxBpdJab9XNFDMLIe8OrNKvHXbO8824Qoma5icT362/Mup7HkqghLTf14D8rDnK2wkbX1snceG5Orecv6tGaKSM6AjBzwXYczmanD6PP6jlC2GR0hJF/8Hyu+2WQPRDsVbDxrWjMrulT1yBL7V1zICtOoOd83Xn/ezQ8ki62ksbNyHtFPFV1mX4ZSv6sNUseF+fxksfdf6vreRnOPpKII8WNF2VWO2+uPATAHy7pgdnk+yN64PJepCWY2XuyjEU/FzTgDCVUnIFVL4nHY2dCXKLn8wYDDL9LPF7/BjgdDTu/5kBdTftDp4o756FTawsk7aKgPrf08doLhXYMlWObPLehIBeh6OLv8x86FSwpIllArwwlX+cMgMFrC+KcU889b0IR9Y0pu6oJ/wakuPHivbV5FFfa6NIqmSvPyfa7X3piHFNHdgFgzvf7aIbeveix6kWwlkDWOdD3Wt/79LsWEjOFdefAsgadXrPA32IRDt4CSStorGXi+1MIvlCsnwvGOPHYGOfOqAp20W5Mi1BTxN/nv36u+/uvT1xMKOfAmIfFOTjmYfffFK+tFj3ifyJBXUVKsN9AIxY/UtxosNodzF1xEIC7LuqKyWgIuP9t53fCYjay63gpGw+fbYgpSirOwLrXxeOL/wxGP6ew2QL9JonHW95vmLlJwkMrkLTp3QpQdVZsHVbAEDh4eMVscNpEkLHTJv4finCRgaWRJdjC6O/zXzFbfP/xKYHFc7DxQzkHfIn0sTWCZ+zDnvuGGp+jh/APFz3cxHqOGwNIcaPhs01HOVFiJSvNwoRB7YLun54Ux9UDxH7z1hyO9PQkAGteFYtg23Og5y8C7ztgstju/ELcCUpilxWzhRvCkuJeXAyArQJQIH+t/9eqF+i+E90X6lCESzQWoeZEsIXR3+cfqugMNr4ertNwjhdN9H6v9R03BpDipganU+G1Hw4AMHVk55Dr1/xquAgs/mpbAaWysF9ksZbBun+LxxfeL2JrAtF+MLToAvZK2Ls48vOTCOpiytZeRNUL7piHhWtCW6wv0Ni557sv1FK4RJ9ILbihju9vnLq6WkIpQRAtfL1XPVxKjfh3JMVNDYt3HOfAqXLSEsz80iv1OxADczLo0jqZKpuTr7Ydj+AMJWx6B6qKoEVX6H118P0NBugzQTze8XlEpybBfTFVM1CCxcnM7gcfTRVb8HRRPdNJjDPmYWHJWTHbM9B40QPui3Ys31E3ZwItjMEW3lCeDzWF+6Op8GgLsYXAgeyByF8LiiOwFTHU+TcEzfx30SjETaSDdRVF4ZVl+wG45bxOpFjMIb/WYDBw7aD2AHy68WhE5idBZDyt/Zd4fN49YAyxMrQqbvYuhuqKyMxNIlAvpgb8p3t7C6Dtn4rtwj8KQaMuWpVnRdyFd/zMyHvF3bPicAucRmw6b7YEW3h9pWhrUTOaFv4xeAD59k/F+bL9U/F/f4HswURAOOdZsPk3BM38dxHz4uavf/0rt9xyC8888wybN2+u0xhWq5WSkhLXv9LSUo/nf9xbyNYjxSTEGbn9gk5hj39NjbhZc/A0x4oq6zRHSRD2LoazhyAhAwbcFPrrsgeKH7itolFkTZWUlGC1WqM9jbqhXkzHPOw/3VsrgBIzwaBeghQhaJY+LsbRuqO8XVZXPucWOCtmN2rTeaxitVpd18mInJPB6h35StHWomgeBAsg7ztRnC99J4r/e58v/kSA97zCOc8Czb+hrDrN/HcR0+Lm+uuvZ/ny5Zx77rksXbqUjz76CAjfkjNr1izS09Nd//r06ePx/Mvf7wNg8rCOtEyxhD3PDplJDO/cAkWBzzZL601EWP+G2A6+GeKTQ3+dweAOPN7zlf7z0pmcnBxmzZoV7Wn4J9CFeehUsUCoLiSovXCowkVBxFA5veLUlJpxHjwEDx3yjJ8Btwvryuea9V1ppJk1a5brOhmRc9JXvaMlmppGvlK0tYx9WIjfRC8BnDO89vk5aS7MPCO2WtRzGYIHEIcrSNR4MYXar2lId1EsuMeiRMy2X1i9ejV33nkn69evx2KxsGTJEqZPn86PP/5IZmYmhmDBpBqsVqvHncfRo0fp06cP+fn5HLMlccNrq4k3GVn+p9FkpycGGMk/H6w/zIMf/0yX1sksue+isOYnCULRYXihP6CIZpgtuoT3+n1LYN61kJIF9+3ynz4eRdT2C/n5+bRu3RqLJXyR3SAEKo3/0VTYJm5AiEsS6fgKYiHSLhzqGFr6TRKxDDnDYf8Sz9d9NBW2fYzrdl22XYg4VquVAwcO6HdOqu7GnOHi9+iwgskivuO8VcJlZLYIC6v6/dalNUIorRvUca1lwvXpb9+Ppop59Z0ozs1w2zfo2fIh0GvqModGTKNvv2CxWEhJSWHv3r0A9OzZE4fDwd13383999/PV1+FfhdusVhIS0tz/UtNTXU999JSMf6kczvUWdgAjOvfjuR4EwdOlbP6wOk6jyPxwaZ5gAKdLwpf2AB0GilqZpSdgILNes9OV9LS0mJX2EBgP74a0wBikVLjZhbeB09ki/YIs/vVfm2/SeKu+t5tYhHRxtu4xq0RNgaTtNY0ABaLxXWdDOuc9GcpUK0V2z4W362tQmyXPO6OiTFZ/MfChNoSIZQ4E1+xYb5QA4i3fypEmfe+6+eKuC9/Vhh/cwnXXRTsOIEsQbGc4RVhYlbcdO/eHaPRyOzZs7n77rs555xzmDBhAlOmTMFut/PBBx9QWlpar2DjbQWl/Li3ELPRwLSLutZrvikWMxMHi9ibt1YdqtdYEg1OJ2yZLx4PvqVuY5gt0GW0eLx/iS7TatIEcz15ZzU93Uk87jsRv0ES9ppgbm+LDQZPd4F3vA1Adn+xNcYJd1QzjSGIOXydJ/4WWnWhN2mSNRIyxemiOMT/W3TyXdRRdXWGsrj7co16z9VXbJgvtMHr+Wtr77titnhOFdz1idEJhPdxfM3Tn0gLJ8OriRGT4sbpdJKamsqiRYu49dZbadu2LePHj+eZZ57hqquu4pprruHnn3/GbrfXy/3z5uojAEwc1J6cFkn1nvct53UC4JvtJ9iSX1Tv8SRA/hrhlopPhV7j6j5O1zFiu0+Km6AEyvTw7v+kWlkWPQBn9osA4fQc9/5qWwQt2p49Zi9rqXe8zfq5cGyzeM4SpGKtpGHxJTiCBgrXnA8JmeI71sbUFGz1HFst6ghC6JiTfDfTDCX7SRvXE6pLSA1eT8wULix/x1UFd30zpPzdVHgfJ9QxvAViMyPmxI2iKBiNRux2O2lpaYwaNYqUlBTy8913fPv27SM+Pr7ex1p9sAiT0cBvx3Sr91gAPbJSXWnhD3++jcpqhy7jNmu2fiC2fSbUbpAZDt3Gim3+Oqgqrv+8mhLeF1XvTA9fDS2XPA4VGver4hBNKxWHp3XGO2AYaqpFG0RczuVP+J7P053ctW5Ul1RMRgc2Y3xZDFTLyZLHRZq2KjLU8ybO4tnaYOhU4ZbUZjN5j60KHYdVbLU1jlSqy8QxfbmmtIu8Af8WIF+d5YdOFS7tqrO1m7h6WzGrisTf65oh5c86pX6mSx93W0m1tXu0r/N+rArEZnhTEBPiZv78+bz++uv8/PPPlJWJMvlms9nlcrruuuvYuHEjV111FXfccQd/+ctfmDNnDpmZmfU+9sRB7cltGUb2TRDuv7wn6YlxbD1SzE2vr2H5nlPYHU7dxm9WOGywY4F4fM6k+o2V2QladhOL76EV9Z5ak8L7oqrNVFk/171ILXncvXAYqGmN4IN2gwIfz2kHFEhq6fuiq/YWqjzrThlPyKzd60cSXfy5XZY8Lr4/FLcrJZAryFc2k3ZsbXsNbQkAVTAsfdxtQVzyuLvxqop2kVfPbV+WDH+d5dXjKwR2janv11eGV317nXnXftLW7tG+zt9jaHaZU1EXNxMmTOCZZ55h4cKF3HjjjTzxxBOsXSv8gwaDAZvNRm5uLlu3bqVfv3706NGD5cuXM3jw4Hof22w08Pux3es9jpZ2GYn857ZzSY43sSW/iFv/s47LZv/A+kNndD1Os+DQj1B5RiyCnS6s/3idLxLbA8vrP1ZTwjuNFjzTdF3BvJrXdB3rYyCDGKdgq+fOCZk1gscgXAv9rvNv6lfno6b5jnnY000liX0MmgdXPiceBnMFeVesXu8ldEbeK+JGtP3DVMGg4BbABmoHpIdazE4V5d7iXBVaas8zX+nmwVxH9e115h2Lpq3do32dNuYIPMfzVd27CRPVVPDly5dz99138/PPP2M0Glm8eDEffPABNpuNu+66i/PPP99jf6fTiVGHNN4jR46Qk5PD7/6zjBdvv6je4/mioLiSfy3bz+dbjlFUYSMp3sSC315AtzapwV8sEXzxe9jwXxh8K4x/sf7j7fgcPrwFWveGe9bUfzwdUVPBg6U3RhQ1bTShxiJqQIiYfUvE4zEPuy+Q6TmQ3MrzLjc9B0qOuQNEwW1xWfSA+Lt6gV/4R0Bxx15IYg71OhnSOalNRwZPMaNNR1YXXvU577Rs1TLjnbrsndK8fq6w0qjnpbqAr58Li/8KtkoholVrUKjp36G8x/qM0RD4S//WlmqI1bmHQKNIBU9LSyMrK4uKigqcTieXXXYZd955J0lJSbz//vscOSICft955x2WL1+ui7DRcvt5OcF3qiPZ6Yk8OqEfyx+4mBFdWlBR7eD372+OeCuJJoPTCbsWicdqC4X60ulCwACndkLZSX3GbEqod4dVRW63UP5aIU7sVpHSXZwPGGoLG4DS47itPEa3sNFme+QMF0JHaw1qZubyJom/jKWPpop4l7gkIQrUtglqwT41CFdNy87uL86T5FaelhzvVGzVdRnvFU8ydKqw9Hp3klfnV1XkLvynxd85qM0IXOo1V++g6UBj+GpBosf57t03C/xbidTPQ/0des+hif0OoypuWrduzY4dO3jrrbdcwmXYsGHceOONbNmyhV27dgGwZcsWWrVqpf/xU+oflByM9MQ4Xpo8mKR4E9uPlbBq/+ngL5LAsY1QflJkSenhkgJIagFta9wuB3/QZ8zGRLCLL4jFQhu5W3G65k5YG1+j1BY2IIKHlZr4MsUJ1hLxWBVNljRhBVIcgMHtdmrmDf6aJOp3uv1TIZLtViFGFNwxW1qhoMbilBeK86Ngq2fvMbWEQ96q2mLH+7z2ru2yfq47iF09t71Txb17VWn/rrq5KouEYPfXXsTfeeyvBYke57t33yzw797Sus7UooS+MsqayO8wquKmQ4cOvPbaazz22GO89957gMiWuvjii+nduzdvv/02AE899RR9+/aN5lTrRetUC5OGdADgzZUHozybRsLuGqtN90vArKMIzR0ptodX6zdmYyHYxXfJ4+6UWxVbhf/A4YAYPHs/qRknrgDhDLc7oZk3+Gv0rJ/rzpArzneLicRMd4yMuh1bIwy0Qeuqe+SZTkJMxyWJgn7a16vBvKrY0dad8T6v99cIaFUQqVaehAzPsbSxJy49r3j+PjwM7UrtzCOtkPKXBu8ttupyvvu7MfHumxUIX0Ha2jk0sd9h6O2vI8T48eM5fvw4Dz74IBUVFfz6178GoFWrVlRUiIuqHmnf0eaW8zrx9uo8vt99ipIqG2kJPup/SNzs+UZse/xC33Fzz4e1r4o7wOaANhZCG++gJWe4iJWprun1ZE7C4y43EAk1bixtBeErn3OX1Fcv6Ooxuo71vGtUgyBlsHDjQz23qjWZSe0GucVEek7tfk7+ULOBwB13Y68UNzkmiyjloG3b4L0oq60dZvcTViJwn77a5/PXirFUi8fSx8Vz3ca6235ox1bdquprfbl61CJ5k+a6z+OnO7mztywpnoX06nK+e7v9VCbNDf0z1uJrDk3sdxj1bCmDwcDUqVN59tln+f3vf8/48eOZNGkSL730Erfeemu0p6cb3dqk0LV1Mg6nwo97CqM9ndimpABObAMM0O0SfcfOrQlSP7kDKppoBpuvujTa7tngGc+we5G4+Drt4jl7Je6VoSYDymASC5fB5HmssQ971h/qO1EsGNs+dt89r5/rXkzUBaIJ3SE2W9Rzy2YV50W/SXDHMvG9mpPEc09m+47h8La2qK5L1Wqjimu1TUP+WiESbBVud6c3+5aIMU0+aumMvNfT6qM2XlWtOPlrhRVJLRqoov5m1PYg/lw93ueyQbPV43wP1BhU4pOoixsQNW0mT57Mhg0bmDhxImPGjGHdunUMGDAg2lPTlTG92gDw/W4ZzBoQ1ZzcfjAkt9R37ORW0KqneNwUXFOBSuAvesB3Txxtn5/ifLfbyZwoLDEmM2AQi9W4v7szoMoL3am9IKoPD50Klz0hjjHuH+7eUNrCe0sfd8fZqFkyepSll0QXNWXfXlm7xL/absNWEVrfJbUydVJL8dqEDDF2XJI7/VnbDkF1KWn7LjlqRFa3sf5bJYBnnyVVzCS3qlsXcH/nstbtpsf5ro7hK1ZG4pOYEDcqvXr14vbbb+fuu++mZ8+e0Z6O7lzcU4ibZbtPyaypQOz7Tmz1ttqodBwhto2934q/hnrBeuKoC4vRyytttog7TYcNV7aJd1+boVPdqeLxNQuD1iJkLQNTjcs1LkncPaunekKGFDRNiaFTa8SBAhjcdYu056Ipznc9I18LvjZWZ+zDokTAXwrcNY7Udgjqub30cREArApnk8V/HyX1NwHu87o43x0rVLC1dlXkcEWEVhBFSsBLq2fIxJS4aeoM6ZRJvMlIYZmVw2fqEqTZDHA64cAy8dhnoTgdUO/cDjdyceOvoZ66CKi1aLSpotoYHJM27svgzmaJq4m5UYMk1UwnFbWYWbexnne3aqyFo8a9ZbaIuaj7ywrDTQ91sU3IcPcYU62F4/4BKW09C+oFQq1srOBfFGjPbQVcyjkxQ5xfCZm++09pX5cz3C2iVFerdzE8rRtI2xw2EHplG4XauLYhaMTp4VLcNCAWs4m+7cUisfHw2SjPJkY5vlW4NeJTof2QyBxDtdwc2+QOPmyM+KuK+tFU9yJTsNUzVVStK7LwjzUWGhAuqOvcAkStE7L9UxEYXFXiuUCpF3/VraU2wlSFkHcvKOmGarpoq/f6shYGszRoF09tnEqg2jDaY6pVe1X3jyVFXD8CuZb2LxHnc1UJDLq5dusH7ftS3ayBBJp6HF8uYF/4qk2jpaFTsgMJmEacHi7FTQMzuKMw6W/MK4ruRGIVtf5M7vk1sR8RoEUXSGolfPQFWyJzjIbAn2jQ1r7wThVVFxAUdwCxlrxVNdkvNanc2z5yxyqUn/a00vhqaFlVE+xpMElLTXNBFdPZ/X030gwkbLWLpzZOJZTaMEOn1g4CDuRa0gZAg2fsjj9G3utpyfRG6xr25QL2ha/aNN7HbEjXkz8Bo3UTNkI3mBQ3DYxL3EjLjW8OLhfbLhdF7hgGA+QME4+PrI/ccaKFKmgsaUKcZPd335mOedgdqGlOxJWVsu0jz6JriRm1M6PsFeJC/u/RUHxEuLW0DS21bjJ/PXYkTQ91sS7Y6rm4B3NpeC+egeqwqFZB7/gd74U52BjpOaIzuYpai8kf3hWPvd+TP9dwIILVpvGu8Bxpt5A/MeWvCrQvYtB9JcVNAzOoYwYAu46XUmVzRHcysYbDDodrej7pVZXYHx2Gim1TFDdql+WqGgF9bJM7s0St6WG3ujNatBiM7srBVz7nvms1xuGy5hzbhLD8ON19obRmeSlsmg/r54rYKgyei7W/YHfvMgW+Fk9tXJj6d20hSO/geX9WDm+rkfr/MQ+7hXswUeItwHylsKvnPARf4NfPdaeiB6pPo63wXN9ml8HcYMEqGoci2mLQfSXFTQOTnZ5AZlIcDqfCvpNlwV/QnDi+RbhEEtIhq19kj9XhXLE98lNkjxNNjJqA4UUPuEvMq3faQK1CfU6bsNzkrfK8a1Wc7rgcbRAmuC9soZrlJU2HFbNFund6B8/F2p9FQz1Xlj5e81v34fLwt1B6L7bezTpDtRxog4uDCXFvAeYrhd1fpWR/4wXbx7vCsxrLVFfhEMwN5o9wYuViMItLipsGxmAw0DtbBBXvOOanGFVzRa0a3PF80LlJai3aDRJWiuJ8UTSwsRDsLkx7Z9xnAq4gG8Xh7uujlrRvN0g8b04SNW0SM93jbPtYFGArPuJ+vSpe7ljmGYQZgxc2SQPh3VpAxV+wu/p3BSGivdsZaPfRiphnOolgeG03ca1lKFzLgXbhDuRSSW7luQ204IfyOwhlH62gmjTXLcRC+X35ei/htGioKzGYNBD19gvNkT7Zaazaf5odBVLceKCKG7WKcCSxpEKbPqIS8pH10Gd85I9ZF7xN9Ns+xhUjk3t+7YuJtoCfJQ2PSsPdxnreXc/uJ55Pbun++0dTxR2eyaLpKWUQd+b+Lq5NrGy7JAy07Qe0qOeDVmwsfVycjtoYLbUPk3eLA7Vukrqf2ppBrbTtyzLkq7VIILTtI9QMK+/zuGCr5zYQofwOQtnHu01KOL8vX20a6tqioZEjLTdRwGW5keLGjdOpETcXNMwx1VTzoxsa5nh1wfuOVFt4z1csQ85wXLExtjJNULBSewHy1egv93xhlbn8CXe8Tb/rPNs2xFDQoCTK+LNE+LKsaFOqfblz1PgSX+4oNeXbOzhYtQzVxXLg3T4iuVXDWD3U35q/YOFQrUq+kFZUF1LcRIE+7YS42VlQIisVqxTuFg0Y45JEdk9DoMbdxLK48b5YudJeDZ4XMLV+jWrZARGgfeVzYlHwTuf0tgj5yjr5SwE8UuS+64vBoEFJlPEnKrwtK74EioraxsFgxGfKtdqaQa1UHOi44aDNnlKzvbzPbzU4P5DlI1wBEkzM+dq3Lu62Zo4UN1GgS+tkTEYDpVV2TpQ04iJyeqJmSbUf4lU5N4Kolptjm8EZo5lr3hcrtRbIuL97XsC09WvMSTWNDK8T+zx0SCwO2v3V4GJtAb6ETKg47b8aq7wrlHjjb2H3ZVnxFigqavE9p6btR7jHq8ucwZ09pY1FC/f8DleAqJ9NKMeTv7k6I8VNFLCYTXRqmQTAnhOlUZ5NjKBe0NTqwQ1B614QlwzVpVC4t+GOGyq+LuSBGvWpd8aXPyHuNnPP978QKF5bdYFRuzBL64wkFPwt7OFaELTF8ny5h4Idzxf+hJC/2jj+On+HMvdwBEg4x5OWmDojxU2U6N4mFYC9Mh1coHbozmlAcWM0QbuB4vHRGEwJ1wYH+ypDr8XXnbE27da7lD24GxSqBHIdaMeTwkei4ituqy6F57RlB7zdQ9pzXo/aK+GKkWDWIilAYhIpbqJE9ywRO7FXWm6g7CScPYTwtw9t2GO3GyS2Rzc27HFDQdvdW+2VE6wwmvZvaq0Mhdpl6NXeOloCuQ7U+UgTuURLoMDgJY/XLRg2u79nerl3BlCowe3+ztdAYsTXb0mK+kaJFDdRonuWtNy4yF8ntm16iwJ+DUn7wWJ7LAbFjXcn40UPBC6Mpr34amtlqA0G1dL13qJJRd6hSuqDdyyJAf+iwFdjTDXAvbzQM73cl0jxPufDceEGwtdvSYr6RokUN1GiexthudlzolRmTB2pETcdGthqA9CuRtwc3xYbHcI3vO15kdZ2J/bXt8lX3x3tBdm7dL1WNAUTSRJJqHjHkqiBuqG4OLX/91cFGPy7p/Q6d30JmVBEUgz2VmruSHETJTq3SsZogNIqO6fKYmBRjSb5Nf2d1GaWDUlmJ0hsITI1TmwLunvEWTMncJyAKmy0F1NffXe8L8iBysZ7H0PeoUr0IJxqvt5i3Pt13i7ZYOd3JOYcCHljEHPICsVRIiHORE6LJPJOV7D/ZDltUhOiPaXo4LC5XUIdoiBuDAYRd7N/iYi7UdPDo8WIe2Dzv3zHCWgvuN5xCN5VTb3Rq3qqRKIH3udasHMvWPftaJ+7wX5/kgZHWm6iSNfWwjW1/1Qzjrs5/jPYq0SsTctu0ZmDK+5mU3SOr2XILaHdOYZiiZFImgr+elXFCvL3F3OEbbkpLCzkP//5D6tXr+b48eMAtG3blvPPP5/bbruN1q1b6z7JpkrX1sks3dXMxc2RGpdUh6GRb5bpj3YxJG5CJdp3qhJJQyLPd0mYhLWarF+/nh49evDiiy+Snp7OqFGjGDVqFOnp6bz44ov06tWLn36KwXohMYrbclMe5ZlEEZe4iYJLSkVNBz+1C6qb8XchkUgkTYSwLDe/+93vuP766/nXv/6FwWDweE5RFO666y5+97vfsXr1al0n2VTpWpMxtb85p4OraeANXd9GS1o2pGZDaQEUbGmYruSSZs28NXm8umw/00Z3ZcqI3GhPRyIBmtZ5GZblZsuWLdx77721hA2AwWDg3nvvZfPmzXrNrcnTpVUyAEeLKqmsjtHeRpGk7CQU5QGG6Afyqq6pWCzmpyLTTZsMry7bz9GiSl5dtj/aU5FIXNeWgu/mNJnzMixx07ZtW9atW+f3+XXr1pGVlVXvSTUXWiTHk5EkmkQeLGyG7pBoFu/zpn2NayoWi/mpyHTTJsO00V1pn5HItNFdoz0VicR1bZlmXtBkzsuw3FL3338/d9xxBxs2bGDs2LEuIXPixAmWLFnC66+/zvPPPx+RiTZFDAYDXVols/FwEQcKy+jTLi3aU2pYolm8zxvVchTLlhttuqm2oqsMtGx0TBmR2+jN/o0a+fvxpObakjLyXlYOHRPt2ehCWOLmnnvuoVWrVsyePZtXXnkFh0O4UkwmE0OGDOG///0vN9xwQ0Qm2lTp0jqFjYeL2H+yGVtuolG8zxs1qPjsQag4A0ktojsfX2gzRmb386xzI5FIQse7TlRzpwlmo4Wde3vjjTeyZs0aKioqOHr0KEePHqWiooI1a9ZIYVMH1IypA4XNLKjYYXOnXqsN8qJJYia0qDHFxrL1RkVWE5ZI6o78/TR56lyhOC4ujuzsbD3n0izp0loEFR9obungBVtF8b7EzOgV7/Om/RA4sx+O/gTdL4n2bALTBO+0JJIGQ/5+mjyyQnGU0VYpblYNNPPXiG3OcNECIRZwxd1siO48JBKJRFIvpLiJMrktkzAbDVRUOzheUhXt6TQchzXiJlZQA5uP/ATNSWhKJBJJE0OKmygTZzLSsWUSQPMJKlYUyF8rHnccEd25aGl7DpgsUHkGzhyI9mwkTYx5a/K44OmlzFuTF+2pSKKIPA8ahkYhbkpLSwGarNum2TXQPHsQyk6AMc6dpRQLmOMhe4B4fES2EZH4py4LlCzcJwF9zwMplPwT8+LmtttuY/r06Rw9ehSDwdAkBU63mjYM+5pLG4a8mvYc7QdDXGJ05+KNyzXlv1ilRFKXBUoW7pOAvueBFMz+iXlxs2HDBvLy8nj66afJy8urk8CxWq2UlJS4/qmWoFih2VluDq8S247nRXcevlB7XKluswampKQEq9UalWNLQqcuC9SUEbmsfGhMoyjeZ7VaXddJeU7qi57ngRTM/olZceN0OgHo168f7du3x2Qy8eyzz3Lo0CGfva0CMWvWLNLT013/+vTpE4kp15lma7mJxQaVOTUxQCe2Q1VJwx8+J4dZs2Y1+HEl4dGYhEpdmDVrlus6Kc/J2KWpn4f1IWbFjdEopnbzzTdzzjnnMG7cOM6ePcu//vUvPv30U+bNmxfyWDNmzKC4uNj1b8eOHZGadp3oWlPr5mSpleJKW5RnE2FKT4haMhhiK1NKJS0bMnJBccKR9Q1++Pz8fGbMmNHgx5VItMyYMcN1nZTnpKQxErPiRsVoNPLNN98wevRopk+fzubNm7n55pspLCwEQgsytlgspKWluf6lpqZGetphkZoQR3Z6AgB7T8SWy0x38laKbVY/SMyI6lT8omZwRcE1lZaWhsViafDjSiRaLBaL6zopz0lJYyTmxc0VV1xBx44diYuLw+l0sn79egYOHMj27ds5cuRI2C6qWKVHlriQ7DnRxF1Th1aIbecLozuPQKjiJm9VdOchkUgkkjpR5/YLkUJRFA/BYrfbsdvtTJ48mdWrV/PMM8/Qtm1bFi1ahNkcc9OvMz2yUli+5xR7mrrlRhU3nUZGdx6B6FQjvPLXga0K4hKiOx+JRCKRhEVMqIP58+dTVlbGiBEj6NSpk8sc6nA4MJvN3Hbbbdxyyy389a9/5de//jUAo0ePJiUlJZrT1pXuLstNExY3ZSehcDdgiM1MKZWW3SClLZQdF3E3sWxlksQk89bk8eqy/Uwb3VUGe0okfojk7yTqbqkJEybwzDPPsHDhQm688UaeeOIJ1q4VsQ4mkwmAc889l2XLljFt2jRXFlVTEjbQTNxSB38Q26x+kNQiunMJhMHgtiwd+jG6c5E0SmT9EYkkOJH8nURV3Cxfvpx9+/axceNGPvvsM1544QUKCwuZM2cOq1a54x3S09Pp3r07iqK4sqiaGt3bpGAwQGGZlcKyJlpTQhU3XS6K7jxCQbXWHFge3XlIGiWy/ohEEpxI/k6iqhTS0tLIysqioqICp9PJZZddxp133klSUhLvv/8+R44cAeCdd95h+fLlTSZ42BfJFjOdW4qU8B3HGr6+SoNwsEYodB4V3XmEQpeLxfbIeqgsiupUJLGDv3L33n+X9Uck3sRqq4RoziuSv5OoipvWrVuzY8cO3nrrLZdFZtiwYdx4441s2bKFXbt2AbBlyxZatWoVzak2CL3bpQGwo6AJipuzeXD2EBhMsR1vo5KZC616gOJwizJJs8efGV26oSTBiNVzJFbnVV+iKm46dOjAa6+9xmOPPcZ7770HiGypiy++mN69e/P2228D8NRTT9G3b99oTrVB6JMtxM32pmi5UV1S7QdDQlp05xIq3S4R273fRnceEl2o6x2q9nX+zOjSDSUJRrjniF4WlWDjNNVzN+rZUuPHj+f48eM8+OCDVFRUuLKhWrVqRUVFBQDx8fHRnGKD0Ve13BwrjvJMIsCBZWKrunsaA90ugTWvwN7F4HRCE433ai5o71DDMYNrX+dvAZgyIle6oCQBCfccqev56s3z3+ymqNLG89/s9jlOUz13o361NhgMTJ06lWeffZbf//73jB8/nkmTJvHSSy9x6623Rnt6DUqfGnFzoLCccqs9yrPREUVxu3a6jI7qVMKi04VgSYOyE3D0p2jPRlJPgt2hqne40+dv8rjT1b7Onwk/VuMpJP6J9e+sLhaVWH9P3kRyvlEXNwBms5nJkyezYcMGJk6cyJgxY1i3bh0DBgyI9tQalDapCbRLT0BRYOuRJmS9ObkDyk9BXBJ0GBrt2YSOOR66XyYe7/wiunOR1JtgwYuqcFm49ZiHgNG+zt+C01TjFpoysf6d1SXY1td7uv/ynrTPSOT+y3tGYpr1osmmgnvTq1cvbr/9du6++2569oy9L6IhGNQxE4BN+WejPBMd2f+92OaeLwRDY6LXOLHduUBYoCRNlmmju5KRGEe82URGYpzPO2Z/C05TjVtoyvj7zhqb9UOLr/cUy5l7TTYVXFKbQR0zANh0uCiq89CVAzXipjHF26j0uFxYnM4egqMboz0bSZiEs1BNGZFLssVMpc1BssUcdDHQjh3LC4jEN/6+s2hadOorrGLpPAzlvTTZVHBJbbTiJpSO5zGP3QqHajqBd22E4iY+GXr+Qjze9lF05yIJiK+LqXah8n7e1/7h3EnGulujMRCLVpJoWuGe/2Y3R4sqef6b3Q163Eh8D9H+fUhxE2P0bZdOvMlIYZmVQ6croj2d+nN4DdgrISUL2vSJ9mzqRr9JYrvtY3A0oUDvGKYuF1tfF9MhuZmYDGKrPv/wZ9sY+Ohi10Ki3T+cO0npihLUZ2EMFKA98NHFDHx0cYMLn1iyfjQUkQiUj/bvQ4qbGCMhzuSy3qzaXxjdyeiByyU1WvRsaox0uwSSWoqsqf1Loj2bZoF6sZ35+bagF1b1AjwkN7PWxXRD3lkcithOG90VkwEUoKjSBhDSxdffBb45LoK+CPUOPRxL2avL9lNUaaOo0uYxbjQtPQ1x7GgF/0YiUD7avw8pbmKQC7qJasyr9p2O8kx0YP9Sse06NrrzqA/meDjnBvF407zozqWZoAoRh0LQC6t6Ad6Qd7bWxVQNElZLKzw6oR8ZiXEkxhldzwe7+EbbvB7LzFuTR7nV7jcAW4uvzzFQgHZGYlytcaP5XTTEsYMJgkgJrKYYKC/FTQxyfteWAKw+cBqnsxHH3ZQXQsEW8bgx1bfxxaBfie3ur8T7kkSUKSNyeXRCv6AXVu/F1VePp2SL2WUBmDIil80zL6NFssXDKhBo0WjMF/hIo1pYQgnADudzVL+nzTMvqyVWGyrDyXvMWDgPIi2wmlKPNCluYpABORmkWsycKa9my5GiaE+n7qgp4FnnQGpWdOdSX9qeA+0Gg9MGm9+L9myaJMEurP4ChrWLqxpH89fPttH74a/8tkxQ/zYkN5MLnl7qM/5GpTFf4CNNKAu++r0B9f4ctd+F9nwIFDjuPY9QBZC3kPB37IZ0ldVHYIUyz6ZkpZTiJgaJMxm5qGdrABbvOBHl2dQDNT6lMWZJ+WLIbWK74b+iHYNEV4JdWH3F4XiLFKvd/b1U2pzM/Hwb6w6eqTWWulBtyDvL0aJKiittIblWJJ6EIvwitWB6t8XwVUXanwAKhUBWopmfb3Odi4GEsd7UR2gHev9qAPeZcmuT+R1IcROjXNa3LQCLtx+P8kzqiNMJ+2rETfdLozsXveh3HcSnwpn9slN4BAh2V+ovDqfcamfBFlFVGBRXPA2Ifb+oec5Xeq02yFi1/sRienJjJlLuHO24/qpI+xNAoRCoDo6jJlpA3TZ0m4S6vD7Q+1ctoJU2Z0guRj3mGkpphvoQ9caZEt+M7tmaeJOR/afK2X6smL7t0qM9pfA4vhXKT0J8CuSMiPZs9MGSAgNugvWvw/o3mo5FKoKod8yhBO4Ga+A3ZUQu6w6eYeHWYwzJFZW81YuySqXNyfgB7diQd5YhuZlsyDvLmfJqKm0OSqtsdHpoIf3bp7PgdyNdY6rjqBf9YI0GJYJQv9tINWb0N67337Vz9LV/OOco4BJN6vkV6uvmrclzCWyr3UmlzcHDn21zzTnQ67Tn56vL9lNutXvEjPmbv/d783ecaaO7uuamtwj11wDU++96NQpVkeImRklLiOPSPlks/LmA//10hL7jG5m42fet2HYe1fhaLgRi6FQhbnZ/BUX5kJET7RnFNKFcsHxdvP1dqBdsOQbAtzuERXPa6K48/Nk2tGH36j5Hiyp54pp+HvMA2HrUs29bU+2KHGn0Xox8oZ4bqpAIV1CE8t16v49gYqeu54tWiKtFMZSav2vH8z6+tzvpaFElGYlxfpu5al8bqlAP9J7CFX/eqHP0Fk3ef/e3X12RbqkYZtK5HQD4fPNRqmyOKM8mTPYsFlu18WRToU1vIdgUB/w0N9qziXlCcQVoq7J6x0sMfHQxvR/+it4Pf+26y4UaC81LK3j4s20ByyepC8fKh8bQv724QVC3/ojlRoOxhLZAIkS2yq3azNS7qakeaMsF1CU2J9zjZCTGcY7mHFQ/PxXvYpPa+k3qZz6qR+ugbjjAFYOmjUVTCfX7CiVYOxDq7w8ImDCgd+C+FDcxzKjurWmXnsDZChufbjoa7emETnkhHFkvHve4PLpziQTD7xLbDf+F6iZQRTqCqBff57/ZzcBHFzN9/qaAF0fvC7UaB1Bpc3hYZ0BYYBTAX7WEOKPBJarmrcnjdHk1T1zTz+WSCjRnmR0VHG2BRIhM4LB6Pozr3472GYn0bZfuIahCIZQFubTKXTDQW5DrJdq06e2ny6tdf1c/PxXvYpPa+k3en7k6rr+u9Raz0WOr/Uy0QdGB3ptW/Kk3Ik8u3EnXGQuZPn9TyJ9RQ2diSXETw5iMBv5vZGcA/v3DARyNpebN3m8BBdr2h7R20Z6N/vS4AjI7QeVZ2CLTwlX8XeC01WZ93XlrLSXrDp7heHEl6w6eYUhuJgaESEmMM7nuelUyEgN71dukJXjE1DSVFNdYwXsh1Stw2FdD0hcnD2LlQ2M4XV5da3EPRihZeGpgsC/RFCnR5qtIoUpqQpzrnPcuYaC1MnnjLcz9WSG9g6IDvTdtrSgQwdNVNocrWN9fKYVo1wmS4ibGuWlYR9IT4zhYWM7/fsqP9nRCY9eXYtvjiujOI1IYTTDibvF49RxwNjKXYYTwtwhoL+TqHbiauu3dUXvh1mM4FFi49Rg/7DmFAtidCn8Z15tRPVp7BA8XVYqqwyZDbVeTr0Uh2gXYmhqRcisEEhN1+R59vUa78E4b3dUVA/PDnlOu46vWxkikR2utOIBHzZyZn2+jqNJGi+R4VxFDba0gVWg8/83uOnfdVj+T8QPahfR5qvvff3lPVj40hqsHtMNkgIQ4oyuWzXucQHWCGgKD0iRaT4fHkSNHyMnJIT8/nw4dOkR7OkF548cDPLFwJ61SLCz540Wka+5eY47qcni2q2iWeeePkN0/2jOKDNYymN0Xqopg0pvQ79p6Dbdz50769OlDcXExaWlp+syxgQkn8HDgo4spqqkto17gAabP38TCrccY178dP+w55XG3eLy40nW3qWIA1++hqNKGySBaLEiXUv1Rr5MNfU4GOo/qG9yqcsHTSzlaVEn7jERWPjTG43y8//KeHhlJgGu/+rwHf3PXzgVEwLD3eazdR3XZqvMLd256Euh9hhv8HSolJSWkp6cHPS+l5aYRcMt5nejSKpnCMiuPfbEj2tMJzL4lQthk5Iqqvk0VS4o79ubHv0Pzu0eoRV3uzIorbUyfv8nVAXpY5xbsnzWOFycP4v7Le9b0gTJxptyK0Vg7cjg9Mc5jAZLCpvET6DzyZ9UJNy7G25qjdd+ox1fPv7pYbXzNU2sR0lpqzpRbMSBcYuq8Hp0gsvy01iVvy8ioHq0jbo0M9rn6+q7U9+mr11tDIsVNIyDebOTZSf0xGODjjUf4aMORaE/JP9s/FdveVzfeLuChMvxOUcfnxDbY+UW0ZxNTqBdFfwHEo3qICtwKwgWlxuQ8uXAnnR9aSPe/LOLJhTsot9qptDmotDmxORS8zyj1Aq+ay6WwiS6RLoDoXZFaPU44cTHe1obp8zcx8/NtDMnNrOUC8tXfytd43sXofDUTVecOeFQ3rrQ5URBxRFqxoK3IDdT6e6jiwdd3UpdMqVCJFRewFDeNhHM7tWD6mO4A/PnTn1lzIAY7hlcVw+5F4vE5k6I7l4YgqQWMmCYef/+kjL3R4J3C651G+sOeU4BwK43r387VqVvNirI5FCFovILove1j6gUeiOiiKgmNSAduq4v/D3tOudKl/Vk2Qp2jNs6rLu/BV52ZQM1EO7ZIAtzVjf1Zh/xV5PYOKtb+rqbP3+TKYlL/ri21EEorCu94pEABzL5eB/XvIaYHUtw0In4/tjuX982i2u7kN2/9xOb8omhPyZMdC8BeBa16QvbAaM+mYTjvt5CQAad2yYaaGrxTeLU1ONTCYgBmo4Ef9pyiuCblWyXOFNzqZzK4q6nKbKjYoK537eFYfOatyaO45vzRFsELdUH1nuO4/iI4dlz/dn6tLoHmGihrzFdvq+3HRBFJk0G4wwJZh+LNJpfLSouauv78N7tdKd3Pf7ObBVvcQk1buFJrMQrWisK7qKEawKz9bWlFlK/XxQKyQnEjwmg08M+bBnHrf9ax9uAZbp67lnemDmdgTka0pybY+LbY9r+h6bukVBIzYNQDsPgvsPRx6HsNWFKjPauo46viqZrmrS0oZncqHhlQAIlxJixmI+VWey3LjZa+7dJdxxiSm8nx4sqw6p9I9KeuLQ7CqXb86rL9KLiDycMVUt5zfHHyIF6cPAgQ1j81SNffPLyr/nqPpy0/oG2TEE7bhnlr8jwqb2tT39U0bgMiZk1BCCUt4/q3Y1jnFh6feTitGIJVDtZau9TPTu8Kw/VFWm4aGQlxJv5z21CGdsqktMrOzW+sZdPh0Gs+RIxjm+DIOjDGwaCboz2bhmXYHdCiC5SdgO9nRXs2MYX2zlUtQGYxG12BwglxRg8rjQGotDmE4DEIk736fJzRQEZinCvuZvuxYtf4P+w5FXb9E0nDEeyuPhSLj/pdqxV7H7+mn1+LR11jf/SKF9FaTVS3DuBRswf8u1JVAaeidQupc0xPjHMJm0cn9HMFRT9xTT9enDyozqn62v38iVKttcvf64I1y4x0fJYUN42QZIuZ/94+jGGdW1BqtXPL3HVsibaLas2/xLbvNZCaFdWpNDjmePjFc+Lx2n/Bsc1RnU4kCXRB8vWcdlFT/fcgzPEtkuNdgcIAiXFGjzIHNofCqB6tcdZYb1QrztUD2mFABNo/uXAnR4sqsdodPgNNJbFBMNEQysIbTiCtNhg32EKqtvkY+KhoGRNsbFVEjOrR2u+Y2rowvtw62jn6q+ejxuJk1GQEeteLUecRKEMwlGDiQJ+Nv9YLL04e5Mpq9HU8X0X9vMeLtBtLiptGSrLFzJu3DWVYJyFwbp67lm1eDQEbjMK98POH4rFa3K650f0S6Hut6Dn12TSwW6M9o4gQKBVX9f0/umA7nR5ayPiXVngsauoFuKjSxsOfbaNlcryHOb3S5mRUj9YkxrkvS6r5W8uLkwfRLiORSpvT1XPNYjax8qExbMg7G1N+f4l/l1Qod/dafLVFUEWJr321wbiB+iNpK2iHkmKuigv1XPNVTC9QSwR/70eLtsifKmK89/MWhIHSz7UtFnwFQPv7zWj7h4UiRrzjfAK9Z+/eZHojxU0jJtli5j+3D2VIbiYlVXZ+9UaUBM53j4DihJ5XQvvBDX/8WOHK5yCpFZzcIT6TJoJ39oSvi9bz3+x2iRDVwrL1aLGHD14tlAYiEHTr0eJawmXh1mP8ZVwfnrimHxmJccTXuLDUSqpqGXl1Hlf7+Xus+P0l/hdPbRaPr/29ex75Wsz9iZIpI3J5dEI/17mgPS+8jxuoFYKv2jQq3qnd/loP+LJKaQvdqYLL12t9vW8twX6bvjKuwmmboe1lFUrPLe9KxuC/WaY69g97TkXE2iorFDeCCsXBKK2ycfPcdWzOLyItwcybtw9lSG6Lhjn4zi/ggylgMMFdP0JW34Y5bqyy+2uYf6N4fMPb0GdCSC+L5QrFvqqjet+Fa4WLigFcMQGpCXG1nveHWrVYPW5GYhzJFrPulU4lgalPhWKttQYIeM54V6lWrYAOJXBl4Hlr8nhy4Q6qbE6uHtCulovEH6FUx1bHUt+HdzVg7b7egbtQuwKyN+rzqvAItfLwvDV5PP/Nbqx2BxazCatd1IDyfi/er6lrVedArw32HoPt4+uz9Xd90SIrFDcjUhPieGfqMM7VWHC++rkg8gcu3Aef3yMej/yDFDYAPa8Q6eEAn94FRzdEdz46oL1j83UXrt5xxfmoIKxevIFaBfi0qHVuwF21WK3carU7pKupkeGd/eTL8jCqR2tMBndBRxVvq4uKL4tGi2SLqwBeqPhrJuld70Y9hja+RZ2Pdl/v9zd9/iaOFVWSGGf0mL82fTpQqYTiGuHlL027qKZsQlGljaqa8gnFlbawqgiHSqDXhmIlDeZ68/5s9YzDkZabJmC5UamsdnD3uxv4frcokHbPxV35wyU9iDNFQMMW7oN3roHifOgwFG79EuIS9D9OY8Rhh/dugP1LIDETbvkcsgcEfEksW260qHeOgGtx0N5lD8nNZMEWsTiMH+C+q22ZHM/WAC5T9eKmjqUVRdJyEx30stz4y7oJ1zLnywoQTg+nYIx/aQVbjxbTv306C343MuC+vqw8Kl1nLHSdw/tnjQv6d5VgFiut1QZEnNmoHq1dQsv7NfWx2ESLUOYsLTfNkMR4E6/fci63X9AJgDnf72fSq6vYc6JUv4MoCvz8Ebw+Rgiblt3gpveksNFiMsMNb0H7c6HyLLx5ZZNpz6At6jXz8208umC7S4ScLK3iixphYzLAsM4tXHdnP2uETWKckcQ4UZysf/t0j4Bj9Y5drVqsNjKUVYgbF6EEu/qLWQk1oNjXcaB2LI/3eL4K0AGcLq/22AbixcmDeHRCPzbkna01T19p0urf1Sw/X+ewt8XKO2Batdq0SLaw8/FfsHnmZa55+LKOxFpRvYZGipsmhtlkZObVfXn5l4NITTCz5UgxV/7zR574cgdnQ/jRBuTkLph3HXw8FazF0GEY3P41pLTRZ/JNCUsq3PwJdLoQqstEXNIHN0PB1mjPLCiBslgGPrqYM+XVGBCWFW2RPZtDcdXmUAMY1YXEu6bjzsev4ODT41jwu5EetTGe/2Y35VY7wzq3qFW5tblfrBszgYSJ6p5Ss2b8BRrXFe8AZdXSsWDLMY80cbV+TqjB6P7OR39p0tosP3/nsFasqcUCtUUAA2VNgaf497d/ferL6FGbJtTU8/oixU0T5ar+7Vh87ygu7ZOF3anwxoqDjHxmKY8s2M6u4yWE5Y08cxA+uwdePU+4WkzxcNFDcPsiSGkd/PXNlYR0mPIJXPAHMBhh5wJ47UJ46VxYMB1Wz4Htn8HBHzEW7mnQqfkrpqVN6fbOVnH7+4VZPCMxjvYZtS12iXEmDxeVQ/Fsmm6vMfV430EHyn4BmQnVmAkUu6HNyAlEqAufd0yNd8aQ1qKiTRMPt4t1OIUHtYIj1F5NKmr7BVXgrDt4xqflKdTPJ9B+wdLz/dWv8YW/sfxlw81bE7z1RTjImJsmFHPjj+V7TvHs17vYfqzE9bfclkmc16Ul53RIp2dWKt3apJCRFO9+kdMJ+Wth/Rui07dS0xSy11Vw6WPQUi4wYXFiB/zwnHBPOWtnDR0pcZIzu6zBYm608QtArccq2vRZ0TZBoaqmi3H7jETOlFe7xE6c0YDdqXB1TayNGj8A1DTFFMGPBuDg0+NqxSB4x/M0ljiBpkp9Ym7CIZT4HF/76XUMwOdjPTKLfGUaBsqG0o6l/S2oVpyMxDhXywX1d+Tv+P4ylQL9zvy9pi6Zi4GO7yu2KJTsKwg95kaKm2YgbgAUp5Mf9p5i/tpD/Lj7JHaHnTjsxGMnyWAljXJyLWUMTD5Df9Mh+lZtJK36pOv1Je0v5MywB6D9ucSbjZhNBuKMRoxGAyajAZPBgMEgWkoZDQYMgMG1FY9jFavVyqxZs5gxYwYWiyWyB6sqhoM/iHYVp/dD6XGoPMPhgkJynzrUYOIm2MVd2//Gu5Q8gNXuxGI2eqR3q5VUvUVSnNGAzam4UsMzEs0kW+JomRzP9mPFXNEvi9Z7v2yYzz/GaNBzL0yCiZtozj1SwbKBFthg7zdYwLP6O/InEHztq46lTV+32p1U2hwkxpm4tE+W38DmuqRxa19z/aC23Pr4G+yM60a13ekKYA7WFyvQ8bX1fbzHCfU7leImAIcOHaJz586sW7eO7OzsaE+nQUj67HbMR9eG9ZoyxcJix7m85xjDLqVTZCaGuAO5sFsLnp7QM+i+kaC0tJQ+ffqwY8cOUlOj0/Ryz549jB07lvz8/JjLlvpg/WFe/G6v6//FVXaXmT8hzuhKR02IM2KzO7m8b1uGdMrkqYU7XQ3+fF1kstMT+Pa+iygpKXHdbMTae480sfzejxw5Qt++ff3OLZpzv/QfyykornKdQ3rxwfrDvPHjQX59YWduHNrR47lg7zfQawH+9L8tfLP9OJf3bcuz19fOntS+p19f2NljLO3YgOux+hszGWDLI5fr8j6173fYzM8xp4mYyux04YKuz+eux/emfg9nzpwhM9N/deNmKW6+/PJLrr766mhPQyKRSCQSSR1Yt24dQ4cO9ft8sxQ3p0+fplWrVqxZsybm7pYakrKyMoYNG8a6detISUmJ9nSiRix8Drt27eLaa69l8eLFzcZVqhILn3+0iOX3vnv3biZOnMjPP/9MRkZGredjweLZkMj3GxuUlJTQt2/foJYbcwPOKWaIixNxA717927W4sZqtTJz5kz69+8fc/7+hiSWPofevXs3O3ETS59/Q9MY3nvHjh39xtzMnDmTLl26xOzc9US+39igpEQkxphMpoD7NUvLTagBSRJJQ6FWKG5OQe6S2KaxVM2WNC9khWKJRCKRSCTNEiluJBKJRCKRNCmkuJFIJBKJRNKkkOJGIpFIJBJJk0KKG4lEIpFIJE0KKW4kEolEIpE0KZplnRuJRFJHTmyHn94UvbHMCdBrHAy5DeKTQh6iqKKazzYdZfmeU3RskcRNwzrSO1umGkskEv2Q4kYikQTHYYcfnhWdzRWn++95K2Ddv+GWzyCzU9BhTpdZmTBnJUfOujuPv7U6j2mju3L/ZT0xGWO3wapEImk8SLeURCIJjL0aProdlj8jhE3PcTDpTfjFs5DWHs4ehDevhKL8gMPYHE5++94mjpwV3YgfvKIXV/RtC4hO5He8/RPlVntDvCOJRNLEkZYbiUTiH6dDCJtdX4IpHsa/DANudD/fezy8PQEKd8PHv4bbFoLJ92XljR8PsvrAaZLjTfz39qF0zxL9aj7bdJQHP97Kkl0nueG11bx28xA6ZIbu5pJIJBJvpLiRSCS+URT46sEaYWOBye9Bt0s890nLhl9+AP+6EPLXwMrZMOqBWkNV2RzMXXEAgJlX93UJG4BrBrWnY8skfvPWT2w/VsIl/1jO1JGdOb9rK8xGA2crbJytqCYtIY6hnTJpk5YQ0bctkUgaP1LcSCQS32z4L6x/HTDAda/XFjYqLTrDuOfh0zvhh7/DgMmQ7tkf66MNRygsq6Z9RiITB7evNcTgjpl8ds8F/PHDLaw7dIY53+9nzvf7fR7ul8M78sjVfYk3S6+6RCLxjbw6SCSS2hzdCF/9STwe+zfoMyHw/v1vhI7ng70SvnvU4ymHU+H1H4XV5tcXdibO5Puyk9MiiQ/uHMHLvxzEuHOy6dQyic6tkhnUMYOxvdrQpyaj6r21h7l57loqqx31e48SiaTJIi03EonEk+oK+OQ34KiGXlfByHuDv8ZggCuegn9fDD9/CCP/AFl9AVh74DR5pytISzBz49CcIMMYuKp/O67q387n89/vOsn0+ZtYe/AMLyzZw4xf9A733UkkkmaAtNxIJBJPlj4Op/dBajZMeFkIl1BoN8ht4Vkx2/XnL38uAOAX/bJJiq/f/dTFvdow+8aBAMz98SC7jpfUazyJRNI0keJGIpG4KdgKa14Vj8e/BImZ4b3+wvvEdtvHcHo/doeTr7cdB+CqAdm6TPGSPllc3jcLu1PhsS926DKmRCJpWkhxI5FIBGp2FAr0vRa6Xxr+GNkDoPtloh7O2tdYtf80Z8qraZkcz3ldWuo21b9d3ReT0cCq/afZd7JUt3ElEknTQIobiUQi2L0IDq8CcyJc9njdxxkxTWy3zOfbTSLj6Yp+bTH7CSSuC+0zEhnTqw0A768LXDxQIpE0P6S4kUgkwmqz/BnxeMS0WqncYdF5NLTsBtYSknd/BIh4G725qSY4+eONR7DaZeaURCJxI8WNRCKBvYuhYAvEJcN5v63fWEYjDP0NABPsX5MYZ2Ro5zBjd0Lgoh6taZuWwNkKG9/uOKH7+BKJpPEixY1EIoGVL4rt0KmQrENszIAbcRji6G3M56YOZ7GYTfUf0wuzyciEQSJl/DspbiQSiQYpbiSS5s6J7aK7t8HkjpepL4mZrLOcB8D1cSv0GdMHF/cUcTc/7C3E6VQidhyJRNK4aBTiZvPmzSiKvHBJJBFh3eti2/sqSPNdPC9cyqx25paNAKDnya9EZ/EIMLhjJikWM2fKq9l2rDgix5BIJI2PmBc3EyZMYMaMGZw6dQqn0xnt6UgkTQtrKWz9UDyuiZPRgzX7T/O9/RxOk4Gp6gwcXK7b2FrizUbO7yrcaMt3n4rIMSQSSeMjpsXNb3/7W06cOMFnn31GmzZtMBrrNl2r1UpJSYnHP4kkVrBarZSVlUXn4Du/AFs5tOgKnUbqNuyaA6dxYGJPyzHiD9s/1W1sby7q2RqA5XukuIkEJSUlWK3WaE9DIgmLmBU3lZWVFBYW8tprr2GxWHjnnXd48MEHefbZZ/nuu+/CGmvWrFmkp6e7/uXkBO5vI5E0JLNmzWLYsGHROfiW+WI7YHLobRZCYM3B0wA4ete0Y9j1ZcRcUxf1EOJm4+GzlFTZInKM5kxOTg6zZs2K9jQkkrCIWXGTmJiIoiicOnWKOXPm8OCDD5KcnMzatWv55z//ybx580Iea8aMGRQXF7v+5efLol+S2GHGjBmsW7eu4Q9clA8HfxSP+9+g27DFlTa2HxPW0e7nXgrJbaCqGA4s0+0YWjpkJtEhMxGnAlvzZdyN3uTn5zNjxoxoT0PSAMxbk8cFTy9l3pq8aE+l3sSsuFEUhTZt2jB//nwKCwv5/PPP+dvf/sYrr7zCqFGjWLZsGVVVVSEFGlssFtLS0jz+SSSxgsViISUlpeEPvP0TQIHckZCZq9uwPx06g6JA51bJZGUkQ5/x4oldX+p2DG8GdxR1dDYePhuxYzRX0tLSsFgs0Z6GpAF4ddl+jhZV8uqy/dGeSr2JWXFjMBj429/+xuLFi3niiSc4duwYTqeTrKwsBg8ezLZt27Db7Rh0NKVLJM0KNQ7mnOt0HXbNAeGSGtGlhfhDz1+I7Z5vIEJJAYM6ZgCwSYobSYwTy9aRaaO70j4jkWmju0Z7KvUm5sSNaomx2Wy0bt2ar7/+mjZt2vD+++9TUFAAwKFDh0hKSpLp4RJJXTlzEI5tAoMReo/Xdeg1B84AMEJtlNnpQlH5uOw4HN+i67FUVMvNpvwieV2QxDSxbB2ZMiKXlQ+NYcoI/Sy50cIc7QkAzJ8/n7KyMkaMGEGnTp1ITU0lLi4Oh8NB3759+eGHH7juuuuYMmUKRqOR7du3s2jRIlJTU6M9dYmkcbLjM7HtdCEkt9Jt2DKrne019WaGda6x3Jgt0PVi4Zba/TW0G6Tb8VR6Z6dhMRspqrBxsLCcLq2j4OaTSEJg2uiuvLpsf5OwjsQyURc3EyZMIC8vj06dOjF79myuvvpqrr32WoYPH47JZMJms9G1a1dWrlzJtm3bqKyspEuXLnTs2DHaU5dIGi87PhfbvtfoOuymw2dxKqJrd3Z6ovuJnr8Q4mbP13Cx/sGp8WYj57RP56e8s2w6XCTFjSRmmTIit0lYRvRg3po8l9DT+zOJqltq+fLl7Nu3j40bN/LZZ5/xwgsvUFhYyJw5c1i1ahUAcXFxACQnJzN8+HBGjx4thY1EUh+K8oVLCgP0ukrXoX86JGJezu3k1Siz26ViW7AFygt1PaaKGncjg4olksZBJF10URU3aWlpZGVlUVFRgdPp5LLLLuPOO+8kKSmJ999/nyNHjgDwzjvvsHx5ZCqcSiTNjl0LxbbjCEhpo+vQG/JqxE2ul7hJzYKsfoASsZTwATkZAGw7Jot0SiSNgUgGMEdV3LRu3ZodO3bw1ltvuaoPDxs2jBtvvJEtW7awa9cuALZs2UKrVvrFBUgkzRo1JVtnq43d4XRlK53bqUXtHbqMFtsD3+t6XJU+2aLEw66CEuwO2apFIol1IhnAHFVx06FDB1577TUee+wx3nvvPUBkS1188cX07t2bt99+G4CnnnqKvn37RnOqEknToOIM5K0Uj3vrK252HS+lvNpBqsVMjywfwf5da1ox7P8eIpDRlNsymaR4E1a7k0Ony3UfX9K0aOiU7FhOAW+KRD0VfPz48Tz22GM8+OCDvPHGG666Na1atXJZa+Lj46M5xZimotrOK9/v4463f4rJ1EJJjLHnG1CckHUOZHbSdWjVJTUoNxOT0Uf9qdzzwWSBkqNQuEfXYwOYjAZ6tRWiart0TUmC0NAp2bGcAt4Uibq4MRgMTJ06lWeffZbf//73jB8/nkmTJvHSSy9x6623Rnt6Mcvnm4/yy9fXcOt/1lFYZuXKc7L5ce8pXlyyN9pTk8QyuxeJrVpYT0fUQN4hHTN97xCXCB2Hi8cHf9D9+AB92gnX1I4CKW4kgWnognWhHC9c6460Bvkn6qngAGazmcmTJzNo0CBWr15NZWUlTz75JD179oz21GKOaruThz/fxsFT5dxyfi5tUhNcz/324m68unw/L3y7hz9c2iOKs5TEJLYq2LdEPO51pe7Du8SNdzCxlk6jhLA5tAKG/Ub3OfTJTgdgh7TcSILQ0CnZoRxPa90JZW7h7t+ciAlxo9KrVy969eoV7WnEDIqi8M8le9lZUEJFtYPKageVNgeX9s7i2kHta7WeMJuM3D26G08t2smNw3I864xIJId+BFs5pLaD7IG6Dn2q1Er+mUoMBuifk+5/x04ja+ayQsTd6Nw+xWW5OVaCoiiyPYukURFugb9Q9g9WSyaStWaiSUyJG4mbjzYc4b21h+mdncqEAe1JijeREGfC6CuWQYNaer5tWkLA/STNEJdL6grdRcXm/CIAurdJIS0hzv+O7YdAXBJUFMKpXdCmt67z6JmVitEAp8urOVVqpY38HUgaEeFak/SwBjVV60/UY24kntgcTqbP38Rnm47ymws7M2Fge1qlWkiymIMKG4D1h84ytFOmvGOVeKIoovUBQM/IuaQG5QRwSQGY4yFHjbv5Ufd5JMab6NwqGZBxNzHN+rkwu5/YSiLKkNxMTAb/7uKm1CxTixQ3MURxhY3J/15D19YpTB/bnZYplrDHWL7nJPfKeBuJNwVboPSYaGDZ6ULdh1fr2wzOzQi+s+qayluh+zwAetXUu9lzojQi40vqhkfw64rZUJwvtpKIsiHvLA7Fnc3oTVNqlqlFipsYoKTKxt8+38Yv31jDpCEdOK9ryzqNc+BUGW1SE0gN5BaQNE/21Fhtul4Mcfq6auwOJ1uPiGaZg/xlSmnJvUBs81ZFpN5Nz5oaO7uPl+k+tqTueKRCj7wX0nPEVhJRmqplJhhS3ESRk6VV/OH9Tdz8xlrapFp4eFyfejX8+3TTUWaO76PjDCVNht1fiW2PK3Qfes+JMipqivd1C+X8bT9Y1LspPwWn9+k+H7WA4O4T0i0VS3gsskOnwr3bxFYSMsFSv309H6uWmUinsUtxEwUUReGhj7dyz7sbGZiTyZ+v7M2wzi1Diqnxx94TpbRIjpcZUpLalB6Hgs3icY/LdR9eDSbun5Me2jlstkCHoeLxIf1dU2ohv70nynA49bcMSepGrC6y3sRy7ZhghQAbU6HASM9VipsGxu5w8pu3NxBvNvLA5b3o0y5Nl+Dfr7Yd529XS6uNxAd7F4ttu8G6N8oE2FIjbgbWNK4MiU4a15TO5LRIIiHOiNXu5PCZCt3HlzRtYlkgBHMx1dcF1ZDCbtrormQkxlFutUfkeFLcNBBlVjvPfbObia+sol+7NK7q3063sc+UV+NUFGm1kfhmzzdiGwGXFLgtNwM6ZIT+otzzxTZvpe5xNyajge5t1LgbGVQsCY9YjlEJZv2qr3WsIYXdlBG5JFvMFFXaInI8WecmgjicCq98v481B09jtTs5N7cFD1zek4Q4k67HWbzjOJf1ydJ1TEkTwW6FA8vE4x6X6T58mdXOnpNCQIRluekwFIxm0Weq6DBk6uuq6JGVys9Hi9lzopQr+rXVdWxJ0ybUWjNq8bshuZlsyDvbJIrghVtEMJaPJ8VNhPhs01H+u+oQ/Tukc9v5nUlPjEwGU7Xdyb6TZfz9+gERGV8ShNLjsHoOmOKEyyf3AmjVQ8SVxAJ5q6C6DFKyoK3+58jPR4pRFGiXnhBewbz4ZGg3CI6sF3PUWdyocTe7ZTq4JFzWzxUp6iPvDRjwrFo5jhdX4lBo1EXwtFWKVz40psGOG8kWGNItpTMOp8LfPt/Gu2vzuGNUF67q3y5iwgZg1f5CLujaShbta0gUBTa8BfOug8/uhvT2kNJWZP+sfQ3e/AVs/yzasxTs+05su10KRv1/7luOFAEwIByrjYrWNaUzPdpKt5SkjoRYg0d1X43r367B3FiRionx546K5eDqYEjLjU4oisLrPx7ky63HGNG5Jfdf1jOg4CgormTO9/spt9qpsjmwmE3MvnFAWCLlWFEly/ec4uNp5+vxFiShYC2Dj/8PklvDiLt9B+hWnIEfnoOTO2D0DN1bHYTF3m/FtvslERm+TsHEKrkXwMp/RiSoWK11c6iwHKtd/L4kjQu/PY9CtKzUmZH3uscPQEM33oTItUrw5x5qzK0ZpOVGB+atyeO6V1ex+3gJ913Sg0v6ZPkUKYqi8NSindzz7kZmLdpFvMlITmYS57RPJ95s5LEvdoR8zCqbg9d/PMCbtw3VPYZH4gNFgfVvwNvjoddVMPwu/5lHSS3g8ieh4jQs/GPDzlPL2Two3A0GE3S5OCKHUMVN/3CCiVVyhgMGOLNfuPd0JCvNQmqCGbtT4WBhua5jSwR63NUHGsNvcGukqxs3QA2eUD47X/uEG+wc6nfkLxA5loOrgyHFTT15eelevtxawN2ju3Hj0I4kWXwbw/6+eDfT3t3I2fJqumel0Ds7jdapFhLjTRgMBnJbJnGsuJKSSltIx/1gfT4TB7WXjQEbgrKT8M41ooXBZU+KWJFgGIww+FY4sT3i0/PLvhqrTc4wSMzQffiTpVUcK67CYIBzOgToBO6PxAxo20881tk1ZTAYNJWKpWsqEqjiY+bn2+oscAJl5/hdWJtAdeNQspJ87aOKECAk0RKqu8mfCGostYl8IcVNPXh56V5W7T/N9DHdSPMTV6MoCg9/to19J8vomZVKl9YpPk3kRoOBrq1T+Mtn24Ied/+pMsqtdn59YZd6vwdJENb/B+bfBOf+Hwy7AyxhVJA2GMBoAqczcvMLxL4lYtttbESG35ovWi50a51Cih9RHxS1z1UEivl1rxE3ssdUZJg2uismA65g2rqO4UvA+HVJQZOobhyKRSTQPqGmbPsbw/v1kUgBj3a8jhQ3dcDmcPKH9zezIe8sv724G2aT74+xsMzKb9/bhN2pcE779KDuo9SEOKrtDqpsDr/7nCmvZt6aPP5+g8yOiijWUvhsGhxcBlc8Ay3qKCSTW0Fpga5TCwmHDQ7+IB53i0y8zdaaYOI6uaRU1CaaERA3PbOEEN1zQvaYigRTRuTy6IR+9XJb+LQMrJ/L2K/HMrr0i3ovttFeYP0RikUk0D6huotCdTdFwv0U7WKIugcU5+fnM3PmTP7zn//oPXRM4HAq3P7megbnZjKyW0ef+yiKwswF2zlZYqVbmxSSQ7yrLbfaSYgz+RVBJZU2Xl66lztHdalTx3BJCFScgSWPwcnt0G+SO6OnrlQVQ0KaPnMLh/x1IgU8qVVEUsABttQ0yxyQUweXlEru+YABCveIuJtU/WrSqBlT0nITOSISVLtiNtmc4rdxX1CaewvPPfEnpvIZc7mG7EvuCXo8rdUnUgGxAS1LDUBdPnfvOWtfH+54obz/hq6Z443ulpszZ87w1ltv6T1sTOB0Kvzm7Z8Y3DGDkd1a+dznbHk1v31vE9V2J+d0SA9Z2ADkn63gT5f38vlctd3By9/v47YLOjN+YPs6zV8SAHs1fPEH+OBX0LY/XPn3+gsbAFsVWFLrP0647K9xSXW9OCIp4IqiuCw3YVUm9iYxE9qeIx7rbL1RG2gePlNBRbVd17ElEaQmpiZ73Aw25J1lsu1jWthPMNn2sV8rgNZCoxU0WouEPytOXaw7DWmV0Mv6VNc5z1uTx8BHFzPw0cWuOYQyVrTjdcK23CxYsCDg8wcOHKjzZGIZRVG4+92NdG+TwsjurX3u89SinRw6XU6PNqlhiRoQ2U8Op0L7zNotFJyKwr+WH+Cq/tlMGtKhTvOXBGDnFyIluffV+vrxK4sgsR5Wjfqwf6nYdo1MvM2Rs5WcrbARZzLQK7ue4q3ThXB8q3CjnTNJnwkCrVIstEyO53R5NftOltXPfSZpOIZOdf0OpznymP/ddUzlM+ZzjV8rgLegeXXZfv7RZQPDV09nyth7YegYLnh6aW0rzvq5jP16FjttV/PqsqtDXojrYpXwtnb4sn5Mn7+JhVuPMa5/O16cPKjWe9POL9wKyXW1pLy6bD9FNYku6hyG5GZyvLiSlsnxXPD00pis0hy2uLnmmmswGAwoAfrBNLWCcuVWO9PmbaBHVipje9duc+BwKsz4ZCtVNif922dgCrO7t6Io7DtZRm7LJJ/PzVuTR592aTKAWG/KTsHCe8FWCRf/RcTH6En+OrdVoiEpPw3HNovHXSOUAl5jtemdnVb/GjJdLoI1c9xtInSkR1Yqqw+cZs8JKW4aI1NG5MKIZ4FneSDAftqF2+VimT3dnTI+dKrvxb3GBXZP3AIWWn/BvDV5TDF9F7SOTkA3jp86PN7Wjoc/24YCPP/NbtdYC7cew6GIrSputPP25XI7XlzJTcbvGPv1F2Ca4Trm2g+fo+OO1zjc506G3/BAUNeTP1fTtNFdef6b3a7HABvyzuJQYPuxYhwKAas0R8uFF7a9Ojs7m08++QSn0+nz38aNGyMxz6jx2aaj3PTvNYzp1YbL+taOByiqqOae9zaSGGemd3Za2MIG4GBhOa1S4vnTFZ4uKUVR+N+GI6QmxPHnK3vX+T1IfLDiBZh/I/SZAJc8or+wUZyweyFceL++44bCwWWAAm366BrDosVd30YHy1TuBWCMg6I8OKOv5bdHTVDxroISXceVRIewUpa9Usb97VOWkM0c23iKKm1iEa+po1O25Lm6uYP81OHRusheXbYf1TxgtbsTSMb1b4fJILa+3psvl9u4/u34bdwXZHPK45gdd7xGNqfouOO1kKbtz9U0ZUQum2dexuaZojedaqnRVmfWVmn2/o5CdYfpHfwdtrgZMmQIGzZs8Pt8MKtOY0FRFP753V7+u+oQ91zclT7tal/En/l6F3/6eCvdWqfQNr1u9WZOl1mxORQendCv1vHfXXsYi9nIrGujcPffVCkvFG0Tzh6CK5+H1r5jnOrNwR+g4wiIi0Kn9v3fi23XyPWIUYOJdbGGWFJELR5wz10nemWLYG7ZY6rxUKfCfuvnwux+YqviJ2XcY/yhU7mcV3jXockorBFFr9rHc7SokoLv5tQeOxB+6vBoRcqQ3EzX37WWzxcnD2L/rHEM69zC52egFUjqeC9OHkT2uBm1jnm4z50U0JrDfe4MadqhZEypn/+GvLOuY2u33gIs1HG1Y+sVxxS2uHnggQc4/3z/gZbdunXj++/1vUBFCqdT4aGPt/Lrt9bz/De7yT9TQXGljUcWbGf8yyspKK7kT5f3pEVy7cykmQu2k3e6nH7twgsa1lJlc5B/toJnJ/X3nJeiMHfFQVqlWHhyohQ2urHlfXh3EgyYLC54pgj1/LJVwbZPYPSfIzN+IBTF7d6JUFVih1Nh29GaTCm9XD2q+0yNFdIJtYHmzgIpbhoLBd/N4YPK3whR4YW/hbJsyXMua0swfC2+GYlxZCTGcf/lPZnnuIQLrC+S33WyOJZ5QXgVkYdOZXrbd+j6SVumz9/kc5cNeWcBMBmgY4skus5Y6LGvvwKJfoN0fQi54Tc8wJIrlnDfgSEhWUNCCQCuS32eUAsP6p2OHra4ufDCC7niiiv8Pp+cnMxFF11Ur0k1FL96Yy0ZSfFcO6gDRgM8smA7v3n7J1okxzPjF724dnCHWjVsnE6F+/+3hbIqO/3apRPnp8ZNMOwOJ7uOl9AzK5V4s+cY89bk0alVMn+7uk+d35tEQ8UZ+OBm2PUlXPo4tO4ZuWMpCvz4HAy+JbyCf3pxep+4EJvi9cn28sH+U2VUVDtIijfRrY1O77FLjZXp4I+iRo9O9MhKxWAQNadOlVp1G1cSOaaZF9DBUChEhRcfrs+vESb7PF0f9vEcUVrxqn187QG9rDrzMv7NvoQpzMv4t2uXZIuZ+y/v6WF5UK0TKWMf8LCKhOI+0cbO+HyPNQv5oxP6ueJWtPuGUiDR1zy8//b8N7s5WlTpipmpL/WpzxPMMqN3dlWzLuL36ws7M6ZXG1qlWhjZvTV3XtSV+y/ryYguLX0W5quw2vnd/E0k11zU6xo47XAq7CgooXOrFO67zHOhXbi1gIQ4k4yx0Ys9X8O8a6HXlXDRg4HbEFhLoOSYaLdQcRrsdVgMd30JLbrCubfXecr1QnXr5AyH+NoB6nqgxtv0a59epxgzn7QbCEktwVoM+Wv1GROxaOW2EJ+DbMMQHcKNpVDFRMrY2iHEW2sshkeLqjwWyuxL7uHGxNfJvuSe2gN6xcB0PrEYM046n1gMeC6689bkUW61k5EYx5DcTDFvxyXuZprr54bkPvEVO6NFu5D7i7NR/3+0qJLxL62o9Rn6mofeYkZLsO8x2POqhazcam+QoorNWtyk+2mZ4Iu/L97NHz7cTE6LJNqm1z2Owqko7DxeQofMJB76hWe8x8p9hRwtquQ5LzeVpI6Un4blz4pMqKx+tZ9XFPjmz/DJb0Qczid3wNczYNEf4Yvfw/zJ8LmPi6U/Ks+KlgeXPaHfewgX1a0ToZYLAFvV4n16BBOrGE3Q7VLxeM/X+o2LyOgC2HVcBhVHEn+L26vL9jO69AvGfj3WHbeitaZ4x8sEaK/Qv70450wGyEiMc7s+TN+x0jJdZDp5kzNcNI/NGS7+33ei+H/fiYDbijIkN5OZn2+jqNJGssXMhryzbvGgEUge7hNfsT64Y2fUjKdA+NtXdV2BEHVaIeNThK3JY5KymBWW6UxShHAb1aM1JoPY1gV/9YN8EYplJtlipqjS1iD1gZq1uAmVp7/axZ4TpfRumxaWIPJGURR2Hy8lKzWBv4zztMxsO1rM2oOn+deUwU0ulT4qbP1QxNec/zvfGUPf/k08X3ZSdPfOPU8EtbYbIBpjth8MnS4QFYa/+Uvw4zntsOxpOO8esVBHA4cNDv0oHkco3gZ0arvgix6Xi+2eb3QdtldbIW5k3E1k8be4TRvdtXY2j9aaEkaX7wW/G0n7jEQcirDKuVwYgcbIXwuKw20RnDQXZp4RW8SiO210V5cryWQQc/YQMSPvhYRMqC4TQkp1n9Qct2DhrJCtEaFasqaN7kqcyb0WqPMCd+2ZZIuZnP3zXTFKf0j4kg6GQv6Q8CXgTtnekHfW47hqYb4nHrmfsqd7eYizUAoi+puv1jKjR1fz+iDFTRD+9vk28s9U0K9d8N5QgVAUhX2nyshIiqsVS3O6zMqnm47y5m3D/PapkoTByn/Cpnlw+RPQspvnc1Ul8OEtIjal/WDI6iPcIQYfn7vBAFl94eROcPrv9wXA2n8La0m/a/V7H+FyZH1Ny4WWospyBLDaHS6RoFswsUrXMWA0i1YMp/W7s1OLDErLTWRQFzE1PfgfXTZ4WDOmjMitnc2jzSjykV209sPnKHikG2s/rB0grC6QHscJ1Cm8Jt37ufIr/QqKV5ftdwmbRyf0c9WEUdO25zkuoYwEqDzrGbQ88l4KaM3LtqtDTnVWXUehWC+cTpF5rJ2X9jOYNrorU/mMDoZCbnV+yqv28ZQlZLtcelrBoT2uKo5uUz4lparAQxT6EzTBYmK8LTOBupo3RL0buZL6we5wct8Hm6msdtC3XVq9RIeiKBwoLMdiNvKYj5TvN1ce4vYLOpEYH6U7/qbE2n/DweVw6aNg8erp9M2f4X+3QnoH6HBuaGnaZgukZcOXf/C/z/6lwnJz4R/rNfV6o7qkukSm5QII60e1w0mL5HhyWuic5p6YAR3PE493L9Jt2N41lpu9J8qwO6LUob0J4x2AO/zoW7WtKKqrCYQgyVtV+zmNG8pXjRZVHAC1j+M1hq907zllF/kUFFoXj1ZAaN/bq8v2+w5aHjqVJVcsISMxjm+4G9bPZd6aPJ574k8ui4i3qAGCWi/mrclj5ufbagkuFa1ImMs1HFFa8aL1KuaUXcTlvOL6HLSCQ3tcVfT81zCRsoRsD1EYjqDxRvvahrTS+EL3xplNgeJKGw99vJW26Qm0Sa1b/RoVRVHYf6qceD/1apbvOUW3rBSuHSzbKtQLRRENLws2w5i/CguAit0Kn94FjmpReybcFPC0bCj42fdzlWdh55dwu36LcZ3ZVxNvEMn6NjXBxAM6pEfGfdpngnCt7fhcuBR1oENmIikWM2VWO/tPldOzbRR6fTVhvCvoFpRfybSEBaT4sqKo7qOSY6A4KFg4iyWOS2otnof73EnSjhdoEVctLDNDp9ayBAQ6jnfLAu/qxN6VfosqbbTPSPTZPdv9unu4cdkVrhgXj2rIqxdBsbCAvGrtzAe2j0mxF7r+f7SokozEOA/R4I/p8zexYIvInPIlbLwr/mZf4p5X+5oWCP7eg7dAgsuA5z3296hk7Kfasj98NeT0Jty2EXVFWm68ePbrXTzw0Ra6tE7RSdiU+S3Ed6a8mpX7CnlsfN96HafZY7fC/JvAXiWqDZvi3c99N1M8l9wKOgypW22bwv3Qqpvv59a+BsPuiFzNnFApOwXHaupkRDCY2CVucjIic4DeVwMG4WIrPqLLkEajgT7thPXm55psG4l+eFfQdVkPoHawreo+6juRYlJIUCp81rMZfsMDpKdnYrEVuyxA3hV+55RdxIDiv4tsJi/81VpRF9GQYknWz2XK6nGsHHvQtWivfGiMZ6Cx9/saeS/TRndlftx1lCVks7b9rS6r0P2X9wzJCqJNCfclbB7+bJsrI0ordF6cPMjtRgulNk4ohBEPFSrqZ79w67GINh+NeXHz9NNP8+CDD/Lf//6XwsLCOo1htVopKSnx+OeNoij85dOfyTst4mtS6liYTzuecEWZeMqHsHE6Ff79wwFuPb+TjLOpD9YykerddSwM/KVn7MyXf4AT2yFnqLC+1AW7FapL4bInaz93/GdhIep/fd3GrsFqtVJWVlavMThQkwLe9pyItVwA2BxpcZPa1u2a2hG4SW84nFOTZfNzTTC0JHRKSkqwWmuXRQgaMOprYVTdR5Pm4jAnk2koZyqf1T7o+rkifiwh02f7hGB1YDziZXx0AVcFhy/Xi/q+1MKA/tooqBac6fM3ccGSzsw7byEMncqUEbk88NdnSXloF/cdGOIK/PUe31/8j5oa3r99eq35e7ZtcHLo65f4oPI3HPr6JdfzegqGDxImcURpxQcJng1t69MqQds2IpJuq5heVSdOnMiXX35JmzZtuPfee1m4cCFA2O0dZs2aRXp6uutfTk6Ox/PFlTZ++5646+3bLq3Ohfm0HDxdjtlo8ClsAD7acITzuraU7qj6UHQY3rkG+t8ksp1U7Fb48GYRPNzxPDDXwwJ3aje07F7773YrrH8Drqr/Hc2sWbMYNmxY/QbZ+63YqunUEaC4wsaBwnIABkayCWWfCWK77WPdhnSJG2m5CZucnBxmzZpV6+9BA0YDBfmCK1bkJ2eP2haeFbOFy9eS4tMdMsX0HVvS/8g9KctD6hTu/XdvweHzdTXBuf4CkX/Yc8q/BaImRfwfXTbUWsC1FZi9RcK8NXlsyDvLoxP6cbq8uta400Z3RXUGW8xG/o9P6WAo5P/41PW8noLhz4eHMtL6In8+PNT3Z1QHEaVtGxHJ4OKYFTd//vOfOXXqFCtWrOCPf/wjw4YN48MPP+TkyZOcOXMmrLFmzJhBcXGx619+fr7ruScX7uRPH22hU8tkOmQm6RJHcLCwHKPBwNPX+c5Y2Xa0mNPlVh64PIKVcps6616Hj6aKxpTtBrr/Xnpc1KdJzYa2/UTGU10pPSFSSK+ofWFn5QuijUNSi7qPX8OMGTNYt25d3QdwOmD/EvE4kvVtjhYBkNsyiczk+MA714e+E4UF7uhPULhPlyH71YibHQUlMqg4TPLz85kxY0atvwddSH3Vq9HUhVEL750fX1NVe8njMLsfaz98jsWlnXBidNem8a4ns2I2KVUFTDMv8LRuaPbzN79af/caW31+VI/WlFbZXQ01L3h6KWs/fI6xX49ldOkXAP4tEDVWq+FH36q1gGsrMHuLhGDusikjcrl6QDtX7Zr8PndRgNiqz68ce5Apq8eF3gtLg7fY8leMMNh3r3cTzLoQk+LGbrfTq1cvPvroIwAee+wxlixZwsUXX8zLL7/MzJkz+eab0GthWCwW0tLSPP4BPPHlDo6XVHJO+wxSEvSJrT58phwFhWf8CJuSShufbDzCy78crMvxmiVLn4B938Ivnob09u6/f/0QfHY3tB9Uf9eM3SpSkq99o/Zz+5dCYgsY9pv6HaMGi8VCSko92hjkrxMVlRMyIGeELnPyxebDRUAEUsC9Sc1yB0Vv/UCXIbu0SiY53kSVzcn+U+W6jNlcSEtLw2Kp3V/Pw0rjp5hdLTSuKvX1KWMfoCwhm+IqGxTn03HHa/Rx7MSI012bxtvFVZPe/XTpLzwtCD7G92UZUFOj563J8xtX0vfAXLI5xW/jhJA5WlTpyuL6bdwXrhgabwvEvDV5PFd+Za0spPEvraDTQwt523StqwKzt0jwm6mk+Xy1tWuG3/AA2Y/sY/gNmmrO/uJkQviOvMVWOMUIfY2jikKtZaqhRE9Mihuz2cyUKVNo06YNBQUFFBYWsmfPHu6//35uuukmqqur+fLLL3E663cHZnMq9G6bplsJ+fwzFVTbFZ71I2xsDidzlu3j1vM71bnZZrPG6RQVg0sLRNVhNXBYUeCzacJNlTsC4pPrf6yTu6BNb5EKrsVaIjJ5rnze9+uiwW7hrqXH5WCK3Hm1qSbeZmCk4m209L9JbLd+IL73emI0GugrXVP6ol0stQuqj0VUXdTWtr+1tquqJlX7WdsNri7WakCuz7o4Na951T6eu8wL+JXpO3eXbR+uMO/UbNUt5aqU6/UarVuK9Byy+13ECst07klZLjpsp+dwuM+dPuN51Nd7p2SDu3XEs6cvcFm0vAWYX0HmVSFZrV0zff4mj8J8tT5jf9+RH3xZZHwJkmBuKXUcwKdlylv0RIKYFDcARqMRo9FIdnY2zz33HF26dMFqtdKnTx8GDRrEmjVrqK6urtcxOrbQxw0FwmJT7XDy/PX9fY7pcCq8umw/l/dty/Xn5vgYQRIQaynMmyhq1Ay/yx047LCJ+BpFgfZDPFPA60r5KeGOuvwpz78rTlj2DAyfBuYIumXCQVFgV00aes9fRPAwChsPi3LwroUkkvQaB/GpUJTnrrpcT9S4m21S3OiDdrHUCgQfi6ha4+XOnQN8tlaYNrory1KvZskVSxh+wwOugNxA6cda946rVYEPV9iry/Yz2faxKFa35HG+4W5+nfC9K6BY7QL+wU/5FDzSjenpP9A+I1H0qRp5L2wXhe4eSF4kLCT3buO+A0MYXfoFo78aU6vQoD+Xjdo6Qt16M33+plrdwV1oChECrto12ngfVTjcd2CI+zPw9x3V4C1cfIkrX/2qgrml1HHuv7ynT8sUuEWPOgetUNODmDMfKIpSSxzEx8d7bIuLi+nSpUvMtCnIO12O3anw3CTfwsbucPLKsv2cm5vJXRdFp6BRo6YoXxTfO3cqZGusYlXF8PFUyOwEab4b1IWNo1pYbW58t/ZzG94SdXLqmR2lK4V74Mx+YcXqVjslVi8OFJZTVGHDYja6ejVFlPgk8Tn/9B/Y+BZ0uajeQ/av6YWlWqAk9UQVMmoNFK0QUf8ejPVzYcnjTDHAlLEPw1A/NZq0i3TNcVLGPoB18aO0tJWy1HEbfHQp5K/lYGI/Eo7/xOE+dzL8hgf4R5cNtNxRihMDRoeVFNtZ/pr+NX+9V1hfL3h6KUeLKrmg8h2yDYWMOjGPGx95RBz3mcdBceDEwPr2t1ITAcS00V0Z/ZUQV6YdrwFut5B3rReVBb8bWetv2lRubSdxbzfQPMclzCxui0OB9pr6PC2T49l+rJghuZkM69zCo5ZPrYwz7++I2vWAQsXfewy2n/p/7zpDR4sqOV5c6cp+0yPIOCbEzfz58ykrK2PEiBF06tSJ1FTPIluqYCgoKODTTz/lueee4/vvv/fpB25oDp8pxxFA2NgcTl5auo8Lu7finov91EqR+GfLB7DuNbjoT5Cmia9Z8igc2yxSnwN1+g6Xgq2iJYN3R+3Dq6H8JFz1D/2OpQfbPhHbLqPBErnidOqd8YAOGcSbG8jgO/hWIW52fiGaoCa3rN9wHYXFafvRYiqrHbIieH3xsViq7o+17W/lh292M21JL1LGPsD9l1/iufCqrJgNVWfdj4dOrVWkDhCWiyXP8Wr5lWSvyRMNMlfMxmIygs0q/m3/FBQHOcVHMeOEGtEx/OhbQE0qu8ki2pN4VeR9ddl+VqbfzKgT8zjc505chSNqEnOLlSTuOzCElTV/njIil7WH78K04zXP/YPgXcCu3Gp3ucfG9W/Hwq3HXMG73gJA2/dqiuk7plhm81zxlWxVLmJD3llenDzIUxSoGWcG/+e5d3FDX/MFXHV69MJb9HgX9dODqIubCRMmkJeXR6dOnZg9ezZXX3011157LcOHC42sWnJsNhtz5szhk08+4bvvvqN//+h3zg5msVGFzeieraXFpi6selmU4b/sCc+Fe/Ff4cSO0FsohMqZAxCfUrumTXkhbHkfbouBKsRaFAV+/p943G9S4H3ryaYal9Sg3IyIHseDdgMhewAUbIHN78IF0+s1XIfMRNqmJXC8pIotR4oY0aV+YknigxoLy9DiJzlXAZNdEcG9906tdTeuVjP+nXm+6NuniXkRXcS/ANMMl4i6fElnRld+wZSvx0KCXYiixExhmTAgal3lr6VISSOjZCdVbc8VB8oZLgpCmhNh7MO1BJlroV1/EFYkkN1ZkwE59mHKljzHG/bxnhaRFbMZPvJeuGFfyMJGfW9aK4V31WKtxcY7c8pD8M0Wn/O0hAWQAtNYAOsf8Hhva9vfypDipzArDg+Ll8/3HmC+/qo360WoVqBwiWrMzfLly9m3bx8bN27ks88+44UXXqCwsJA5c+awapXoPaKKhri4OB566CGWLl3KoEHhRW5HgmDC5mRJFc98vYsxvdpIYRMuTgd8/ltRcfeyJz2FzdcPwqld0HG4vsLGWipSvye+5vl3xQk//h0u+D3E1a9ite4UbBYuKXMi9LoyoodSLTdDOjZAvI2Wc2suyD/NrXdgscFgYEgnMf+fDoVXTkISBDVwNWc4GEwYUTAZFBQMrG1/q89YCjXwdqz5LXjwkGvxHZKbyTTzAs8u4sA/umzgsbg3xd8dVhGDYruBeaOXi9dPmgv3bqOVoQQzTjpX1vSyyl8LKMLyN3RqrYBnNeDYsfB+KM73bIw5dCopD+3igb8+K6xFs/vB0sfD7gSuHkctHqimjweqWqxtEKqtlAy44mdSxj7AA8mLajW/BLjvwBBm2m7jGK0CNg0NxD+6bGB1wu9Fk9JGRlTFTVpaGllZWVRUVOB0Ornsssu48847SUpK4v333+fIEVF+/Z133mHp0qWkpqaSnV3HSrM6obZUcCr+hc1Ph87w+o8HmPPLwdwxqksUZtmIqSyCdybWBL79wTP7Z+F9cOaQuIDq2e5AcQrrwIQ5tevibP0Acoa5C8vFEls/FNueV0TUJVVcaWPPCVFBeXBDBBNrOed6SEiHs4fcvbPqwbk18/9JDUCV6MMSseCzbwlc6RYHBqOZH/acchWt06Iu3tPTf/DoAL4h7yyv2sdTQGsP99Hwo29hUv1EZov/ZpjegbPq/3OGe4gTVQyoAccmnNgVo2djTC1q3I9C0E7g3hlaIAJz1QaWoRSwU4NyXQ1CFz3gzkDTBk77KZaoBmlfaXjV/TmFmrJfw/Cjb5HNqRrXXuTRM1U8quKmdevW7Nixg7feegtjTRfjYcOGceONN7JlyxZ27doFwJYtW8jKyormVAHRMmFnQQmJcSaenTSglrBxKgrvrT3M1iPFfHjXeeS0SPIzksQnu78Wwmbgr2pbIr74vSjQlzMUjDrHSpzYARkdIaWN59+P/wwnd8KYh/U9nh7YKmHze+LxgMkRPdTGGiGQ2zKJVikNHOcWnwSDbhaP1/6r3sMN7SRcDhvyzuJ0hlfpXBIAg2Y7dKr7D067R1YT4Fpgp5i+Y+VDYxh1Yh7ZnKLXjhdcVX0vsuwli9Oie7jWKpSQKVxRYx5m2uiu3JOynCX2W+GZTr4X/pr/zztvIQXblrvEiVYMTBvdlX/VdPx+xH6byJLyhSoixj7MkiuWsCz1as/4EI1w8MjQqkmPX6RM41em75ikLA4oMOatyWPgo4sZ+OhisciPvFfEzajuJW98FUvET8ZSjUALyeq0fq5ob5OY6TM4vL5CxNfrfWVm1ZWoipsOHTrw2muv8dhjj/Hee+JCrSgKF198Mb179+btt98G4KmnnqJv3+g2l3QqCjuOl5CVlsDj1/Sr9bzd4eSV7/fRNj2Bf908BItZBiuGxaZ34YfnREfvrD6ezy28T6Rntx/i2TtKD07vF9aaq17w/HvJMfHjvuHt+lU5jhTbPoGqIkjvGNEsKYA1B04DMKJzlGJU1MVy/xLRDqMe9GqbSlK8idIqO3tOluozP4m4AUjPcd8I9LtOLMjtBpJiqIKETFLG1mQUeaWK/5A1hbNKMqmUi6q+B+dwmfNHUcRv+6fu/fPXipiZ+BTWHjwjYlDMC0iwl4jA2QD1W15dtp+XbVdTTApWh1O4aRyXuJpjXj2gHfPjruOh1K+E+0mLKlrAb30a7fsqW/Icv6haRIqhiipzmiurrB2F3BO3QLRKCFBvplYdnqFThTUsQCuLQHi3xAhmdfJ4P1VnRRxijXDSCpL69rHSuw+WN1GvczN+/Hgee+wxHnzwQd544w2XNaRVq1a0atUKcKeAR4sqm4NtR4vJSk3gr1f18fn8C9/tZUSXljz0i15RmGEjZ8ULwv1z+VO1rSeL7hdCo/1g/UVG6XHhBvOuQmy3CqF1/ZsRdffUGUURfa0Azr1Nf0uWFy5x07X+rSbqRIsuou4NwJpX6jWU2WR01elZte90fWcmUfG2HkyaCzPPiGB8bY8oHw0xXyweRTmJGFFqLBSacftO9FlDp+OO1xhd+gWOqlIwJ3lYF3z1ayq32lkY/wtMCalYbMVMtn0sFlVNmwQ1dsXDqrF+Liz8oxAji/8a2KVTE2+0qrobtymfkkEZdnMyFyzp7Cqs9675OubYarvctKhF+hLjjJRb7WIums/Xl8srnO/Jp9XJFz7cXSF1Uw8RX69XrUx6ZGZFXdwYDAamTp3Ks88+y+9//3vGjx/PpEmTeOmll7j11lujOjdFUThRUsXu46V0a5PC366uLWwqqx3M/nYPV57Tlrtlqnf4LHlcBA5f+mjt9OuvHxRVh9ufq7/Fprpc9C2a9B9P0aQosOolEeuR0VHfY+rFgWVwbKNIax10S0QPVVplc1X0HR4tyw3AiLvFdsv7YsGsByO7iZumH/aequ+sJMHwXiDV9GT1cU0PKFdF4iufE9YZ1f2Ue77P+JLDfe7kt3FfkE6ZCBRWA5LXz3X1ftJWxX3UPpuflBtJadGWM+Ys/mUfL0RujSAhZ7hvq8aK2bjUlq0icIXf/LWgODg/fp/r/bxqH+9RWC/7kntcxQr9FSicMiKXzTMvo0WyxW290eBdlDCcGBp1fA+rk784HB/uriG5mZgMYhuovUWd5uHnb3Ul6uIGRLuFyZMns2HDBiZOnMiYMWNYt24dAwYMiNqcbA4nOwtKqKh2MOdXg/njZbWVpNXm4IUle7h2cAduu6BzFGbZyFn7GpzcARf+sXZl4e9mCvHRYSgYdT5NbZVwdCNMfLV2e4Wt70Nyaxh+p77H1AtFgWVPi8fn3g4prSN6uJ/yzuJURLxNuwwds9PCJfd8yB4I9irRNLUejOohPrM1B05TZXPoMLlmTqAgVe8FUhU7Bjx6QHlUJB46VVh6vF1NaguBkfeKnkrjZtRuM7D0cbI5xaNx/3Vl+Ewb3ZVxpjWi9k3BVq42/4t5jktEBuC+JSKWZd8S31aNkfcKkaUNKrKW+X6v2gymy3uSYjEzqkdr7klZzjfcLVxgYSzeakzRN9zN2g+fc1mjPMSg5nP0JuSYGNXtF4JQ0va1inViQtyo9OrVi9tvv527776bnj2j1zG7rMrGtmPFtM9M4tlJ/X32nrI7nLz0/T6u7t+Om8+LTP5/k2bH5yJuZNT9td1NFWdEMb0O5+rvcrFXwZGfoN0gSPEKUt+/VNTDuPI536+NBfZ+C/lrhNXmgj9E/HBRj7dRMRhEOj7Aun8Ly1sd6dU2lTapFqpsTn46FPsX6ZgnhJ5FteJW1Bgdb9eMNnjY+3nv42iFkyaTCYMJM06GH5zjClw297tWvEZxMi/j364Ua6qKxN9rLkG1xMfQqcIqNO7vYj4JGSIOJVhgrw93V8DPR/vea8TFlBG5rtd23PGaR3zKZ+Yr+Gz0N6ztfA8FtBZuLy/8xbR4i5617W+lgNZYHc469Z6KVWJK3MQCx4urOHi6nOcnDfAbP6MoCm+sOMjIbq34v5HSYhM25adFnM0YTfNLFbsVPvm1KN7mbVWpL0475P8kxh77N8/nTuwQwuG6/8RmADGArQq++pN4POw3kBb5sgir9wtxM7xLlOJttPSZIFptVJ6Bje/UeRiDwcCF3YX1RrqmdEC1bvizaIBvYaLG0Ghfo00p93KJqItwrYVcG8cz9mF38K2C+5iT5tZU6lXofGIxK8ceZPjOWaDG+QTLiFSFy1gvUaYRJB6iQeuO83bN+bN0+RKJGjecKiq0ouW+A0M4r+qfwu3lhT8h4i6SOBbWz3WN8aJyU9CgZT3dRpFGipsaRGxBEZU2Oy9PHkxaou86Koqi8PbqPLq0Tmb62O4NPMsmgNMB/7tFVJtN9KqZoijw8f9By26QoHP/IqcD8tdDm15wySOezxUdFi0ebno3ol21682Pf4ezByE1G0Y/FPHDnS6zuuJt1DiVqGI0ua03K18QYq+OXNRTiJvlu6W40YWqktoWDe0i7qsWi6/F3OC11YxRayHXuKJcQcsg/m8tg25jPY/Zd6IQMn0nimMqDvF/1VIbLHZF4xZziS61Zs7Sxz0tJVorjrdrzl86tq/PqOa1wzu3YKVlOlNM33mIlkCWFH9CZNrortwTJ4okli15zjVG9iX3+Ewpb6w0e3FTZXOw/Vgxx4qqeHxCP56dNACjDzeUyv82HCEzKY6/jqsdXCwJgYV/hM4XCQHjzYLfQVwypLbV95hOBxxZDy271u70XXocfngebnpPFIuLVfJWwY+i0R9XzGqQLK4f9p5CUaBPdhpt0mKkOvPAX4keY6UFsHlenYcZ1b0VZqOB3SdKOXCqTMcJNkO0QsGfePFVi8XXYu6dUq4Zo9ZCrj5XWeTOllIDlqtq4mm0qBlcuecL6zEGIXS8u2dr0Qo0X/so7m3ILht/6dh+6tV4fw5a0RJycLDmuSmm73jXfB1HlFa8ah/fqKwx4dCsxc2Jkip2HS+lU8tkXrhpIC2DFChb9HMBdofCExPPaaAZNjHWzxWZLj1/Ufu5b/4MFYXQWudYK8UpYmwyO8EVT3s+V3EGvn9KWEH0FlR6UnocPv61eC8DJosLcgOwrMaqMbpnZIOWw8KsiTX68R91tt5kJMUzsruwRn2xpUCnyTVT1IwjVSio+Kmc68KXa8r7b5rqwj5bENS4mly1WFQXmdpvypdgWfo42CvE6/LXBp6rxjLjc59uY8Ucuo0NXSSEk46tEuyzVAkU/6R5LvuSe7gx8XX/BQubAM1a3FTbnbzyq8Eh5dQv3XWCI2crmX1j9DK4GjXFR2qaH/6+9nNVxaIScLtB+sa7KE44sgEycuAXz3o+V3FGdBa/8D7ocbl+x9Sb6gqYPxlKjkLL7g0W7OxwKvywR4ibi3rEkLgBGHwLpHUQn4la76cOXF3TfXnBlqMoiqxWXGe0GUdatJYI1aLw0VRPy4KvxVj929LH3W6gfUvcGT3gtqT0nei56KsBwA8d8h+07PqqDe6WDODbaqKxzPi0rNSkf7P909rvzQ8+u55r8WV9CWTV0Yz7XPmVIovKlwjSCKRwrTV6tkVoKJq1uHlkfF+fmVBanIrC/HWHOXq2ktduHuKzl5QkCLYq+N/tMOoB380nP78bsvrq3y/qyAYRdHvl857PlZ2A7x6BkfdB76v1O6be2K3w4c2ipk1iJvzygwYrKrj1SBFnK2ykWswN308qGHEJMPpB8fjHvwtxXAcu65tFvNnI/lPl7Cwo1XGCzYj1c2tlHPlEFSzbP/VMO/aVFaUuwtqAYG0szvq5os+SWrX43poGmaEKAtXa0u868fpAGUJqAPFYPwHH2tYI6nsL5NoihMq8oWSf+UBtRHo5r/gWQSEIpEBjR7KacCRo1uImGDaHk5eX7qN1ioWXfjk4qBCS+OGT38A5kyC9Q+3nFt0PxjhI0jEbR3GKOjZp2TDuH57PFR+BpU+KxbH3VfodU2/sViEI930HcUkw+X0RM9RAfLvjBAAX9mhFnCkGLxMDfgmteojMqR/qZs1KTYhjTE9REfvjjUf0nF3zQS1y551x5G19UAWLamlxWD2zovJWwaMthPXDV2aSNhbHV4yPVhAEaw6pWlv2LQnYOwkILgi0rRGy+7sLAnp/RhqxEjQ2J9TsKi8imabdmFLAVQxKM7THlpSUkJ6ezpItB0lJ9Z2VU261M2fZPsb2ympUX2jMsfRJqDgtCs7Veu5xOLYZOp6nX6E+rcXGW9ic2i3K99/wDqS31+d4OrFz50769OlDfn4+Hdpkwoe3CGFjssAv34euYxpsLoqicPHzyzh0uoIXJw9i/IB2DXbssNizGN67Xojju9dAq/ArhH+/6yS3/3c9qRYzq/88lhRLDGfLNTDqOVlcXExamp/sRdU9lDNciAZ1QV70gBAQ6Tluy4qWZzqJwN/ETOFGerSFW7DMPFN7fG2Gkvff1s8V1xIFIYhUMeHv2Orrq8vEHPztFy6z+/k+rq/3ECqqlUpxiM8qPqVu40QaH+8xqPutjqjrd8DzEmm58cnBwnKeX7ybawd1kMKmPmx5H46sgyG1C0wBorZM9gD9hI2a7p3WrrawObxaxGf86qOYEzZaDFVn4e0JbovNrz5sUGEDsKOghEOnK7CYjYzt1Sb4C6JFj8ug26XgtAkLYB3u0y7q0ZourZMptdr5cH1+BCbZxFEtG1r3jtayosa0eFsdvLOitGnaWny5aHylVmv7V/kLvg1WSNCfhSREy4nf49bDHeTxWWrddOEQ6vzrg4/vKdquLCluNCiKwpKdJ/hoQz7zpg7nl8NjtLdQY6DspGivcNFDvvtCfTdT/F2tTVFf1HTvzI6imqiWHQuEWLjlc33dXxEg+X83ifeRkCHm22V0g89h0c8ie2h0z9Ykx7ol4xfPCOvWge/h54/CfrnRaOD/alqnvLnqIHaHU+8ZNm18VRRWF/krn6sd0+KjwzYg0rMtaaLzuzYw15+L5qOpwvrzdKfacTv+xIS368rbmuIv1iXUGJj6iBhvvD9XtedWeg5r298aXnBvHWN4wsKHsIu2KyvGr1wNR1mVjTdWHKRjiyQ+uOO8gLVuJEGwVcIHU2DkH/yLl1O7RRCxHjiqRbp3y26e6d6KE9b8S1iGbnpf/x5VEcBYkg9ZneBX/9M/LT4EFEVh4VYhbsb1j1F3lJaWXeGiB2DpE6LRapeLaneWD8J1gzvw98W7yT9Tyfz1+dzcxOp9RBR14QRPV4x2gVdFhHZ/tfaNdp+qs+Lxto/cf1PHXPK42/VUdRZKjgmLBngGFQdCTTHXdBf3mIf2eX+vaygCfK73Pb3UZREJyd2TM1x8Xt6xQHqiFivUoNbhiRaxf7VvAA6dLufv3+5h/IB2PH1dfyls6ssnd0D/G6FFF9/Pl50QVpv45Pofq7ocDq+FNr09hY2jWlwQMzvChDmNQtgA2NsOhl8viYqwAdEQ79DpChLijIyJZZeUlvN/D1nniNiuL/4QtnsqMd7EvZf2AODvi3dztrw6ApNsooRSy8ZX40xvS0zOcFGbRk2L8g4WrjorXE8G3IHJaj2bUEWHj+7iQV9bn3iZ+hBgfmFbRNQAarWmTzOhWVtuFEXUr1l/6CzvTB1Oi+T44C+SBGbliyJdOWeY/32+m+k7cypcKs/C8W1wzaueRfiqy2HJY9D3Ghh2R/2P04BUXPMmLSLc6TsQ79fEnVzVv13jCa41x8PEf8G/R8PuhbDpHVELJwx+Oawj7609zK7jpTy5aCfPXy/rWUUE7zt8rYXioUO+xcTIe8WNigERJ+NLZIQrQnxYGnxac/xZmiKNr/nVELZFJBqWpxigcdzORoh/fLuHymonH9wxQgobPSg+AjsXwNBf+9/H6YDSE7U7ctflWCd2wPVveQqbkqOi2vHgWxqdsAH0rfUTJiVVNr7cegyAycNyojaPOtG2H4z5q3j81YNQuDesl5tNRh6b0A+DAT7acIT31h6OwCSbIIHiOUIJZPW2UPiKWxk6VQifBw/5FxjhxJX4m5cva0koTUHDIZTPRO8AYD1jgRoRzVrcvHjTQB6d0BdzLNbxaGwoCnx6l7gYBFqgv65pdVDXYohOh6hhU1Usar9oG2ye2gXLn4Mb3oYBN9Vt/GbM55uPUWVz0r1NCoM7xljhvlA4fzp0HgW2Cvjo9rBbMwzr3IL7LxPuwJkLtrF014lIzLLpsH6uZ50Y70VZ27rA34Ltq4qxv0U90POhupnALYQWPSDG8hfkrM4vPqV2U9Bw5+d97EBjNUQAcDOgWa/qrWOlGWBT4MfnoU0fyAiSYVZytO6p2NUVIqU7rT1cN9dTRJ3eL4KHp3ykj8urmeF0Kvx35UEAbhrWsXFW4jYaYeK/IaklHP8ZFv8l7CHuHt2Vcf2zsTkUfvP2BuatyZOtGfyhxsKofZ28F2Vt6wI9FvVAhfrCsU5oqwqrqevexw3W0bwu81ePHWyscISaxC/NWtxIdKL0uCioNnBy4P2cdlF5Ny4pvPEVBYoOC4tN9kCR/qslbyWsngO//FDcRUrCZsmuk+w/VU5qgpkbzm3E4jAtG679t3i8/g3Y9nFYLzcYDLxw40CuG9wBh1Phr59t47Y313OwsDwCk23keC/C3v/Xti4Ixb0TbFHXPl8f64a2qvDIe92NP5Nb+e4AHqpwCkWUDJ0qjrfoAZHO7m8ff8driJo1TYRmXaE4WIVDSYi8c60o1OcvO0rl6xkio6VNr9DHtlVBwWZxYRw/B0yaIFdFERWHHTa45hXRMbqR4lGhuEPDi4tJr67ip7yzTBvdlQevCOP7iVWWPCb6TsWnwG++h9Y9wnq5oii89sMB/vHtHqrtTowGuGZge+64qAu92jaPa0ZIFYrDwV8F32CEUqVYj3mp1hytgApl/HDn4q8aczhz1auqciNEViiWNAwlBUJwBBM2ILKbkluGPnZ5oSho16YPTHzNU9gAbP1QFOWbNLdRC5tos+bAaX7KO0u8ycjt53eK9nT0YfSfodOFosT+B1PAWhrWyw0GA3dd1JVF0y9kbK82OBX4ZNNRrnjhR257cx3rD4W5KEmCWzb8WSVCqVKsx7y0HcbDGd87hicYajXm7P7hW2GkyypkpOVGWm7qx9InRGXRrhcH3/eDKaIeTVxi4P0UJ5zcJYoBXvs6xHu5sRzVsPMLEVfxq4/qHpwcQ0TLcqMoChNfWcXm/CKmjOjIE9ec02DHjjhlJ+G1UVBaAL2uEj3F6ljvaEt+Ef/+4QBfbSvAWXPFHNOrDX++shfd2qTqOOnYod6Wm3AtGpHozdQQaPs/hWNRkVaYOiEtN5KGIX9d6JUv7VVgDhLEXV0OeatFrZyb3vUUNo5qEUOx6IGaTtkfNAlhE02+2X6CzflFJMaZmD62e7Snoy8pbUTmnCkedn0Jy58O/ho/DMjJYM6vBvP9/aOZPCwHs9HA0l0n+cU/f+Qf3+7BanfoOPEmQrhxMWrsi/f1JFQrSrTiUbxjeEJFWmEiihQ3kvrhqK5tWQlEIDFSfER0CW83EK7yuiAqiggaNpjg/xbDRX+q7aaShEWVzcEzX+8C4NcXdqZNahPMHswZ5j6Xlj8Dm+bVa7jclsnMurY/39w7ijG92mBzKLy4ZC8TXl7JzoISHSbchAh38Q5USVevNOtwxguHurjJmmn9mYZCihtJ3akqFgGb9cXpgGNbREzO5A/cnYJVygvh24dFiu+Yv0pRoxNzvt/HwcJy2qRauGNUCDFTjZVBU9wL7ILpsOPzeg/ZtXUKc289lzm/HEzL5Hh2HS9lwssref2HAzidzc7T75twF29/lhvQL806nPFAZic1YqS4kdSd4qNhNyn0QFGg7JSoXZPSGia9WTsbavdXsOwpOPf/hOlXuqF0Yc+JUv61fD8Aj47vS2pC9CojNwhjZ8LAXwnLwP9uF8Ho9cRgMDCufzZf/2EUY3u1odrh5MlFO/nlG2vIP1Ohw6QbAdrF39/jUMfYv8S/5SbUNOtwat34Gs973rKgXqNFihtJ3Tm43LP1QTAMRlETB6CqBA6thPJTovDalc977uu0ww/PiaDQ276CPhP0m3czp9xq5+53N2JzKFzSuw1X9AvjO2ysGAww/iUYMFksoJ/8RqSLO+z1Hrp1qoU3bj2XpyaeQ2KciTUHznDFCz8wd8VB7A6nDpOPYbSLv7/HvtCKCHVfBf8CRm8Xjr/xvOfdXOJimqCFSoobSd05uhGyw2gweP1bos5N3iqR6TRpLlz3hiiepcVuhe8ehfZDYNzz0g2lI4qiMOOTn9l3sow2qRZmXdu/cVYjrgtGk+gQf/508f8f/w5zL4EjG+o9tMFg4JfDO/L1Hy5kWOcWlFc7ePzLHVz10gp+3Huq3uPHLNrF399jX2hFhLrv2IejH4MSSq+rpkgTtFDJVHCZCl533rgUxv09fFdReaHoCWXy0azUWiruqPvfCOfers88GwENkQquKAqPfrGD/646hMloYP5vRjCsc4uIHCvm+fkjWHifiBsD6HapaPjabWy9m5c6nQof/JTP01/torjSBsB5XVoyfWx3RnRp0WjEZJ1TwUNJ3Q60T0Olfsd6inlD0og+i1DXbylupLipG6f3i4Z4F/5RvzEri+C7R2DEXXDO9fqN2wiItLipsjmY+fl2PvgpH4DnJvXn+nNzdD9Oo6KkQNRp2vwurkZIiZlC6HS7BLpcFJ7b1Yuz5dW8tHQf76w5hM0hxu+dncaUER256px2pCfFdpxTncVNfeu3NFT9F1lnplEi69xIIssPz0KPy/Ubr7wQvpsJ5/+u2QmbSKIoCiv2FnLNnJV88FM+BgM8NfEcKWxA9KG6Zg78bgOMuAeSW4uMvZ8/hE/vgL/3hJeHwpf3wbZP3PFiIZKZHM/fru7Dsgcu5uYRuSTEGdlZUMJfPt3G0Ce/4+a5a3njxwNsPVJEtb0JxebUN06loeJcmks8TTNFWm6aseXGarUya9YsZsyYgcUSRvuCqmJ470aRvaQHpcfh+6dg1P3Qa5z779s+gZPba6eG60ydPwcd0ctyY3M4KSyzsu9kGZsOF/H1tuPsqKm/0jI5nhduGsiF3VvrNW1diIXPHxAlCQ6vgb2L4cD3ULAVd2vrGtI7QvtBkHUOtOoOmZ0gNVu0AQniziqqqOZ/Px3h441H2HXcsx2E2WigS+tkOrdKpkNmEtnpCbROtdAqxUJGUhzpiXGkJsSRHG/CbGqYe9JglpsG/96i7DqJmfO0gYjV9yvdUgE4e/YsLVq0ID8/v1mLm5KSEnJycsL/HL59BDI6QMfz6j+J0mPw4wtw4X0i3kFFUeC968V2SnidncOlzp+DjuzcuZMRI0awbt06srOzXX+/a/42quwOFEUss4qi1GzB4VRwKgo2h4LN4aTS7qSyurYFIM5k4Jr+Wdw6vAMtkmPPFVJaWkqfPn3YsWMHqakx1MqgqgjzsZ8wHV2H+ehPGE/vwYB/C4tiSkCJSxIix2gGgxHFaAIMIlMQQ81jA9VOhfJqJ+VWB2VWGwajSXyv+I7H+U31fZQiakqZjQYscQbiDAbiTEaMRgNGowGTQQQ2GxBhcGIrxlPDfDz+VjO2NgRIGw9Ufvo4q5+f6vd30eC/mznDoeQopLWHe3yki0eYWLhONCSx+n7VeRUWFtKypf9ehc1S3Kxfv55hw4ZFexoSiUQikUjqwBdffMFVV13l9/lmmWPbrVs3AF76+HuSUmLoTtGLCqudb7Yf59UpQyIyfszeMdsq4H//B2P/6n8fRRGurMnz6324WPgc8vLyGDlyJKtWrSIjIyMqcwBhGfrte5u4fWSnBjtmZXk5d066nNc++obE5GSP54orbLy6bB9dWgX+XvadLOXPV/UO+9jvrjnME9f0I9kSnUthWVkZw4YNY926daSk6FDtW0d27drFtddey+LFi326SmN57pFAvt/YoKCggLFjx9KvX7+A+zVLcWMymQBolZUd0+KmstqB5agjYqnBVquVmTNn0qVLl5jyqQLQrTeYzogu4r4oyodO3UCHzyaWPoe+fftG1QRcUmWjbW4Jnbp2jdgx7A4nFdUO0hKFi6y62sptv72frr36EB/v/vydisID/9tK1+69XPv6I5ESOnXtEfZczilNQcloT+9O0UmJV8+9/v37R/3c80fv3r19XoMaw9z1RL7f2EC9ATWbA8uXZp0t9VpN+flYxWggon1qLBYLjzzySEyduC5G/xl2fOb/+UM/QscRvp9zOsFhC/lQMf05NDAnS6xkRDhF+fEvd/LnT7ehesTj4y383/Q/eQibaruT+z/cSlpiXFBhUx86tkjiyy3HIjZ+MBrzudeY514X5PttXDRLy43K8ZIqrDYHljhTtKfiE6PRgKPZRUTV0KIz2KpE+wXv/lWlBaL/zBVP137dz/+DNa9CXJLIfgHRtfxXH8m+VCFwsqSKjAiKCaeicLq8mhZJ8fzxf1v5y5W9aJniefE8XWblkS920D4jkcwkH4UeA4xtDPM77tQqifWHzoT1GolEEvs0a3HTMtnCP5fs5U9X9Ir2VHxiNhqafm+aQAy+Bb5/UhRV634JmBNEy4fN78JFD4ly+lq+fwoOrRCp44kZ7r9vfAfWvALn3dOg02+MLNtzspbY0JOnv9pFZlIc7TMTKbfaeezLnaRYzMy8ug/xZiPPfLWL/LOVdGuTQmIYNx0J8UaOF1fRLiMxrPlkJMVTVBm6lU8ikTQOmrVbKiMxjqIKG44Iun7qQ2Mp0x4xzpkEU78Fczx8+zfRlmH3V3Drl9DrSvd+Tid8eKuol3PpY57CBqDftbD9UxGELAnI6bJqWqaEbi0Jl+PFVbRNSwAg2WKmd9tUkuNN3PfhFv700VZOllrpk50WlrABSLXEMXfFwTrNqWVyPEfONpMu3hJJM6FZixuDwUBmUhyzv90T7alI/GG2wEUPCpEz7u/wq/8JN5OWz++Glt1ELypvaw5AfDK0PQfWvtowc27EnC6rpmVyZMTNc9/sJine7FGEzmAw0DLFQt/sNFomx9O9TQomY/iiPsVipqyqbh2+e2en8fbqQ3V6rUQiiU2atbgBaJVi4Wx5NZXVDr/7vLxkLw9+tJUnvtwR0QBfSRBadKkdN/PDc0LQ9PZf7wCosd58Hrm5NRGKKm0RC+A9VlRJu/QEn88ZjQYykuLrbK1MiDNSZaubC7d3dirbj5XU6bUSiSQ2afbixmAwkJWWwD98WG/KrXYeXbCdsxU2umelkBhv4pEF27Ha/AshSQNzYDkM/FXw/eJTRFPEovzIz6lRE35Qbij8Y/EeTEZDxIL3DQYDinerhBDJSIqntMretPo7SSTNnGYdUKySmmDmVJmV4gqbq1PvK9/v48jZStplJJJSU+CrZbIFi8nEY1/u4P7LepIZIfO9FoNBFFZr9vE3vrBXg9MOcSEGkXY6H9a/LuJyJLWwO5wRETYAR4oq6ZiZFHzHelLX30qfdmm8/uN+7rm4ewRmJQHE7/X0XijcA0WHRbPc6jIwmEScXHoHaDcYsvr6di83YRRF4dDpCtYeOE3+2QpKq+xkJMbRLSuV87u2pFUEg/ybKlLcIO76stMT+OeSPfzt6r7887u9nCqtokvrZMxGT+NWSoKZjqYknl+8m8cm9KtTfEA4xJuEuT0xvnn92ENiy3viQhgq7c+FpU9Ebj6NnILiKlpEQLAfL64CiPg5HGcyUma1k5oQvlttaG4mH288KsWNnlSXw8EfRU2qw6vh+M/gqA7+uqSW0HciDLsTWodfmLExUWVz8L+f8nl37eFazVRVDAa4vE9b7rm4G+d0SG/gGTZepLipISnejFOx8sSXO7A7FLq0TvF7F2uJM9Ey2cIzX+3iz+PCL/ke7rzOVFTTPj68FNdmwZGfIPf80PePSxR3hFXFkCAvEt4cPlNBmzTfMTH14dlvdtMhzBTtumAxGzlVaq2TuGmTlkBagpmXluzld2OlwKkz1lLYsUAU4DywrLaYsaRB656im3pKlnAXKw6oPAun98PRDVBxGta/IbqA950Ilz0urDpNCEVR+GTjUZ5fvJuCGvEfbzIyqGMGvdqmkpoQx5mKajYdLmJnQQlfbz/ONzuOc9v5nfjT5b3kzW4ISHGjoX1GIiWVNlpkBA9sbJEcz+EzFbzw7R7+cGnk7i5SE82cLrPSvgEWh0bH6b0w5NbwXpM9UNTJGXF3RKbUmPl2xwnapoVo/lYUkot2UZ7Rs6bjtW+eXrSLeJOxQXo3JVvMvLPmMDOv7lOn119/bg5/X7yHm4Z1pHWqdAOExfGfYe2/YNsnojecSkYudL0Yci+ADkOFqAl0bXXY4eAy+OlN2PUlbP8E9nwtXMlDf90kCnHmn6ngTx9tZfWB0wBkpydwx6guXDuogyssQsueE6W8vHQfC7Yc482Vh/jp0Flev+Vc2voJzpcIpLjREGcyhlXALCczkf2nynn1+/1MuzgyvXgyEuNZsOUY/TtkRGT8RoutSvjqjWGewm16Qf66yMypkXO8uJI+7YL3WruwaAFseV/ESdgqWH3uP7FbfFvCTpZa6dI62edzepNiMXO0qLLOr483G/nViI5Me3cD/7vzPBnnFgpHfoJlT8O+b91/a9kd+t8AvccLK004n6PJDN0uEf+O/wyLHhAurUX3w/7vYeKrjdrq+vGGI8xcsJ0yq52EOCO/G9OdqSM7kxAg0L5HViovTh7EtYPbc+8Hm/n5aDETX1nJB3ecR8eWkY9ja6w0+2yp+mAwGMhtmcSRsxWUVkWmymmL5HhOl4Xgp25uHNvkv6lmIFp0hdMH9J9PE+BkqTWgxeLCiu+4cOVtogr0qPvFv/43ct7K/+PCsq99vsbudBJnapjLjMVspKqemYwdWyTRKyuVmQu26zSrJkrhXvhgCrwxVggbgxH6Xgu3fw2/XQ8X/UncSNRHILY9B27/SrRZMcXD7oXwxiXCfdXIqKi2c9+Hm/nj/7ZQZrUztFMmi/9wEfdc3C2gsNEyumcbFvx2JF1bJ1NQXMXk19fI4pMBkOKmnsSZjHTITOKZr3ZFpFVCq5R4TpdZdR+30bNzAbSuQ9sMswUcVlmt2AtFUbA7lVoB9CoX5v9bWGuG3wUj7nJXgW7dE8Y+DFve58IDs939vIDCUivx5oa7xKiWlvpWHL+0bxbbj5Uwf12eHtNqmuSthJ1fCFEzcAr8bgNc/ybknqev68hggBHT4P++gdR2ItNq7mWiDUsjYd/JMia8vJJPNh7FaID7Lu3B+3W0uuS0SGL+HSPo0jqZo0WVTP3vTxG7sW7sSHGjA4nxJlqlWHhq0S7dx85MiudMhbTc1OL41vAypbSkZjfKu79Ikn+mkjZ+rDYXFn8Jh1eJStHeTUxBBImO+Stg4MLVv8bgEGL8xaX7aJncsLErKRYzh06X12sMo8HAbefn8u6aw7L2jT8GThExMHethGvmiAKbkaT9YLhjGWQPgIpCeOtqYUGMcT7ffJTxL69g78ky2qRaeO83I5g+tnu9smzbpCbw7q+H0ybVwu4TpUyfv0kWl/WBFDc6kZEUj9lo4Plvdus6rtFokEYGb6qKxR1jqPVtvMkZBhvf0ndOjZz56/Po1ial1t8tZUfFZ3XhHwPXHjEYoc946HkFI1ffgcFhpaiimgwfAZKRJCMpnjdXHNJlnIt7teH+/22p/6SaIiazaIeSVbfg7TqRmgW3LYTOo0R9nHmTREZWDFJZ7eChj7fy+/c3U1Ht4PyuLVk4/UJGdGmpy/jZ6Ym8ceu5JMQZ+X73KV5dLm/WvJHiRkey0xMoqbTx4pK9uo4bZzIGbA/R7Fj3OuSMqPvr2w0UMTsSF/tOltcSNyZbKcPW/wFG3iv6c4VCh6HQ+ypGrvo1KUZbxIoC+iM1wUyJTmb6YZ1bUGVz8LfPt+kynkQHLKnwyw+h+2Vgr4T3bhK1dGKIrUeKuOqlH3l/fT4GA0wf0413pg7XPQOvf4cMHhvfD4B/fLuHnw6d0XX8xo4UNzpiMBjo1DKZ02XVulpw2qRa2H+qTLfxGj2HV4dX38abuCRR2dguY5lUTpRUebilDE4b56/7HQy+BVLbhjdY+yHQdyI/tnuRJKfvwmSRwmgwYDAY6h1YrDJlREdOl1Xz0MdbdRlPogNxiXDjPI3AuQEOr432rKiyOXjm611MfGUV+0+V0ybVwrtTh3PfZT0jVuz1+nM7cO2g9jicCvd9uIVya92axzZFpLjRGaPRQKeWSVRWO3jua30ETtv0BD74SfZEAqD8tBAlakBrXck9H1a8oMeMGj02hxOz0eBOfVacjFz/O+g6pu5xTe0GwsBf8W+eZF7LN8l0FOo232BkJsXx98W1e8XVBYPBwI1DO3C2opqnFu3QZUyJDpgtcMM70OViUVfn3euhIDouREVR+HrbcS6dvZxXl+3H4VS4qn82i+/9//buOzyqMn34+Hd6ei/0joRepKgIiiKoIEVRFlYExJWlLCoWxHXVZV0Q/e2ru4K90KSsBWwgKEiQoiAIgggIUgVCQkJ6Jpk55/3j2WCjZGbOmXNm5vlcVy4CzJy5Z5I5c5+n3HdPrmiWputjWywW/j6wNXWTojmSX8aMFd/r+nihJCSSGzXEFp1YLBbqJUdTUaVNglM7MfpsCfuIlz0DsvoFfpzmfeCHVXLXFPBDTgl1k39ev9Tj+2liLUWjKwM7cHoLuH4G1L2U56NfYYFzBgva79T9NU+NdWlaPsFisTC8awN2Hivkhc/3a3ZcKUCOKPjDW9DgcnAXwoJbgrpRQFVVNu7PY8hLm/jzgq0czS+nVkIUr4y4lFnDO5EUo3/vQYD4KAdPD2kHwIIvj/DV/4oDRjrTJzePPvood9xxBzNnzmT79u1Gh1Nj1QlOWaWHZ8/RcdwXGQkucopkcoPXI8qz1+8a+LHsLjEqsfXNwI8V4pZ+c4xGqWJNTY/jb4gS+ln9tTm4xQK120GvR6DLGDj2NQt4hAVZm3RLcpx2K15Fxe3Rbp2a1Wrhrh5NWPndSeZvOqTZcaUAOWNh+BJRE6c0F+YPhuIcXR/Sq6is2HmCm1/cyPDXvmLr4QKiHFYm9mrG6vuvok9rH6dxNdC9WRrDujYAYOrSnZr+7ocqUyc3t956K9nZ2XTu3Jk1a9bwzjvvAL6P5LjdboqKin71FQwWi4UGKTHkl1Yya43/V3wOmzXg2h1hYdMsaHDFBcv9+6TVQNj5juGjN263m+JisTalqKgItzu4a4EOnS6lYWoMPYo/EVVgu/1ZnweKy4DOo8W28TOHWKA+zIJL1mFVtT8RJ8c6+L+V2kxNVXParfz56qYs3HyEE4X+V0IOBW63m5KSEFnnF5UIt78HyY3hzGF4awhUaH+Ozy+t5KXsA/R8+nPGvbWNb46cwWm3csflDVn3YC8e6NsiKG1GzufhG7JIj3fxY24pL3wud0+ZNrnZtGkTe/fu5bPPPuOee+7hoYceYunSpeTn+74ifMaMGSQmJp79ql+/vg4Rn1v1IuMTZ8oDKsYX5bBptgskJG2bD9+/Dy1u0O6YMSmiyrHBncJnzJhBq1ZiS239+vWZMWNGUB8/t7iSIayGr98QVYcvtOVbC85YaD8Mej8BpXnMUx5mQZeDmj6E1lNT1eJcdkZd0YhJi74JuelyX8yYMYOuXTUYIQ2WuAwY8R7EposaWP8dAV5tzpfbj55h8pLtXDZjNU+t2MNPZ8pJinEwoVdT1k/pxbSBbXRpOOurxGjH2b5qL2Yf4HCA9Z5CnWmTG5fLRVxcHD/8ILZVt2jRAq/Xy/jx43nggQdYsWJFjY81depUCgsLz34dPRrcxbk2q4UGqTH8v0/3ofh5QqybFM3u48EZcTKdNf+AXe/AdU/WfEtyTXUYLnpNfbtE2+P6YOrUqezeLRarHj16lKlTpwb18Zd1+ga2LxSVhl0X7y2lGUc0tLlZTFltfpUFbbZqdmin3YpHUXQpwlcnKZoGKTH83ypta1qZydSpU9m8OcR6sKU0EdvEHTGi/s2H9/g9KutVVJbvPMHNL2xg0OwNvPfNT1R6FNrWTeTpIe34cuq1PNg3i4x445OaX+rXtjZXNkuj0qPw+AffhXUCfjGmTW6aN2+O1Wrl2WefZfz48bRt25aBAwdy++234/F4WLJkCcXFxTX64blcLhISEn71FWwuu404l53Zfk5P1UuOZsmWCNsx5XHD26Og5BRc+xg4dWgSZ7GK0YovX4TyAu2PXwMul4v4eJFUJCQk4HIFsarvZ0/A/tVwzd+0TxxrKjoZej8O+1axoOFyzQ6bEuvkGY2Lalbr3642a/fmUlAantXDqy8uQ07dTnDrXNFUd/tbkP20T3f3eBXe3XqM6/5fNuPf2sa2I2dw2qzc3KkuyyZ058O/XMltnevXuB9UsFXvnnLYLKzdm8tn358yOiTDmDK5URSF+Ph4li9fzsiRI6lVqxYDBgxg5syZ9O/fn0GDBrFz5048Hk9Ide5NiXVy2s+TYb2UmMhpkqYosOHf8EZfUTOl853arbM5l6gE6DYW/nuHeOxIoKrw/gQoPCqaHNqDs7PjvOwuuHoKFJ9gQcrrWNTAfw56TU0B2G1Whlxaj3uXbNfl+FIALukjqicDrJ0OOy4+KquqYpFwn+fWcf/bO/gxr5TEaAd/uaYZ6x/uxf+7rQMd6ifpG7dGmqbHcVcP0Q7jHx/t1qzmU6gxXXKjqipWqxWPx0NCQgI9e/YkLi7uV1NJ+/fvx+k0+GTsB5fdhserUuVHg804l51Sd5j/knrcsPIReP1a8aF7/VOBb0euqfQsaNhdzNUrYf46FxyCN68Xa4663q1v4ugLi1XsqIpNZ37anIAPVz015e9U8MU0y4ijosorG9uaUefRcMUk8f0HE+HwxvPedPvRMwx5aRPj3trGj7mlJMc4mHJ9Fhsevob7+7Qw3dRTTUzs1YxaCVEcyS/j1XU/Gh2OIUxxVlu0aBGvvvoqO3fuPLtC3263n51yuuWWW9i2bRv9+/fn7rvv5q9//SuzZ88mOTnZyLD9khDt/9RUlMNKYVkYLipWVVj/LLxxvZiiuOEZ6PBHcTUfTJf0FY35Fv1Bs8WIpqKqsPrv8O6fxI4orbZ7a63VAKiqYEGLwBsjRjttutaI6tYkRfN2K5JGev8dWt4E3kpY/EfI//WH/OkSNw+9s4NBszew9XAB0Q4bk65pxrqHejHu6qbEGbjzKVCxLjtTb8wC4IW1Bzh+Jrx3952L4cnNwIEDmTlzJh9//DFDhw7lySef5KuvRClti8VCVVUVDRs25Ntvv6VNmzZccsklZGdn06lTJ4Mj909yjJMCPxOUhqmxvLQuzLb47f5ATD8VHRcF35r11n+3zoU0v06MFr11a3i1ZyjNg3kDobwQrvs7JNQxOqIL6/on2LuCBd2OBHSYeJeD19druxPrl9rXS2L70TO6HV8KgNUKg1+BOh2hPB8WDoXyM3gVlflfHqbX/63lv18fA+DmjnX5/IGrmdynBfFRwW32qpcB7evQtVEK5VVe/rk88ioXG5qaZmdns3//fnbu3InVamXVqlUsWbKE2bNn4/V6ueKKK3A4xC9agwYNmD59Olar4flYQKpr1lR6FJx2355Lo7RYvj8RRjum1j8Le5dDjwfEVk6zaNwTbE5REOyPbxu30FYrG/4D370HXf4Eac2MjqZmbA7oMRnWPkW05QnKrf79DOJcdl1r0jjtVhJjHBzNL6N+ig4L3qXAOGNg2GJ49RrI20fJgj9yh/shth0TMwStaifwj0GtubRhisGBas9isfDEgNb0f/4LPv72BMO75tFd53YQZmJoppCQkEBmZiZlZWUoikKfPn0YO3YsMTExLF68mGPHRFY9f/58srOzQz6xqZYQbefFtb6PwNRPjuZofhgsKlZV+Ph+0Qum73RzJTbVGlwG7W6D+TdDZYjWi6gsgyW3w/FtcN0/QiexqRaTCh1H8GriG34fIsphpVznBZXt6iUxT1YtNq/4WpTcsoBKazRxP61n8Mn/EO+y8fhNrfhgYvewTGyqtaqTwIjLGgLw+Aff6VIawawMzRbS09PZvXs3c+fOPZu4dO3alaFDh7Jjxw727NkDwI4dO0hLC5+MMyHKQVG571NTdpsVl90a2ttPVRWWjROLR6+YBFYTz2vXbg8dhomeNZUhllRuXwhv3iD67lw2zvjdUP6q3Q4qS/2engrGbsp6SdH8FIFrGkKBqqos/eYYV8/PZ0LFOBTVwgj7Z2y85gCjuzfGbguPC+YLmdynBamxTvafKuGNDfpN0ZqNoT/ZevXq8fLLLzNt2jQWLlwIiF/GXr160bJlS+bNmwfA9OnTad3az+7EJuSyW/3u/dGqTgL/CrBXlaFWTBHF2zoMF32HzK52e2g7RJR0D4U1OIoCKx4SyU2vR6BeZ6MjCtylI2HrHL/vbsGi244pgMxEl2xsa0K7jxcx9OUvuW/JDvJK3BxIvYojnR4EIH7to6K+UwRIjHYw9caWADz32b7wGP2vAcPT1gEDBjBt2jSmTJnCa6+9dvZKKy0t7exoTShu+74Qi8WC0271awtpqzqJ7D5eqENUQfD5dNHcruMIoyPxTd1LocWN8M4Yw/tQXZC7BOYNAKtD9G+KTjI6Im3E14aEuixo5V/FXIfdousuQ7vVqmvyJPmmsKyKx9/fRf/nv2DzoXyiHTYe7NuCFff0oNGAR6D9cFAVeHs05IbwhaIPbulUl26NU6ioUvjb+7sionKx4cmNxWJhzJgxPP3009xzzz0MGDCAIUOG8PzzzzNy5Eijw9NNrNPOvE2Hfb5fnMtOhUfxq1aOoXa+A0e+hCsmhsaIzW816i7qwqx/1uhIzq38jNgN1XqQ2Eodiq/xhXQYDrve8+uuTpuVgjJ9p3KtFguKbG5rKEVR+e+Wo/T611rmbjqMoop2BJ/dfxUTejXDZbeJ98VNz0H9y8BdCAtvgzLf+xWGGovFwj8Ht8Vps7J2by7Ltv9kdEi6Mzy5AVHTZtiwYWzdupXBgwdzzTXXsHnzZtq3b290aLpx2q1+L+5qlBrLrM/97zJuiK1vwuUTzFMwzh8dhsP3H5ivBk75GVhws5i+qdXW6Gj04YiG5IY0qPR9Ib7NaqGiSt+LAYfNijuCFmuazZ6TRdz68iYeevdb8ksraZYRx1t3dWP2HztRNyn61ze2u+APb0FSAyg4KCqTm+09rYNmGXFMulZsKnjig92cKgrvqVRTfdJkZWUxevRoxo8fT4sWLYwOR1eBJDcta8eH1pbwr9+ExPrm3BXlC7sLml0La4PbtfuCziY2oyE9vN8zNLuW6Rm+r5OwW626l6B3OayUVXp0fQzp99weL/9atZf+/1nP1sMFxDhtPHJjFivu6XHhbc+xaTBsCTjj4NAXsPwBc085a+TPVzWlbd1ECsureOjdb8N6tNFUyU0kcdqsVPo5tVQ/OSa0FoV9uwTaDTU6Cm1ccj0c+ByqTLA7pqJQJDadR0P6JUZHo7/U5pB/AIvqW6Jis1r4eOcJnYISXHYbZZVh3rbDZHYfL2LA8xt4fs1+PIpKn1aZfDb5Ku7u2RRHTXZBZbaCW14HLGLB+uZX9A7ZcHablX/d1h6XXUxPvbnxkNEh6UYmNwaxWCx+XyhYrRaiHTYK/dhOHnTbF0FS/fBZ3Gq1Q9aNkD3T2DgURbSJ6HQHpEVAYgNivUTt9sxvv8unu1mt+vdDtVnAE8ZXwWaiqipzNhxk0OwN7M0pJi3OyYt/7MQrd3Smzm+noC6mxfVw3TTx/ScPR8QOqksy43m0n9g9NXPFHr45UmBwRPqQyU2Iapgay8vZIdCK4dAX0PQao6PQVsPucGyLsTF8PBnqdYWMlsbGEWy128NJ35IbCxZU9E083B6FWKeBbUMiRKnbw4SF23jiw91UehV6t8zkk3t7ckPb2v4f9Iq/iF521Tuo8sK/V9jtlzWkb+tMKr0K4xZs41Rx+K2/kcmNgSwW8Pp5tdcoLZZDp0NgaipvX/iNLDj+d3VoVOXiLa+JruktbjDm8Y2U2lz8TplMhUchJoQbLYaCo/ll3PzCRpbvPInDZuGJm1rx6h2XkhYXYINdiwX6PysuFtyFYkS0/IwmMZuVxWLh/25tT9P0WE4WVXD3vK1ht2ZMJjcGctgsFFf4N7VULzmaYwUmT24KDkFcZmjvkDqfOp3EQulgKz0N2+bB5SG6pT5QdicoXiyquXYmuau8xDjkyI1evj12hsEvbGRvTjEZ8S4W3305o7o31q4CdfUOqoR6cHo/vDsGlPBeQxUf5eCVOzqTFONg+9EzTFz4TeiVGLmAMPzUCR12q5WiCv+yZYfNav45/i2vi/L/4ahBN2Ompt4dA13HioaAkSq5AXU9vteI0pOiirVwkvY2Hshj2CtfklfiJqtWPO9P7M6lDZO1f6C4DJHg2KNh/2ewepr2j2EyTdPjeH1kF6IcVtbsOcWEt7aFTf8pmdwYyG61UB7AUKDdajH3L2LOLtEbKBzF14GSk8F9zM2viGaSodYAU2u1O/BUo29qfHMVFQsy8QhFn+89xag3t1Ba6eWKpqm8/efLqZ3o46JhX9TpAANnie83POd34chQcmnDZF66/VKcdiurdufwp3lfU+IO/SkqmdwYyGa1sHyn/x+QCdEOcy8EqywBV7zRUeijejg8WLUxqsrhm7dEIcFIV6stnNxZ45urqr4zeIqqRuQMod4+33OKsfO2UulRuK5VJm+M6kJ8lEP/B247RCwyBnh/Ipz6Xv/HNNjVLTJ47Y7ORDmsZO/L5baXNpl/2cNFyOTGQDarxe8FxQBJ0Q5yikzazLHwGMSmGx2FvmLSoDhIozcfTII2g8EVF5zHMzNHNCgebGrN1qvpndwUV3iIj5KLibW0YX8eYxdspdKrcEObWrzwx05EBXNN07VPQJOroaoUFv9R1JQKcz0vSWfJ3ZeTFudk94ki+j+/ns/3nDI6LL/J5MZAdmtg62bioxzk+dF8Myi+XQKZbYyOQl/JjeDUbv0f55sFUFEQvuuX/JHZirltttfopnpPS50ucZMaG+COHemsbUcKuGvu11R6FPq0yuQ/wzrWrCiflmx2UeAvoR7kHxAjOBFQwbh9/STen3gl7eolcqasitFztvD4+7soD8EClTK5MZAoLub/G8ZiwbzdXY9uFt20w1lyIziwRv/H2bFItFeQfpbVH3a+U6NqxYoK17fJ1C2UE4UV1E6M0u34keSHnGLunLOF8iovPZqn8fxwAxKbarFpcNs8sDpET7mvXjImjiCrmxTNf8dezqgrGgEwd9NhbvzPF2w5FFoNRmVyYyCrxYISQHIi7mrCyX7FC2WnQ7+X1MUkN4ICnXftbJ0jFhHHXqBPTiRyxUOjK5nfaOVFb6qqKnYdPyBPFFZwYyBF5CQAThSWc8cbmzlTVkWH+km8POJS0cnbSPUuhb7Txfer/gY/bTU2niCJcth4YkBr5t7ZlVoJURzMK+W2lzfx+Pu7KA2RxcYyuTGQNYAWDNVMuZBx+0LIaBXcx6wqF3V1jm6GD+8RpdT1roUSkwplufo+xs63od0f9H2MUNXiRjiYTYxScsGbKaqoKaWXk4UVNEmP1e34kaCooorRb27hxP9eyzdHdSHGaZJ1TF3/BC0HgFIlKhhHwPqbalddks6qyT0Z2rk+qipGcfo+t46NB/KMDu2iTPLbE5msFgIauVFUFZsZs5sjG6FxT30fQ1Uh/0dY//+gNE8UCnTGiMWm9mhxAlp4m0hArvuHPqNIv9wxpcfPYds8sSg7NlX7Y9eEuwg+fwrK88FdDFh+/TxtLoivBX2mGVOo0WqDDsN55dBcbi+acN6bKaqK3apffBVVXvN8EIegSo/CuAVb2XOymPR4F3NHdyU51ml0WD+zWGDA83BiO5w5DB/dJ9bjmPHcq4OEKAczh7Sjf/vaPPzuTo4VlDP81a+4s3tjHrq+RXAXevtAviMNFEjzTIDC8ioyEky4kDF3H3S5S/vjqgp8+hgUHRcfvK5EiEsX00PWc7zBUptBWR68P0G0gOj7T+1jSqgnetHo0ZX7+4+Cv/VbVcXwe8EhsagyOgUS64Ez/tcnc1UBjxuKfhK7SWLTofcTEJMS3Hhrt4dDG1jQYgO37+1+zpuoKjjt+iQ3Hq+i65RXuFNVlanv7WTD/tPEOm28OaoL9VNMWKAyOgmGvAmv94Fd70LTa6HjH42OKqh6NE9n5X09mb78exZ+dYQ3Nhxk44E8Zg3vSLMM85X8kO9KgwXS0K+gtFLfglb+yD8orua1vpL/7HF46zYoOQVJDcTOoVqtxYjMuRIbEB/GselQv4soqb7yEW1jAvHh+u1i7Y9bnAOVxZAQxLUcnz4BS0ZAeQHU6ShaTCQ3AlfC769SLVYxSpbaDOpfJm7z0X2w9M/BL1vf9U+w52MWXH7inP+tKKpu01I/namgTpJcTOyvf6/+gXe3HcNmtTDrj51oUzfR6JDOr15n6PW/c8jyB8XIcYSJc9mZPrgtb47qQmqskz0nixkwawMf7jhudGi/I5MbA1ksBNSruMTtIdVMw7cgmjo2vEK746mqWEOTu1cs7svIgqhzfNheiNUu7nv6AKycql1sALXbwokd2h4T4KN7oX2QRm2Kc+C/I6H4hEjW0luAzYdiaRaLSDLrXiqSnLdHB7epqM0BV94LG/6NXa383X8rqopTp9GVo/ll1E824UhDCHhn6zGe+0x04P7HwDb0ahECGxCuvA8aXinq37x3N3hDY3Gt1nplZbDi3h5c0TSVskovf1n0DdOXfx9Q3TatyeTGQBYIKLtRMWE/m+PfaLcFXPHA2yPBUwH1uojmdv46m+AchE//pk18AFFJYn2PouHi5R2LxOiHHlNdv7XyUfh4MqRnQWbrwF5jEFNYqU3h3btE0hQscRnQaiBzkl7/3X8pKrpNHR0+XcrNnerqcuxw9sUPuTz87rcA/Pmqpgzv1sDgiGrIaoPBL4kp8WNb4Iv/Mzoiw2TERzF/TDfGX90UgFfW/ciYuVv8bgatNZnchKiC0koSo4NQitwXlaXiKj7QD8hqH0+GqEQxkqDF4j2rHep2gJzvwfv7K3y/1esMG/+t3fF2LIGOt2t3vPNZ/pBYM1O3Mzg13O0TnQy12ovRpzVPanfci2l4OVSVs6Djr8vlK6qq25qb44UVNEmTVaN9seunQsYt2IZHURnQvg4P9W1hdEi+SaoP/f4lvs9+OmK2h5+LzWrhoeuzmDW8I1EOK2v35jLkxU38dKbc6NBkcmOkQAbw9p8qoVmGyU6q2+ZB7Q7aHMtbCYXHIbmhNserZnNCSiOxyFgrrQaKIl9arDXJ2w92J8TrV3QOgA/vFWtranc4/5qlQDhjxJqdnN3w+XTtj38+XcbA1jlYf1HcT69pqYoqL0671XyjpyZ2NL+MUW9uocTt4bImKTxza7vQfP3aDoHWN4PqFdNTlaHdhylQ/dvV4e2xV5AR72JvTjGDZ29g10/Gbpn3+R1fXl7O+vXr2b3792XnKyoqmDdvniaBRQQVv2vw/XCq5OxwoGkc+1pMH2nh4/vFFZIeW4wT6oiT0WePa3M8exQ06qHNEPWaf0DbWwM/zoV8MEkkj5lt9N3OaneJ5OnkTrG7LRiiEqHZtcyru/TsP4lpKe2f54HcUpqmm+wCw8ROFVdw++tfkVfiJqtWPK/c0dn4In3+sljE6E18bbFZQatzSQhrWy+RZRO60yIznlPFboa+vIl1+3SuA3YBPn1y7Nu3j5YtW9KzZ0/atm3LVVddxYkTP+9QKCwsZPRoWSa+pgLIbThTZsKdUmcOi51MgfK4oegEJOq4lqFWa8j5Tqzr0UJWP9j7CXgDnG/2VmrzGp7PqsfE9GF6VnDqdDiiREHHpeMDf21qqtl1cGIHqR7R9E9VVaw6PNc9J4q4rXN9zY8bjgpKK7nj9c0cPl1GveRo5t7ZlYRgdPjWU0wKDJwlvt/8SnBasZhcnaRo3h53OVc0TaW00sudc7bw9tdHDYnFp+RmypQptGnThlOnTrF3717i4+Pp3r07R44c0Su+sOZvQ7/cYjepcSarb5P3AyTU1eYDc9VfxRZoPQvD2aPE4tcP79XmeDYnNO4BGwJce9NygDbxnIunAk7/IBYOB1NUokjYlo0LTvNBiwU63cG/U97R7SGqvAr7ckroWD9Jt8cIF4XlVdzxxuazRfoWjOlGZkKYbJ9v1vvnml7LxkNZaPVf0kNClIM5o7syqEMdPIrKg+98y7Of7gt6H0SfPj02btzIjBkzSEtLo1mzZnz44Yf07duXHj168OOPkbfnP1D+Frbdc7KIlrVNVjRp86vQ6EptjlV0XEwd6S2xPpScFCNFWrikL+z7JLAP8LTm2sRyLh9NhpQmYmF1sMXXAkeMqIUTDGnNofgE0Yo+W9I3HjjNFc1SQ3O9SBCdKatkxOtfsfOnQlJinSy8qxuN0sKsVcV100S9p+ITYjrdrM2Mg8hpt/Ls0A5nl078e/UP3LdkO25P8Gpg+ZTclJeXY7f/fGK0WCy8+OKL3HTTTVx11VXs27dP8wDDmUhufD857jtZzL29g7BN2BcndogaKYGqLBHVb7XacXUhFotIcFY8pM3xHDHiJPfNfG2Op6XVT0JVGcTpvFD5QlKaijYOK/8anMe7pC+v1l/p1+johSiqysb9p3kw1Hb5BFlusZthr37Ft8dEYrNgTDeaZ5rsokwLzlgY/ApYbPDde6IfnITFInZSzbi5LTarhWXbjzPslS85VVwRlMf3KbnJysri66+//t2/z5o1i4EDBzJggI5D6mFIUVWfR248XgWPohLnMlHnjJJccMX5VvjtfFY9KhbpBUtiXbEdWqsmm21vha1zzVXcS1Ug93tID3Iz09+yWMQi5vyDotK03hpcDke+FDtaNLTt8Bna1ksM3cWwQXD4dClDXtrI9yeKSItzsfjuy2hVJ8HosPRT71K4aor4/uP74YxcqlFtWNcGzBndhYQoO9uOnOGm59ez9bD+03c+JTeDBw9m0aJF5/y/WbNmMWzYsKDPq4UyVcXnhY5HC8ppYLbeK9/M165wX3GOmMIIFosVYtK0a80QkwINLoNNz2tzPC188lfxHB0mWOdgtUGtNmKKTO+u7f97rG39tCsN71VUPt2dw2P9DU4UTWzzwXwGzd7A4dNlNEiJ4d1xl3NJOI7Y/FaP+6FeV7Ez8N0/mesCx2A9mqezbEJ3mqbHklPkZujLX/LKugMoOlY09im5mTp1KsuXLz/v/7/wwgsoWlZqDXOKquLrlP3BvFIam23OOmeXuCIPlKdCZHxajAD5IrkhFBzW7niX9IUfPtXueIFQFbGLTet6QYFwxomKwh9N1v+xqkdvNPL53lNc3jSVWDONnJqEqqrM2XCQ4a9+SUFZFe3qJfLOuMtpmGqy85VebHa4+RXRZPbol7DuGaMjMpUm6XG8P/FK+rWrjUdRmb58D7e//hVH8/WpESSL+BlI8WOL6uHTpYwzW32bwmNi51GgPn0M4tICP46v7C5xlV98UpvjueLFDqHTB7Q5XiA+fVyMJhmxiPhCkhpC2WlYo0On9l9KbSZ28mmgvNLL14cKeOTGlpocL5wUlFYy/q1tPPHhbjyKSr92tVly9+VkxJtgtDCYUhpD/2fF9+uehoNfGBuPycS57Mwa1pHpg9sS5bCy8cBp+j63jlfWHaDSo+3AiExuDORVVGw+Dt24qxTizVQfoqpcbIPWYgt48UmIC+KU1C8lN4RVGvacyupnjiu3wqNi0bTZVK+/0bLW0PkeJ6EOUUWHAj7UBzuO069tbZ/fs+FMVVVW7DxBn+fWsWLXSexWC4/2a8msYR2JdkbomqR2t0KHP4pR03fHBGd9WQixWCwM79aAFff0pGvjFMoqvUxfvoe+z63jwx3HNZuqksmNgRQf19yUVXqIMdsJ48S32mxfVlWRKDkNWk8UnQIVBdp90Ga0gnyDR27cJaKhp8NkxR6rOaLFiN9H9+v7OPW60CVvWUCHOJpfxqliN+N7NdMmpjCwL6eYkW9uYdxb28gtdtMkPZal47tzV48mfu0CDSs3PiMKZZbkwDt3yvU359A4LZbFf7qMp4e0Iy3OycG8Uv6y6BuuezabJVuOBLxtPCSSm+LiYoCwW6zsVRSub1PzrblF5R7zNcvc86FobBmo/AMQZeBuCosFYjO026ZssYAtSiRsRvnsieDuPPNHQl0oyxOd1fWS0RJy9/h9d0VRWbT5CM8P66hhUKFt4/48rn9uHev25eKwWZh0TTOWT+pB23qJRodmDs5YuG2eWF926AtY/YTREZmS1Wrhts71+fyBq7mv9yXER9k5kFvKlHd3svdkcWDH1ihG3YwaNYpJkybx008/YbFYwirB8Soq0c6ar4UorqgiPspkaydy90GaBsnNF/8Si0yNVL0tXCspjQL6UA1YSY7+DTgDZbFAanPRoVwv0UlQccbvu6/87iRdG6eGT1VdDXRulEKDlBiub12LzyZfxeQ+LYhymGxU2WjpLWDgbPH9xudhxxJj4zGx+CgH9/Ruzqap1/Jov5YM6lCHdvWSAjqm6ZObrVu3cvjwYZ566ikOHz7sV4LjdrspKir61ZcZeBWVaB9OCMVuj7nW24C44o5OCvw4ZfkQkxr4cQLhiBb9jzwaFZlKaQJ7V1z0Zm63++zoZFFJKW53ZeCPXZonFhGbbSHxucSkiNe8SLst278TlYSj4rTPd8spqmDPyWIe7RdZi4jdbjclJSXn/X+n3coHf7mSl0ZcGjm7ofzRepDYIg7wwV/g6GZDwzG7OJedu3o04bk/BD5KatrkpnpLeZs2bahbty42m42nn36aQ4cO+TyfO2PGDBITE89+1a9vjgWWHkX1aQ1NeaWXXlnpOkbko4oibWqnVJaIejN69pKqqbgM7RYWJzWsUTGvGTNm0KqVqJtSv9sAZsyeG/hjr/mn+aekfintEm0XdJ/j+JeVfObz3d7++hjPDe0YcWtIZsyYQdeuXS94m5BvfBksvR6FrP7gdcPCoebYRRkBTPBpcm5WqwhtxIgRtG3bln79+lFQUMBLL73E0qVLWbBgQY2PNXXqVAoLC89+HT1qTJfS3/K10rDboxDtMNGV+LeLxcLZQH32BMSZJGmLy4BSjXY3xKTWqJHe1KlT2b17NwBHv/qAqRNGBv7YZXkQa8C2en+54sWoWXmBPsdPagBnfH/fuz0KDVJNVjQzCKZOncrmzXKUQRNWKwx+Gep0hPJ8WHCzdmUnpPMybXJTzWq1snLlSq6++momTZrE9u3bGTFiBHl5eUDNFhm7XC4SEhJ+9WUGqopPjfeqPIq5tlce2gANugV+nJJcsZjXDJyxUFmmTfM7V7zopXSxm7lcxMeLCq4JcbG4XM7AHre6EWgoTEn9ktbb8X8pqYHPJfH9aY8SLlwuF3FxcUaHET5ccTD8v5DcCAoOwfzBsoO4zkyf3Fx//fU0aNAAh8OBoihs2bKFDh068N1333Hs2LGIGi4WIzcmSW4UryjelxRg5VtVFQ0djdoCfi7OWG0WFlssgAEL4Ff/w/j1S/6ISRMnfK8Ga45+d+xUUTTQB8UVHjn1ImknLgNGLBPTxad2w7wBMsHRkemSm9+OxHg8HjweD8OGDWP48OHMnDmThx9+GIfD8asO5aFG9eOqsMqr4LKb5Ef2zXzRIyhQ+QfAZY6RtLNi00V10VBVmiueQ6ixWMSJf6UOozd+XAQVlFaSHCOTG0lDKY1FghObDid3wtybZJE/nZgiO1i0aBElJSVcdtllNGrU6OwQvdfrxW63M2rUKO644w4effRR7rrrLgCuvvrqkB429Sgqdh8rnXpVFYdZkpsf10KrQYEfJ/tpSDDZwteoRDi9X5tjWR1imsju0uZ4NVFZIuprhKKEOnBiuz7HttqxeCtRbTWb9jtTVkVSTIBThJL0WxlZMPIjkdjk7II3+sKIpWLKStKM4Z+UAwcOZObMmXz88ccMHTqUJ598kq+++goAm01MwXTu3Jm1a9cybty4s7uoQjmxATHF5PQxUVEUFYfNBNNw1VNSWjRjLC+A6OTAj6MlR7SYKtNCTIqoNxMs7iKRUIXqdK3NIdp5FJ3Q/tgxKTjLc2t884KySpLkyI2kh4wsuPMTsRYs/0d4rTcc22p0VGHF0OQmOzub/fv3s23bNpYtW8Zzzz1HXl4es2fPZuPGjWdvl5iYSPPmzVFV9ewuqlBX6fF9ismjqDjM8Py3zYNabQM/TsEhsdDObB/EFgtg0WZRcUwqFAcxufn8qdBcb/NLyQ1Fw0+txabhLK/5z+JMeRW9WphkobsUflKbwp2rxLm0NBfm3Ag73zE6qrBh6CdlQkICmZmZlJWVoSgKffr0YezYscTExLB48WKOHTsGwPz588nOzg6rxcMVVV5uudS3TtpeRcVuhpGbQ19A46sCP87ap8xbi8URJU44gYpJhSObAj9OTZXlhX5yE5UEnnLtt4XHpNGhakeNb15YVkV6fBCnE6XIk1AbRq+A5n1FIct3x4gWMN4qoyMLeYYmN+np6ezevZu5c+eeHZHp2rUrQ4cOZceOHezZI0rX79ixg7S0EKrZUQPlVV7qJPnW0NCrqD5PZemi8KgYTg1Ueb6YtjEjR4w200lRieDWsW/SL6mqaJbpDIOKscmNtd8WHp3sU8JUVFFFSqxccyPpzBUPwxbBlfeJv2+aBXMH6FuxOwIY+klZr149Xn75ZaZNm8bChQsBsYuoV69etGzZknnz5gEwffp0WrdubWSomlJVFVVVcdhCcFqqohAcsYFPJZXli7UVZqhKfC72KNg6J/DjRCXo2xTyl84cESfKcBjhrC6A6NFwW7iPyY1HUWW/JCk4rDbo/QTcNh+c8XBkI7zYHfatNDqykGX4J8uAAQOYNm0aU6ZM4bXXXjs79ZSWlnZ2tMbpDK+rp0qvgtPuz0lT9anony62L9JmC/iaacY3yrwQR7SYGglUVKJoUxEMZmg+qhWLRTQyXfmIdsf0MbmRpKBrNQDGZkOtdmJke+FtsGIKVGnU7y6CGL4V3GKxMGbMGBISErjrrrv44IMPcDqdfPrpp6xbt87o8HRR4vYQ6wrRK8JTu6HBZYEfp+QU1G4X+HH04oiCYg1OKFEJwUtuyk6LZp3hIr4O/PS1dseLSgzeKJok+Su1KYz5VLSl+epF+OolOPgF3PIaZGrQ7iZCGD5yA2C32xk2bBhbt25l8ODBXHPNNWzevJn27dsbHZouiss9/KlHiH4IVRQGvnVb8YivGtYbMYQ96uc2BgEfJwhXXaV55p7m84fVJqZAfWybcMHjqYo2x5IkPTmi4IanYPjbouDfqe/glavhy5e02cUZAQwfufmlrKwssrKyjA5DV6qq4lEUEqL9qZ9hgrUUVeVisW0gPnvcfLVtfstqFwlYoGxOfdoJ/FaodQGvqYTaotDjwFnaHM/mwOJ1o9ouvAuq0qP4XGRTkjR3SR8YtxHenwA/rIJPpsD+z2DQi+ZpNmxSYXSZFxrKKr3EOE2VU/pGiz5QJafCZ23IxViswbnSCtWWCxcTnaJt/534OkQXH77ozcoqPcSG8vtUCh9xGaLp5g3PgM0F+z+Fl7qLKvHSecnkJsgKy6v8HLUBQ5ow/pbiCbzbdPkZUctE0kbZaVHZ1xqi67guxGLRrpEpQFJ9Li3feNGblVd6iXaG4esphSaLBbrdDXd/DulZokzFvEGiVpjiNTo6U5LJTRCpqkqp28P4Xk2NDsV/zlhwF/t//5JTYidSKGxXttq0WXejt9X/CM8pqWrRKbD+39ocK6lBjdbwuD0KLoc8PUomk9ka/vQ5dBwBqLB2hthRJXcB/o589wZRaaWXWJcdqx8f7Iqi+nU/zcXXCqy43ef/DJ0pKbtLbMcMhLdK/xGVcJ2Sqhat4S6npIZQcPFpKbdHweVXuQZJ0pkzRqxBG/QS2KPFGpxXr4HcvUZHZioyuQmi/FI3Y3o09uu+FR4vUWY42cbVguKT/t8/lD6Iba7A13t4KsRIlV6KTogdWeE4JVXNEQuVpdocyxkjFsVfhNvj9bn3myQFVYdhMGYVJFY337wODqwxOirTkO/eIPEqKpUehcyEKL/uX17pJcoMawAadYdiPzs2n90CHiKdlu2uwKsUV5WL5EMvn0+HhLr6Hd8MLBbxpcXuNQCbHYv3wtONlR7FHK1OJOlCarcT63DqXybavLx1K+xYbHRUpiDfvUFyutRNaqz/TfhK3V5zFP6r1Q7yfvDvvqcPhNZCYi1q1JTk6DsNZ+b+XFqyR2m3riCuFlGlF16gXOVVcZihSa0kXUxsGoz8ANrcIi4Alo6FTbONjspwMrkJAlVVKSyrYlLv5n4fo8TtIc5lgq2psWn+r3/Y9Lz569v8kiMq8LLnhccg0bfu7zW25klRcyicCvedj12DKcJqCXXo7N58wZtUeRXa10vS5vEkSW92F9z8Glw+Ufx95SOwdqaxMRksAs6Kxiuq8BAfZccWQFGwUreHWDMkNyBGX/y5ii4rgJgQSm7sGvSXKvoJml6rTTy/lX9IdM+OBFos7q6WUPuiHZc9iiqnpaTQYrVCnyeh16Pi72uni2nrCK1oLN+9QZBX4mbitf6P2oAYuenTMlOjiAKU2QpyvvP9ft4qc7dc+C2bQ8QciMKf9On3VH5GVD52xWl/bDOyRcHOd7Q5Vnydi64bq/IqOGzy9CiFGIsFrnoQrvuH+Hv2TFHhOwLJd6/O3B4vNqsl4CmlovIqMhL8X7OjqXZD4cS3vt2nsgxsJhl5qikttt5XleuTgKyeJrpmRwqrDRSN+kJFJ110atXjVXHK5EYKVd0nQZ9/iu/XTocNGtWJCiHy3auzvGI36XGBJyWFFVVk+LnTSnPpWXDmkG/3KTwKzhAdZfB3WFdV9StWWHIKYkOkXpDZOKIvuh3co6g45LSUFMqumAjX/E18/+lj8PWbxsYTZPLdqyNFVSmr8mpSkbi80ku8WdbcWCyi9ogvlYo3vxyaUyg2p9hi6Q93IUQlaBsPiFpBNmd417bRk8XKxVqZeBRFjtxIoa/nA3DlZPH9R/fBrveMjSeI5LtXR6dLKkmJcWLR6Opdq+NoonZ7OLmz5rd3l4TmyI0jWoyS+KM4RxQ91Nqaf4pFsRFHw4WRFxmN83hVueZGCg/XPgadxwAqvHd3xBT6k+9enaiqypmySu697hJNjmU6vq670btSr14cUbDlNf/uW3Zan2rMZfkQk6b9cc1MVbTd8n6RCwWv3C0lhQuLBW58BloPBqUKFt8Ox7YaHZXu5LtXJ2f+1/07kO3f1UrMtA28WnoWFByq+e29laFTmfiX7Bdfn3Fe5fli8arWVG/kTUlp0Y3+ly42cqMosoifFD6sNhj8MjTpBVWl8NaQsO9FJZMbnZwucQdUtO+XCkqrSIk12RZqq1Ws+6hpBV9VDc1ic44AqhSXFYiy6FoqLxA9ryKN4oVWA4L2cHK3lBR27C4YugDqdBIXXvMG+naBGmLku1cHJW4PUQ4b0Q5trq7zyyrNl9wAZGTBqe+NjkJf9gCqFJcXiIrOWlr3L4hK1PaYoUD1aNejS/FeNNH2KCp2mdxI4cYVB7e/K0bei0/A3AGiinoYku9eHeQVuxnfq5lmxztd4uamdnU0O55mmveB/INGR6Evm1NMqfnDXaz9tFRVGThjtT1mKFC82q3ZKj9z0R5nHq9snCmFqZgUGLFMVDc/cxjm9BfFRsOMfPdqrMqroKiqpiMteSWVNEyN0ex4mkmoA2V5Rkehr0B2qHncYsu8lkJ17VKgvFXaJXVFP120AGKVIqelpDCWUBtGfghJDaDgILx5fdhdqEb0u1frXUiqqnKisIK0eG3XRBSWV1LLLAX8fimhDpSGeXITCMUDdo2nE0OthYVWFI9oEqqF4uPid/cCvIrsCi6FuaT6MOpj0R7mzBF4oy/8tM3oqDQT0cnNT2fKNE1wcooqcNqsTAqwj9RvqSpYNdh1pbmoJN8K+UmB81ZGaHKj5cjNcba6ul70ZqaqKyVJekhqAKM/gcw2UJIDc/pp18PNYBGd3MS6HBzMK8WrBJ7g5JW48SgqU25ooUFkP/MqKlaznmTNGpfWLBYxcmAGWm+JDhVarrkpOExFfCNtjiVJoS4+E0avgGa9xZq+d8fAB5OgosjoyAIS0cnNxGuakRHv4sfcEiqqvH4dQ1VV8ksrKXF7eKRfS82v9vJLTbpTKpJYbWL9jK/0Sv4iJan8Ja1KCXgrARVFq51XkhQOohJg+H+h54Pi79vmwguXiVEcrRrWBllEJzcAE69tzkPXZ3GsoIwzZRffFaOqKqVuDycKyzmQW8KB3FIqqrz8rX8rXUZY8krcmq/h0ZTFap5RDb1Y7P7XupHM5dQeyGhpdBSSZD5WG1zzqFhonNxILLx/dwy81B22zg25JQgROL79e4kxDp4Y0JoZK/ZwpryK5Bgn8VF2rBYLqqpS6VEocXsorvDgURRinHYSohw80LeF7v1n8krcpMWZeOQmOkkMX8akGB2JfvwduZHM5/g2vqk1xOgoJMm8GveEcZvgy9mw/t9wajd8OAlWPCQqHDftBfU6i3U6dvNeeMvk5n/sNit/69+K3GI3b6w/SG5x9YeZitNuI85l5/6+lxAfFdxtuGfKqrize+OgPqZPohKh4kx4JzcWq/+1brRmxj5jwaDVqGjuPkpatr7ozSL1ZZYkAJwxYoqqy12wbT5snQP5B2DfCvEF4ryY3BhSm4odV8mNxN9TGovvDU58ZHLzG+nxLqbckAWIxbxa9IYKRGF5lTm3gVdzxkFlqdFRRI5IXG+jleIciE2tUV8u+TJLEhCdDN0nwRV/gZM74cBqOLRebBkvzxcJT/6B39/PYhUJTnqWmAbObA212kFKU9G6JwhkcnMBRic2AGWVHpJiTFy0zRUfcnOxUojRahjlyEZo2F2bY0lSJLFYoHY78XXlfeI9WZIjmm/mHxAFAAsOil5V+QehsgTyfxRfe5f/fBxHLNRqA7Xbi2SnVluR/OgwyiOTG5NTVZPX23DGiV9kSdKLVtvff9rGhiteD/w4khTpLBaIryW+mlz16//7ZeKTuxdOfQcnd0HOd6Ij+dGvxNfZY9kgtZlIctJbQGpzSL9EJEABkMmNFJja7eDH7Brc0MQJ2kWp+BW/XLihDS2Sm7LT4Iip8RZw+aOTJD+dL/FRvJD3A5zYASe/FX/m7BINhvP2iq9qtdrCn9cHFIZMbkzMDGt+LsoZD55yo6PQl6L410bBzCNuoUSL5OaHT6H5dTW+ufzRSZLGrDbIyBJf7YeKf1NV0Z08Zzfk7hEJzukDYq1OgGRyY2Klbg8xTpP/iJyxUBXmyY3qBZsfc8Ly8l8b3qrAmoWqKhz/hi+aT9EuJkmSAmexiD5vCXWgeW9ND23yT059VPeTKis191qR3MJynEoFRUUmLoNdoUBhIRRf5LWs8EINiiSaUnkllHvA6+PvS7kHavizq/4ZF5VcYOeZqv7vdazyLY5QV1oBVUCxn7vyTu6C+OaUlpXV+C5V5aXmft8FQfXzP3HihMGRSNLPqn8flYtUTraoWrfGDgHHjh2jfv36RochSZIkSZIfNm/eTJcuXc77/xGZ3CiKwvHjx4mPjzf3TiSdFRUVUb9+fY4ePUpCQoLR4RjGDK+D1+tl//79NGvWDJvt4nVYwokZXn+jmPm5V1VVsWnTJtq0aYPd/vtB/uLiYlq1asXu3buJj483IMLgks/XHBRFIScnh44dO57z97JaRCY3klBUVERiYiKFhYWmO7EGk3wdjBXJr38oP/dQjt0f8vmGlohvnClJkiRJUniRyY0kSZIkSWFFJjcRzOVy8fjjj+NymbezazDI18FYkfz6h/JzD+XY/SGfb2iRa24kSZIkSQorcuRGkiRJkqSwIpMbSZIkSZLCikxuJEmSJEkKKzK5kSRJkiQprMjkRpIkSZKksCKTmwhXXFwM/NxMNJLJ10Ayyvbt2+XvX4iItHNmqD7PiOwKLgmjRo3CYrHw5JNPUrduXVRVjdheW48++iiHDx+mTZs29O3blw4dOhgdUkR56qmnKCgooGXLlvTv35+0tDSjQwqagQMHUllZydy5c0lLS8NqDY1rzmeeeYbTp0/Ttm1bOnbsSKtWrYwOSXeRds4M5fNiaLyLJF1s3bqVw4cP89RTT3H48GEsFkvIZumBuPXWW8nOzqZz586sWbOGd955BwjdK5ZQM3jwYD766CMyMjK47777+Pjjj4HIeP0nTpxITk4Oy5YtIyMjI2QSmyFDhrB48WIsFguvvPIKf//735kzZ47RYekuks6ZoX5elCM3EUhRFKxW69luvzabjaeffpoHH3yQRo0aGR1eUG3atIm9e/eyZcsWXC4Xbdq0YdKkSUyePJnk5GSjwwt7jzzyCLm5uaxfvx6AVatW8d///pcbbrgBm81GamqqwRHqp7y8nLy8PF5++WVcLhfz589n165dpKam0qlTJ3r37m10iOe0b98+Dhw4wJo1a0hOTmb//v289957LFiwAI/Hw1133WV0iJqLtHNmOJwXQ+MyQdJU9dXhiBEjaNu2Lf369aOgoICXXnqJpUuXsmDBAoMjDB6Xy0VcXBw//PADAC1atMDr9TJ+/HgeeOABVqxYYXCE4cvj8ZCVlXX2inDatGmsXr2aXr16MWvWLB5//HFWrlxpcJT6iY6ORlVVcnNzmT17NlOmTCE2NpavvvqKf//736Z9HyYnJ5OQkMCePXtQVZVmzZoxcuRI+vfvz0cffUR2drbRIWou0s6Z4XBelMlNBLNaraxcuZKrr76aSZMmsX37dkaMGEFeXh4QOsOPgWjevDlWq5Vnn32W8ePH07ZtWwYOHMjtt9+Ox+NhyZIlFBcXR8RrEWx2u53bb7+djIwMTpw4QV5eHvv27eOBBx7gD3/4A5WVlXz00UcoimJ0qLpQVZWMjAwWLVpEXl4e77//Po899hgvvPACPXv2ZO3atVRUVJjudy8+Ph6Hw8Hrr79+dr1JZmYmgwcPJikpia+//trgCPUTKefMcDgvyuQmgl1//fU0aNAAh8OBoihs2bKFDh068N1333Hs2LGwXigHYqg5Pj6e5cuXM3LkSGrVqsWAAQOYOXMm/fv3Z9CgQezcuROPxxP2r4VRrFYrVquV2rVr88wzz9CkSRPcbjetWrWiY8eOfPnll1RWVhodpi4sFguPPfYYq1at4sknn+T48eMoikJmZiadOnVi165dpvvdUxSFqKgo3nzzTd59913uv//+s//XsGFDLr/8cj788MOw/ZlFwjkzXM6LMrmJIL/Nsj0eDx6Ph2HDhjF8+HBmzpzJww8/jMPhwG4P7+VYqqpitVrxeDwkJCTQs2dP4uLiOHr06Nnb7N+/H6fTaWCU4etcV3zVr3X1n4WFhTRp0sTUJ1B/VD/3qqoq0tPT+eSTT8jIyGDx4sWcOHECgEOHDhETE2OqK+Nfvmfq16/PqlWreP311xk7duzZuEtLS0lNTQ2bn1mknTPD6bwou4KHuUWLFlFSUsJll11Go0aNiI+PB8Dr9WKz2Vi9ejV33HEHjz76KOPGjQOgpKSEuLg4I8PWxflei+rtnIcPH6Z9+/ZceeWV1KlTh2XLlvHJJ5/QqVMngyMPD+d7/X/r+PHjLF26lMcee4zPP/+cdu3aBTlS7V3sfXjgwAFuueUWkpOTsVqtfPfddyxfvtzw373zxV29wHb//v3cfPPNJCYmYrVa2b17NytXrjQ87kBE2jkzXM+LMrkJYwMHDuTw4cM0atSIffv2cdNNN3HzzTfTrVu3s7cpLCzk1KlTNG/e/OwJKxxd7LWoqqrC4XBw5MgRXnjhBdLS0ujXrx8tW7Y0OPLwcLHXv/pEWlVVxRNPPMF7773HwoUL6dixo8GRB66mv3ulpaXs2rWL8vJymjRpQoMGDUIi7pKSEnbs2EFJSQktWrQI6d1DkXbODOvzoiqFpbVr16qtWrVSvV6vqqqqunLlSvXOO+9UR4wYoW7YsOF3t1cUJdghBo2vr0X17SRt+Pr6FxUVqcePHw92mLrw9bmbRajGHYhIO2eG+3kxdFNO6YISEhLIzMykrKwMRVHo06cPY8eOJSYmhsWLF3Ps2DEA5s+fT3Z2dtjMkZ+Lr69FKF+JmZEvr/+aNWuIj4+ndu3aBketDV9/98wiVOMORKSdM8P9vBha0Uo1lp6ezu7du5k7d+7ZX8quXbsydOhQduzYwZ49ewDYsWNH2Je6l6+FsXx5/TMzM40MVXOh+rsXqnEHItKec9g/X6OHjiT9LFu2TM3IyFDfeustVVV/HkYdO3asOmLECFVVVdXtdhsWXzDJ18JYkfz6h+pzD9W4AxFpzzmcn2/o712TzmvAgAGcPHmSKVOmUFZWdrYselpaGmVlZQAhsaVPC/K1MFYkv/6h+txDNe5ARNpzDuvna3R2JemrqqpKXbhwoRoTE6PedNNN6i233KImJCSo27dvNzq0oJOvhbEi+fUP1eceqnEHItKec7g+X7kVPELs2bOHTZs2UV5ezrXXXkuLFi2MDskw8rUwViS//qH63EM17kBE2nMOt+crkxtJkiRJksKK3C0lSZIkSVJYkcmNJEmSJElhRSY3kiRJkiSFFZncSJIkSZIUVmRyI0mSJElSWJHJjSRJkiRJYUUmN5IkSZIkhRWZ3EiSJEmSFFZkciNJkiRJUliRyY3kt9mzZ9OoUSOioqLo1q0bmzdvNjokKYKtW7eOm266iTp16mCxWFi2bJnRIUkRbsaMGXTp0oX4+HgyMjIYNGgQe/fuNTqsiCCTG8kvS5YsYfLkyTz++ONs27aN9u3b07dvX06dOmV0aFKEKi0tpX379syePdvoUCQJgOzsbCZMmMCXX37Jp59+SlVVFX369KG0tNTo0MKe7C0l+aVbt2506dKFWbNmAaAoCvXr1+cvf/kLDz/8sMHRSZHOYrGwdOlSBg0aZHQoknRWbm4uGRkZZGdn07NnT6PDCWty5EbyWWVlJVu3bqV3795n/81qtdK7d282bdpkYGSSJEnmVVhYCEBKSorBkYQ/mdxIPsvLy8Pr9ZKZmfmrf8/MzOTkyZMGRSVJkmReiqJw77330r17d9q0aWN0OGHPbnQAkiRJkhTuJkyYwK5du1i/fr3RoUQEmdxIPktLS8Nms5GTk/Orf8/JyaFWrVoGRSVJkmROEydO5KOPPmLdunXUq1fP6HAigpyWknzmdDq59NJLWb169dl/UxSF1atXc/nllxsYmSRJknmoqsrEiRNZunQpa9asoXHjxkaHFDHkyI3kl8mTJzNy5Eg6d+5M165dee655ygtLWX06NFGhyZFqJKSEvbv33/27wcPHmT79u2kpKTQoEEDAyOTItWECRNYuHAh77//PvHx8WfXJCYmJhIdHW1wdOFNbgWX/DZr1iyeeeYZTp48SYcOHfjPf/5Dt27djA5LilBr166lV69ev/v3kSNHMmfOnOAHJEU8i8Vyzn9/8803GTVqVHCDiTAyuZEkSZIkKazINTeSJEmSJIUVmdxIkiRJkhRWZHIjSZIkSVJYkcmNJEmSJElhRSY3kiRJkiSFFZncSJIkSZIUVmRyI0mSJElSWJHJjSRJkiRJYUUmN5IkSZIkhRWZ3EiSJEmSFFZkciNJkiRJUliRyY0kSZIkSWHl/wOxJa8DbqvbuwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)\n", + "\n", + "# Creating mock dataset AB\n", + "nlive = 100\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", + "samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012logLlogL_birthnlive
weights
08.606047e-1440.9579190.0102780.764609-333.867790-inf200
11.189399e-1370.9360970.0125350.315644-319.728712-inf199
21.393459e-1270.9449670.0662070.126178-296.544520-inf198
36.461298e-1250.9288940.0614960.943672-290.405309-inf197
45.659704e-1210.9991000.1524020.520428-281.327427-inf196
........................
10492.248341e-010.0859970.2912880.501905-0.013805-0.3192055
10502.249385e-010.1093100.3121150.532662-0.013340-0.9395714
10512.257491e-010.0951580.2899410.498126-0.009743-0.9395713
10522.263745e-010.1079050.3036120.488828-0.006977-0.5518992
10532.273513e-010.1053650.3069660.497583-0.002671-10.8055251
\n", + "

1054 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 logL logL_birth \\\n", + " weights \n", + "0 8.606047e-144 0.957919 0.010278 0.764609 -333.867790 -inf \n", + "1 1.189399e-137 0.936097 0.012535 0.315644 -319.728712 -inf \n", + "2 1.393459e-127 0.944967 0.066207 0.126178 -296.544520 -inf \n", + "3 6.461298e-125 0.928894 0.061496 0.943672 -290.405309 -inf \n", + "4 5.659704e-121 0.999100 0.152402 0.520428 -281.327427 -inf \n", + "... ... ... ... ... ... \n", + "1049 2.248341e-01 0.085997 0.291288 0.501905 -0.013805 -0.319205 \n", + "1050 2.249385e-01 0.109310 0.312115 0.532662 -0.013340 -0.939571 \n", + "1051 2.257491e-01 0.095158 0.289941 0.498126 -0.009743 -0.939571 \n", + "1052 2.263745e-01 0.107905 0.303612 0.488828 -0.006977 -0.551899 \n", + "1053 2.273513e-01 0.105365 0.306966 0.497583 -0.002671 -10.805525 \n", + "\n", + " nlive \n", + " weights \n", + "0 8.606047e-144 200 \n", + "1 1.189399e-137 199 \n", + "2 1.393459e-127 198 \n", + "3 6.461298e-125 197 \n", + "4 5.659704e-121 196 \n", + "... ... \n", + "1049 2.248341e-01 5 \n", + "1050 2.249385e-01 4 \n", + "1051 2.257491e-01 3 \n", + "1052 2.263745e-01 2 \n", + "1053 2.273513e-01 1 \n", + "\n", + "[1054 rows x 6 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samplesA" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'samplesAB' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samplesAB\n", + "\u001b[0;31mNameError\u001b[0m: name 'samplesAB' is not defined" + ] + } + ], + "source": [ + "samplesAB" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 38\u001b[0m \u001b[39m# Creating mock dataset AB\u001b[39;00m\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[0;32m---> 40\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 41\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)\n", + "\n", + "# Creating mock dataset AB\n", + "nlive = 100\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.10526316, -1.06578947, -0. ],\n", + " [-1.70526316, 1.31578947, -0. ],\n", + " [ 0. , 0. , 0.3 ]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0, 1], [0, 1], [0, 1]]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bounds" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " + ] + } + ], + "source": [ + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.10526316, -1.06578947, -0. ],\n", + " [-1.70526316, 1.31578947, -0. ],\n", + " [ 0. , 0. , 0.3 ]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m [[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]]\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "boundsAB = [[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m [[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]]\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", + "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:517\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m__init__.pxd:741\u001b[0m, in \u001b[0;36mnumpy.PyArray_MultiIterNew3\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3)." + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "boundsAB = [[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[[0, 1], [0, 1], [0, 1]], [[0, 1], [0, 1], [0, 1]], [[0, 1], [0, 1], [0, 1]]]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "boundsAB" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]])\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", + "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:517\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m__init__.pxd:741\u001b[0m, in \u001b[0;36mnumpy.PyArray_MultiIterNew3\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3)." + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]])\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.10526316, -1.06578947, -0. ],\n", + " [-1.70526316, 1.31578947, -0. ],\n", + " [ 0. , 0. , 0.3 ]])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nlive" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 526.31578947, -473.68421053, -0. ],\n", + " [-473.68421053, 526.31578947, -0. ],\n", + " [ 0. , 0. , 10. ]])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA_inv" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.1, 0.3, 0.5]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanA" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 526.31578947, -473.68421053, -0. ],\n", + " [-473.68421053, 526.31578947, -0. ],\n", + " [ 0. , 0. , 10. ]])" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covB_inv" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.7, 0.2, 0.1]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanB" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 52.63157895, -142.10526316, -0. ],\n", + " [ -47.36842105, 157.89473684, -0. ],\n", + " [ 0. , 0. , 5. ]])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA_inv*meanA" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[39m.\u001b[39;49masmatrix(covA_inv)\u001b[39m*\u001b[39;49mmeanA\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/matrixlib/defmatrix.py:218\u001b[0m, in \u001b[0;36mmatrix.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__mul__\u001b[39m(\u001b[39mself\u001b[39m, other):\n\u001b[1;32m 216\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, (N\u001b[39m.\u001b[39mndarray, \u001b[39mlist\u001b[39m, \u001b[39mtuple\u001b[39m)) :\n\u001b[1;32m 217\u001b[0m \u001b[39m# This promotes 1-D vectors to row vectors\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39;49mdot(\u001b[39mself\u001b[39;49m, asmatrix(other))\n\u001b[1;32m 219\u001b[0m \u001b[39mif\u001b[39;00m isscalar(other) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39m(other, \u001b[39m'\u001b[39m\u001b[39m__rmul__\u001b[39m\u001b[39m'\u001b[39m) :\n\u001b[1;32m 220\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39mdot(\u001b[39mself\u001b[39m, other)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)" + ] + } + ], + "source": [ + "np.asmatrix(covA_inv)*meanA" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[39m.\u001b[39;49masmatrix(covA_inv)\u001b[39m*\u001b[39;49mnp\u001b[39m.\u001b[39;49masmatrix(meanA)\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/matrixlib/defmatrix.py:218\u001b[0m, in \u001b[0;36mmatrix.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__mul__\u001b[39m(\u001b[39mself\u001b[39m, other):\n\u001b[1;32m 216\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, (N\u001b[39m.\u001b[39mndarray, \u001b[39mlist\u001b[39m, \u001b[39mtuple\u001b[39m)) :\n\u001b[1;32m 217\u001b[0m \u001b[39m# This promotes 1-D vectors to row vectors\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39;49mdot(\u001b[39mself\u001b[39;49m, asmatrix(other))\n\u001b[1;32m 219\u001b[0m \u001b[39mif\u001b[39;00m isscalar(other) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39m(other, \u001b[39m'\u001b[39m\u001b[39m__rmul__\u001b[39m\u001b[39m'\u001b[39m) :\n\u001b[1;32m 220\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39mdot(\u001b[39mself\u001b[39m, other)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)" + ] + } + ], + "source": [ + "np.asmatrix(covA_inv)*np.asmatrix(meanA)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[-89.47368421],\n", + " [110.52631579],\n", + " [ 5. ]])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.asmatrix(covA_inv)*(np.asmatrix(meanA).transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.01 , 0.009, 0. ],\n", + " [0.009, 0.01 , 0. ],\n", + " [0. , 0. , 0.1 ]])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.asmatrix(covA)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 526.31578947, -473.68421053, -0. ],\n", + " [-473.68421053, 526.31578947, -0. ],\n", + " [ 0. , 0. , 10. ]])" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA_inv" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.01 , 0.009, 0. ],\n", + " [0.009, 0.01 , 0. ],\n", + " [0. , 0. , 0.1 ]])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.asmatrix(covA).transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'reshape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[47], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA_inv\u001b[39m*\u001b[39mmeanA\u001b[39m.\u001b[39;49mreshape(\u001b[39m3\u001b[39m,\u001b[39m1\u001b[39m)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'reshape'" + ] + } + ], + "source": [ + "covA_inv*meanA.reshape(3,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[-89.47368421],\n", + " [110.52631579],\n", + " [ 5. ]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA_inv*np.asmatrix(meanA).reshape(3,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 526.31578947, -473.68421053, -0. ],\n", + " [-473.68421053, 526.31578947, -0. ],\n", + " [ 0. , 0. , 10. ]])" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA_inv" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.1, 0.3, 0.5]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanA" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-89.30000000000001" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "526 *0.1-473*0.3" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "ename": "LinAlgError", + "evalue": "Last 2 dimensions of the array must be square", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.4 ],\n", + " [0.25],\n", + " [0.3 ]])" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "meanAB = meanAB.transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "ename": "LinAlgError", + "evalue": "Last 2 dimensions of the array must be square", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 43\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = meanAB.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = meanAB.transpose().flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = meanAB.transpose().flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = meanAB.transpose().flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "ename": "LinAlgError", + "evalue": "Last 2 dimensions of the array must be square", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 43\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0, 1], [0, 1], [0, 1]]" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bounds" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "ename": "LinAlgError", + "evalue": "Last 2 dimensions of the array must be square", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m meanAB\u001b[39m=\u001b[39m[\u001b[39m0.4\u001b[39m , \u001b[39m0.25\u001b[39m, \u001b[39m0.3\u001b[39m ]\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=[0.4 , 0.25, 0.3 ]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Output size (200, 1) is not compatible with broadcast dimensions of inputs (200, 3).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[39m#meanAB=[0.4 , 0.25, 0.3 ]\u001b[39;00m\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB,bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", + "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:518\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m_common.pyx:245\u001b[0m, in \u001b[0;36mnumpy.random._common.validate_output_shape\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Output size (200, 1) is not compatible with broadcast dimensions of inputs (200, 3)." + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "#meanAB=[0.4 , 0.25, 0.3 ]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0, 1], [0, 1], [0, 1]]" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bounds" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB.ndim" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "ename": "LinAlgError", + "evalue": "1-dimensional array given. Array must be at least two-dimensional", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m meanAB\u001b[39m=\u001b[39m[\u001b[39m0.4\u001b[39m , \u001b[39m0.25\u001b[39m, \u001b[39m0.3\u001b[39m ]\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB\u001b[39m.\u001b[39;49mflatten(),bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:532\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 471\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 472\u001b[0m \u001b[39mCompute the (multiplicative) inverse of a matrix.\u001b[39;00m\n\u001b[1;32m 473\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 529\u001b[0m \n\u001b[1;32m 530\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[0;32m--> 532\u001b[0m _assert_stacked_2d(a)\n\u001b[1;32m 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n", + "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:183\u001b[0m, in \u001b[0;36m_assert_stacked_2d\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 181\u001b[0m \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m arrays:\n\u001b[1;32m 182\u001b[0m \u001b[39mif\u001b[39;00m a\u001b[39m.\u001b[39mndim \u001b[39m<\u001b[39m \u001b[39m2\u001b[39m:\n\u001b[0;32m--> 183\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39m%d\u001b[39;00m\u001b[39m-dimensional array given. Array must be \u001b[39m\u001b[39m'\u001b[39m\n\u001b[1;32m 184\u001b[0m \u001b[39m'\u001b[39m\u001b[39mat least two-dimensional\u001b[39m\u001b[39m'\u001b[39m \u001b[39m%\u001b[39m a\u001b[39m.\u001b[39mndim)\n", + "\u001b[0;31mLinAlgError\u001b[0m: 1-dimensional array given. Array must be at least two-dimensional" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=[0.4 , 0.25, 0.3 ]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB.flatten(),bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'cosA' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[79], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m cosA\n", + "\u001b[0;31mNameError\u001b[0m: name 'cosA' is not defined" + ] + } + ], + "source": [ + "cosA" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.01, 0.009, 0], [0.009, 0.01, 0], [0, 0, 0.1]]" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covA" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=[0.4 , 0.25, 0.3]\n", + "covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012logLlogL_birthnlive
weights
01.467395e-2620.0182080.9681070.512536-608.317803-inf200
11.662490e-2180.0014470.8536330.898664-506.879231-inf199
24.384759e-2180.0103750.8645090.091090-505.909413-inf198
35.861166e-2100.1204410.9487450.935246-487.198518-inf197
42.067021e-2070.0138110.8431520.044832-481.333003-inf196
........................
12072.205249e-010.3978760.2411900.315647-0.027948-11.6005595
12082.209846e-010.4125410.2577400.281244-0.025866-0.5711134
12092.239392e-010.3943770.2458820.270074-0.012584-0.3353583
12102.243973e-010.3952610.2484960.279307-0.010541-0.3353582
12112.247963e-010.3928820.2411490.307434-0.008765-0.3353581
\n", + "

1212 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 logL logL_birth \\\n", + " weights \n", + "0 1.467395e-262 0.018208 0.968107 0.512536 -608.317803 -inf \n", + "1 1.662490e-218 0.001447 0.853633 0.898664 -506.879231 -inf \n", + "2 4.384759e-218 0.010375 0.864509 0.091090 -505.909413 -inf \n", + "3 5.861166e-210 0.120441 0.948745 0.935246 -487.198518 -inf \n", + "4 2.067021e-207 0.013811 0.843152 0.044832 -481.333003 -inf \n", + "... ... ... ... ... ... \n", + "1207 2.205249e-01 0.397876 0.241190 0.315647 -0.027948 -11.600559 \n", + "1208 2.209846e-01 0.412541 0.257740 0.281244 -0.025866 -0.571113 \n", + "1209 2.239392e-01 0.394377 0.245882 0.270074 -0.012584 -0.335358 \n", + "1210 2.243973e-01 0.395261 0.248496 0.279307 -0.010541 -0.335358 \n", + "1211 2.247963e-01 0.392882 0.241149 0.307434 -0.008765 -0.335358 \n", + "\n", + " nlive \n", + " weights \n", + "0 1.467395e-262 200 \n", + "1 1.662490e-218 199 \n", + "2 4.384759e-218 198 \n", + "3 5.861166e-210 197 \n", + "4 2.067021e-207 196 \n", + "... ... \n", + "1207 2.205249e-01 5 \n", + "1208 2.209846e-01 4 \n", + "1209 2.239392e-01 3 \n", + "1210 2.243973e-01 2 \n", + "1211 2.247963e-01 1 \n", + "\n", + "[1212 rows x 6 columns]" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samplesAB" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.005, 0.0045, 0.0], [0.0045, 0.005, 0.0], [0.0, 0.0, 0.05]]" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.4 , 0.25, 0.3 ]])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "a = meanAB.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]]" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'strip'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[89], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m a\u001b[39m.\u001b[39;49mstrip()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'strip'" + ] + } + ], + "source": [ + "a.strip()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "a = meanAB.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.4 , 0.25, 0.3 ])" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "a = meanAB.flatten().tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "b = covAB.flatten().tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.004999999999999997,\n", + " 0.004499999999999996,\n", + " 0.0,\n", + " 0.004499999999999996,\n", + " 0.0049999999999999975,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.05]" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "b = covAB.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", + " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", + " [0.0, 0.0, 0.05]]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'reshape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[101], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m b\u001b[39m.\u001b[39;49mreshape(\u001b[39m1\u001b[39m,\u001b[39m3\u001b[39m)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'reshape'" + ] + } + ], + "source": [ + "b.reshape(1,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "cannot reshape array of size 9 into shape (1,3)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[102], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m b \u001b[39m=\u001b[39m covAB\u001b[39m.\u001b[39;49mreshape(\u001b[39m1\u001b[39;49m,\u001b[39m3\u001b[39;49m)\u001b[39m.\u001b[39mtolist()\n", + "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 9 into shape (1,3)" + ] + } + ], + "source": [ + "b = covAB.reshape(1,3).tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "b = covAB.reshape(1,9).tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.004999999999999997,\n", + " 0.004499999999999996,\n", + " 0.0,\n", + " 0.004499999999999996,\n", + " 0.0049999999999999975,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.05]]" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'ndim'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[105], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA\u001b[39m.\u001b[39;49mndim\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'ndim'" + ] + } + ], + "source": [ + "covA.ndim" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'ndim'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[106], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA\u001b[39m.\u001b[39;49mndim()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'ndim'" + ] + } + ], + "source": [ + "covA.ndim()" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.005 , 0.0045, 0. ],\n", + " [0.0045, 0.005 , 0. ],\n", + " [0. , 0. , 0.05 ]])" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "b=covAB.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.005 , 0.0045, 0. , 0.0045, 0.005 , 0. , 0. , 0. ,\n", + " 0.05 ])" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.005 , 0.0045, 0. ])" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", + " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", + " [0.0, 0.0, 0.05]]" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "covAB=covAB.tolist()\n", + "covAB=[covAB[0],covAB[1],covAB[2]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", + " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", + " [0.0, 0.0, 0.05]]" + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "covAB = linalg.inv(covAB_inv)" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'flatten'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m \u001b[39m#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\u001b[39;00m\n\u001b[1;32m 44\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "covAB=covAB.tolist()\n", + "#covAB=[covAB[0],covAB[1],covAB[2]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'flatten'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m \u001b[39m#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\u001b[39;00m\n\u001b[1;32m 44\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "covAB=covAB.tolist()\n", + "covAB=[covAB[0],covAB[1],covAB[2]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meanAB" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", + "covAB=covAB.tolist()\n", + "#covAB=[covAB[0],covAB[1],covAB[2]]\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "#samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", + " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", + " [0.0, 0.0, 0.05]]" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "covAB" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'flatten'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 44\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" + ] + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB=meanAB.flatten().tolist()\n", + "covAB=covAB.tolist()\n", + "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", + "samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG5CAYAAAByehWbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADkl0lEQVR4nOydd3hUVf6H35lJ7wEChBBC7x0pKiICAoqCKC7iYlvsu7rLWpC1reUntl12VSy74oqiYseCCgqCIlWq9B4SakJ6m0z7/XFyZ24m03uS8z5PnpnM3Dn3zMydez73WzUWi8WCRCKRSCQSSRNBG+4JSCQSiUQikQQSKW4kEolEIpE0KaS4kUgkEolE0qSQ4kYikUgkEkmTQoobiUQikUgkTQopbiQSiUQikTQppLiRSCQSiUTSpJDiRiKRSCQSSZMiKtwTCAdGo5Ft27bRpk0btFqp7yThx2g0smvXLs4//3yio6PDPR2JBJPJxKFDh+jatSs6nS7c05FIALBYLJSXl9OuXTuX63ezFDfbtm1j2LBh4Z6GRCKRSCQSH8jLy6N9+/ZOn2+W4qZNmzYAbNq0iczMzDDPRiKBAwcOMHbsWPLy8khJSQn3dCQS8vPz6dOnjzwmJRFFWVkZ2dnZJCcnu9yuWYobxZSVmZnpUvlJJKGivLwcgJSUFLmQSCIC5TiUx6QkEtFoNC6flwEnEolEIpFImhRS3EgkEonC5oUwv6+4lbhHfl6SCEWKG4lEIlFYOx9K88StxD3y85JEKFLcSCQSicLI2ZCaLW4l7pGflyRCaZYBxRKJROKQobPEn8Qz5OcliVCk5UYikTQ9ZCxI6JGfuSSCkOJGIpE0DrxZPGUsSGjZvBC+eUB+5pKIQYobL/n5YAFTXlnLRc+v4j8/HcZstoR7Ss0Tox5WPAL/7A3/HQuHV4V7RpJg441gkbEgoWXtfLCYQKOTn7kkIpDixgv2nCzjtnd+ZUd+KXlF1TzzzT5eW3M43NNqnnw7B9a9DGUn4MSv8N7v4MiacM9K4guKReaTWQ0tM2prjTeCZegsmL1L3JeukuCjfDeXvxCcGBx/XF7hem0k7qcZIcWNh1gsFh74ZAc1BjPDOrXgzou7APCPFfvZc7IszLNrZhxeBVv+B2hg4rPQ8wowG+CTW6CqKNyzk3iLYpHZ/XlDy4zaWqMIlqGzPF8MpHsqNKi/m0Bg//368z2G67WRuJ9mhBQ3HrJq31l2nywjMUbHa78fzJyJPbisb1vMFpj/w4FwT695sfZf4nbYbTDiLrhmIWT0gqpz8OP/hXVqEh9Qrvr7TG1omXFmrfF0MZDuqcaJ/ffrz/cYrtdG4n6aERqLxdLsgkby8/PJzs5221VUze/eWM+mo0XccXFn5l7WC4BDZysYP38NZgt8++eL6JUp+68EndO74PULhW//z9shrYN4/OjPsOgK8fg9v0KLzmGdprfs3buX3r17U1paKvv4KGxeKBa3kbMbWgRcPScJCMp50uNjMpDfifx+JU4oKysjNTXV7XEpLTcecLSwkk1Hi9Bq4JYLOlkf79o6iYl92wLw3sbccE2vebHrU3Hb4zKbsAHodBF0HSeCGn/+R3jmJgks9lfvaleFLy4qSXBxZ03z5nuSMVMSP5HixgM+2ZIHwKjuGbRNjav33MzhOQAs3XaSSr0x5HNrVlgssPdLcb/P1IbPX/yQuN2xBErzQzcvSUN8ERyfzIInWohbaGiqdyR2nusIy+6T8QqRgCvXiqep4urjxtVrPDm+pOht1khx4waLxcLSbScBmDakoQvr/C4t6dgygQq9kRV7Tod6es2Lgv1w7hDoYqDb+IbPZw+FjheB2QgbXgv9/CQ21ELE00Vm9+fC8rbrk4bWGXAsdqqLAQugAX2FXMjCiaugYnep4soxsuopcdx88wCsfMr5azyJuQpEkK4USI0WKW7csC2vhBMl1STE6Bjbs02D5zUaDVcNygKwiiBJkDi8Utx2GgVxTnytF9wrbre8DdUloZiVxBFqIeKp0Mnsb7vvaEFyJHbi0yEuHeLSoKbYOzElCR3uUsWVY8SCEDMWE9SUiO+2z1Tb92o/nqsAXPttfDkuZBZTo0WKGzd8veMUAON6tSE+RudwmykDhbhZe6iQwgp9yObW7Di2Vtx2GuV8m26XQuveUFsBv74VmnlJGqIWIp4KncpCcetpIbihs2DOMXjoGIx91PE+JJGBu1Rx5RgZ+6gQQBodYIHYJMjb2PD79CT13H4bX46LUGQxSTEeFKS4cYHZbOGb34S4mdQ/0+l2nVol0i8rFZPZwvd7zoRqes0LswmO/SLudxzpfDuNxma92fg6GKqDPzeJa+yFTny6cCEtf0QsNiufEif22gpxpa6+undV4M/VPmRabWTg68IdlyKOhZGz/f8+lTlkD/d+nEDX71HPJxA1fCROkeLGBdvyijldVkNSbBQXd89wua2SNfXtLhl3ExRO/wb6UohNgbYDXG/b9xpIaQ8VZ2Dru6GZn8Q9SnqvvkK4kIxV4nENQuBUFwtXhBrlxL/rU3G76in3+wnGgiTxDU9dkiufsgldJZYqNikw36Eyh7yNzo8Lb0SYv5YWZT4rn/JddEnc0ijETbhK8Xy9U1htLu3dhrhoxy4phcvqxM26Q4WUVhmCPrdmR94mcZs9HHRRrreNioGRfxH3184HQ01QpyZxgL3F5ZNZtswXs/r3oQGDHkyKO9dSPxtKseZo677z6mJbJo005UcGrr4LZy5JezSqW+U12cPFuIrwcVQSwJO5eGL58cZ64q2lxX5O2cPFG60pcS66PLVYSpwS8eLmkUce4cYbb+S5555j+/btPo2h1+spKyuz/pWXl7t9jclssYqbSf2cu6QUOmck0aNNMkazhdUHzvo0T4kLTmwRt+3P82z7QTdAShaUn4RN/wnevAJMWVkZen0jituyT919riM829HmclIsLkomFJq6eApAGw1YhAVHFwvRCeL57OHieeUKXoPIgFNYO1+a8oOMXq+3nifdHpOe1CMCYbGLTnCc1dZlrDguuoy1vUaJtdHguiSAo7l884BtH55Y8uwFlTMxsXmhqISuPk7dYT/fvI2IyGmL8/gyVy1JJB4R0eLm2muvZc2aNZx33nmsWrWKTz75BPDekjNv3jxSU1Otf71793b7mnWHCyko15OeEM0oNy4phXG9WwOwQsbdBB5F3LQb7Nn20XFwyd/E/Z9fhMpzwZlXgMnOzmbevHnhnobnOHIn1BSDsS7WKTpeLBqZ/cWJXBtVJ3IAXbRtnBYdIaElYKk7+WNbcCxgTfeOD1AchsQl8+bNs54nnR6TzmJZ7N0uijuyphiMenG78imbEN68UHznFpPtuwfbdzzmUeclAewtHNnDbdlW3lhWlGrIjoKX1aydD4Yq6h2n7rA/VkfOFtbI+HTn2WOuWpJIPCJi2y+sX7+eO+64g82bNxMbG8vKlSu59957+fnnn0lPT0ej0bgfpA69Xl/vyuPEiRP07t3bZfuFv364nc+2nWDmiA48fVU/j/az7XgxU19dR1JsFFsfvZSYqIjWjo2HmlJ4tq4a8QOHIbGVZ68zm+A/F4t4nUEzYcqC4M3RT5T2C3l5eWRkZBAbGxvuKXnGcx2FoIlPF4vQsvsAi7DKWMzi5JxzgbiSViw3ODrlaIQQMlSLmKlpqivnT2aJK9g+U+s/Lgkaer2eI0eOuD4m5/cVQiA122adAZtYqK0Qx4baLZU9XIiCqnN1IgGbxUT5jnMu8Lz1gnL8KceVel+u2nYo81C7y+xfCw3H2bxQxH1ZEJldoYjrctSKohm3p/C0/YKb4IXwERsbS1JSEgcPHqRv37706NEDk8nE3XffTVZWFuPGjeOyyy7zeCz1D7OszHUX79IqA8vqsqSuGexZ7ymAAe3TaJUUS2GFnk1HixjZzcNFWOKak9vEbVqO58IGQKuDy/8Bb42HbYuh/3TXaeQRQEpKSuMQNorgyOwPMUn1T7Irn6oLDLbAoZU2l5RGByntxELSAIttsdv9uVjglPEcXdVLgkpsbCzJycmAi2PSXggoDJ1la4uhXoDVi/CzHeu+b41tHOU7treeqMWIWpQMnWXTyVHxkNjS8b7UKEKm7KTY3zcP2Kqd27/22Y7CyrTsvvrvKxBiwhNxYi8Sv3nANg+1q6uZiRtPiVjTQrdu3dBqtcyfP5+7776bfv36MWXKFGbOnInRaOTDDz+kvLw8KMHGn27NR2800yszhYHZaR6/TqvVcEkP4cJatU/G3QSMUzvFbbuB3r+2w3AYcou4/8WfhL9f4h+bF4oqwhaTEJ61FZC7TlzJg8hyUVad2gqbsLn8BbGoOCI6QVh/0NgWHSWOR19hc0dJIgcl7d6+wJ76eUexLpsXCkNLXDpM+kfD9H1HQchK7NauT+oLH6W+0YSnPetFpXb3KO4rZ1lUVueAJfDFIb2psKwubKjMw9vfRKQG4AdxXhEpbsxmM8nJyXzzzTfcdNNNtG3blsmTJ/Pcc89xxRVXcNVVV/Hbb79hNBq9ck95gsFk5q1fjgLw++EdvB5/bC8Rd/PjfiluAsbp38RtW8/cgw249ElxQivJhR8eD9y8miv2J+Tq4vqBj+pAS7NBCBcltkBZVPpOE4sbABoY/7QoyDfpH7YTuVKCv6ZYWIfkFWrk4Utgt6NUb7UQUt9XLLXq87A6CNfbQn3K9tMWimPSVRDxmEdtFbADURxSvZB7U2FZKWyoFnze/iYiNQA/iPOKOHFjsVjQarUYjUZSUlIYNWoUSUlJ5OXZTNmHDh0iJiYmKPv/cvtJ8ouraZUU47CXlDtGdssgWqfhaGElRwqklSAgnKm7Imvjo7iJS4Epr4j7m9+Eoz8FZl5NGU/Se9sNQsTKJNgChhW3gRpDte2Kc9pCeLxI3Haty5Dpe039RU6pUGsxNcyUkUQWnizS9seSN20RFKutxeI+CNfT+SgoFiNnGUnqCti+FodUvzdlIV/1lGfxMs4Eny/ziNQA/CDOKyICij/44AMqKioYMWIEHTt2tPp6LRYLGo2G3NxcBgwYwMiRI2nXrh1Lly7lu+++Y/BgDzNn7MjPzyc7O7tBQHFVrZFx/1jDydIaHpzYg7tHd/Vp/N+/uYFfDp3jsSt684eRnXwaQ1KHUQ/PtBOpwLN3Q6r3gtPK17NFS4b0TnD3ehHAGiEoAcXuguRChhJvEJcuTu6OYgTUAaVQl7arE0Ln1E5RcLGmWAQXmw0NA0+V1ysuK3AdzCkJKcp50qdjcvNCYXVT4sdriht+/wr2x4H6+/YnmNxVXIt9PItGJ/ahjufxFfV+HQUrK0UsnX0eEpd4GlAcdsvNlClTeO6551i2bBnTp0/n6aefZuNGceWn0WgwGAzk5OSwc+dO+vbtS/fu3VmzZo3PwsYV/1xxgJOlNbRPj+cPF/ouSkZ3F66p1QcKAjW15kvBPiFs4tJE3Rp/GPcEJLeD4qOw7pWATK/JongBakqE0FG6NS/7K/xfZn3TevbwulgmjS0OR2l8CCLlW7Hq2Jvm1bEE9kGSsspwZOPK4qK4TpQ6Ra6uztXHwbL74OlMkQVlb+lztu/NC8UxqrxGPQd39XAs2Bp6KoHM6ho5zt6ju/eujKNOk1eOaXUfNF+J1BiaCCKs4mbNmjUcOnSIrVu3snTpUv71r39RWFjIggULWLduHQDR0aIWRocOHXjmmWe4//776dWrV8Dn8tWOk7y5VsTaPDG5j9uKxK64pKcIKt5w5BxVtUY3W0tccrruyqZtv/p+d1+IS4HxT4n7P/8Dyk75N15TZfNCYTEDwFK3SJXYnjdUCbGjLrZWU9xwHG1U3aKFWLh2f96wLo66jkekms4ljnEmHjYvtNWVik6oX6fGkRBRuyKVoo7Vxa7jMFbUFYlc8Uh9IaV+jSv3lzqeRe3usQ/cVapq28/FlXBSj+MoWDkQwj1SY2giiLCKm5SUFNq0aUNVVRVms5nx48dzxx13kJCQwJIlS8jPzwfg3XffZc2aNWi1gZ+uxWLhnfXH+MuH2wGYNbITY3u18WvMLhlJtE+Pp9ZoZsORcwGYZTOmYK+4be2+8KJH9L1GXE0Zq2HtPwMzZlNj1VO2tGwrFohKqPevlZGz66oLA5q632h0ggh4tJggOtZ2sq8pEa4uk16cnA+vdBxXIIl8nInRtfNtfcMSWtb/PtVCRN0nTBE48eniOHOUCaQWJ0pDXEN1/aJ46te4CjZ2dKwpc1C7kJRMP6Vg4HMdhWWp6pwt0Nge+3GCgbPPXlp0rIRV3GRkZLBnzx4WLVpkFS7Dhg1j+vTp7Nixg3379gGwY8cOWrUKfM2YT7efZtJLa3nsi92YzBauGdyev13uv1VIo9Ewui4l/Md90jXlF2fFMUDrnoEZT6OBSx4W97e87Tw1ubmhPik6jMLTiHTbvtPEyb5FR1tl2BWP2Kq2Wizw91J4+JS4Ko5PF+P1mYo1AEODaLcATvYlaRSoU8HVPZCciQ2o+7/OAltdUt/9s3a+aL8QZVdTRzk21T2m+l5TPxj9oWMi+NdVzRilT5krweEocFeJA1KyvIxV4nh31djTlVC3d6n50kPK2fjSomMl7AHFX3zxBbfffjvz58/n+uuvtwYR33nnnVRVVfHOO+9QW1sb0OwoJVAu+y8foY1NIDFGx/0TenDT+R3RagOTWr5y7xlmLfqV9unx/PzgJQFPWW82/LMPlOXDLd9BzvmBGdNigbcmQt4GuOh+sQiHmbAHFKuDOvtMFcX3lEJ8Ctrouh5PFmxCRWdrp6BsE5tkq+CqnGzj0+tcW3VZL13HyqrDEY5HAcXq48Zi8ixIVnH3WEziuIhJUlUsViKQsY2lVCGOThCWIGcBv64CiO2rKXtb4VcJkDbpwWQQv4N2A6Gy0HXAsru5QP2ilr4GGTuqvNxELaCNJqB48uTJPPnkk8yZM4c333zTKgJatWpltdYEK+17QFYyD1/ei7VzxnDLhZ0CJmwAzu/SkpgoLfnF1Rw6K1PCfaKmTAgbCJzlBoT15vw/ivu/vmUzcTdnlNo0SpyAtRCf6jdhNmATO3UiJbO/7XmNVixUSn+plU817A+l0dmEjaw63PhRF8WLT3fcFNPeVaJ221gQi7vyG4yOb2j1UQ45XazrQn2OelrZz9OT5puO5qzUW9LFQnJbMalTO21jfDILnmghbt2Nb1+wUGkk66yJpico+3NWkLAZEnZxo9FomDVrFs8//zx//vOfmTx5MtOmTePll1/mpptuCuq+X7uuL7eN6kx6YuDFU0JMFCM6twRktWKfKdgvbpPa1lWvDSA9J0FqB6gugr1fBXbsxohaZGQPtzUgbDfQ1q0bO/Fv0ttaY4CwiI191LadhoYZIkpWijqWQdJ4URfFi0kSAsB+QVcy7VY9ZRMNYDsu4tNF8Dka6HF5QxeTcuyMfVSIh2V/ddyFXMlM0tBQWNi7cdwFr9t3F1cOfQ31BZ0yhiLWd3/ufnz7+jWK0FPKIfgSMyOD8RsQdreUmn379rF+/Xqqq6sZO3YsPXr0CMp+nNW5CTSL1h3j8S93M7xTCz68I0AulebE1nfgy3ug82i48YvAj7/6WVg9L3jje0FA3VK+NNpTuwrAVptGcRNY/68jLr2h2wpgUl2QtisTeTNu+teY8LrOjfp7Bdt9xeqBBuLTbI1WY5JEBWK1QHbnlnmihe0Y7TtNHF/qBp32LidlHo6ORXd1cJTfg31jT0du1EA1d3XWjNQfmtjvzVO3VESJm1ARKnGTV1TFRc//iE6rYcsj40hLCI57rcmy/GFY/woMvxMuey7w4xcfg38PADTiROJPgUA/Cai4cVQUTXlMWWC6jG3YiBDEVbEaJc5BHRfQd5o4gf9ndN3C5CBOQj0PWaysUeKRuLFfOJX/1YXqRs62CYW4dOHyVJ5Xo3SWd7UAq0WEUpdGGdORcFEX6VP3OFP/JhSh5UqEq4vxBfNYDkbsTBP7HTaamJumTHaLBHq0ScZktsheU76guKUygmPBI70j5FwIWGBPeC03AcW+Xof6MSz1e0Ept0rH4XaDxG1qtvgbX9eQUAl+TM0WHbvn94WiY+KxuLT6PXjU8/C2NL+kcWEfW6L8r6F+8TrF9dJ1rNiu61hbCw+l15irbCcFdVE/R7Vq7OdloWGjTPVvIjUbDHpbrI4ady0PfM10coWyz0MrHc/JF5qpyyoq3BNo6ozv04b9Z8r5fs8Zpg4Kn2WgUVJYJ25aBUncAPSeArm/wJ4vbUHGjR11XQ91g8HcdaK7cnS8yhpTFzSsNKqMq7sS0lfUBRU7QFk40Li+2lbPQ/2/o7GU2iOSxoVi1VCOM/X/9jVk6lkQ8c6K4Mi1oozpaDslQF69fc4FDX8TQ2eJbCxjVYOQMofjqVGO3bKT4vejFKb0xtqiblOh/h2pY3zcfQ7ucPQ5NQOk5SbIXNpbFARcvb+AGoPJzdYSK7VVUFJ3EgyW5Qag15XiNm9D461548j6ob7qVIqP7foEsIiMD+W9Wsy211hMQtRodLYie6ueqh+sOXK26kRvcd+Z2F1WSjO9qmwy2AfquivEqASq24sFdxY89XHkaFvlMSV4effnnsfXdBkr5tRlrOvx7I/jkbPrig7GCqulo0BmdzirrjymLoh6zKPOPweJS6S4CTL9slLJSounqtbEauma8pxzBwELxLcQQYfBIqUdtB8q7h9cEbz9BBN3J36l+JiCSW+rJAzUCwo2G2wBmxqdaMOgpJgqV+WHV9qedydK3IkXWZW4aWPvujm80nEJAHVbDkeojyNHC7zaDWXvflI/76hVhKOyBI7cWvatHNbOF88rBf0UQeJtt25Pqis7+hyUeXja+6qZuYCluAkyGo2GK/pnAvDVDtnLyGOCHW+jptt4cXvw++DvKxioG1g66oWjXGFqoxEuKGyZT/HptjobChqdsO5YTOLWflFRTvj2HZwdIcVL80Y5ZhTLh3Ls2AsAZ24YBXfxL+r4G0etD5yJgpVPOS5LYB/PM22h41YO9rFF3h7rnlRXdvY5qOfhSe8rb2v7NHKkuAkBV/RvB8DKfWcorzG42VoC2MRNq+7B31e3S8XtkdVgrA3+/gKNuoGlq/oxSnVhY7Wtf0+XsSLOJipBZEbFp4vFQV1bxH5RcRTAKZE4wr4mjLNjx5kbxhHO+kI56lFmX1cH6rdyUMSJvVB3J1SU9zUmhL8FR+LDmWXUlQB0V9snFC6vEAgpmQoexFRwBYvFwrh/ruFwQSXPXt2P64Z1CPo+Gz0fzhTF9SY8E/xAX7MZ/tEDKs/CTV9Bp1HB3Z8DfEoFVwc7Hlop3E26WLGAqE+26iBOBfuU3CaSJioJHF7XuXGHo7TxVU/ZWnWoU8kDVZPFPg3aXfp3JBPslO5Q1sPx473IVPAIQqPR8LvzRCrtR7/mudlaAkDBAXEbCreUVisK+QEc/Sn4+wsESpGx0jyRAVVT7LyZn7Vrt0ak3qqruJr0jgM8JZJA4yhtXGnVYZ9K7s564C4NWwmirzxXP54lHBaXQBHs4PtQupBDkEggxU2ImDo4iyithq3HS9hzsizc04lsTAYoOizuBzMNXI1irWks4mbtfJsLKjq+7kGNsMTYn/CHzhKp31hEo7/Zu8TJPT5d9PSRPZ4kocB+QVNiweIciA93i559LI+jmBOlg7cFz7O5vMET10og3S9NKX4tBO9FipsQ0To5jol92wKiLYPEBUVHRXxIdGLoqgZ3ukjcntgiBEKkoywCl78g+vEoIqemWFhySvNg2X22k6p9Cu7QWcIsr9S5cdTwEJpckKEkxKiPH0dp43OO2brHfzLLc7eIo/5O9s+re5wFA1dWJvtUcleWqOb+GwvS+5fiJoTcfEFHAD7ffoKCcn14JxPJWIv3dRMdvENBekdI6yBE1fENodmnPygBvmvni3gbdWaTTqnNabGdVJVgY7WFRlkg4tMcNzwEWVdD4h+eZOgo7lVnVhhHqBt2OrIADJ0Fk/7heZCyL7iyMtlnFrqyRHn7G2tqYihI5xgpbkLIkJx0BmanUWs08/a6o+GeTuQSyjRwNTkXitvj60O7X3c4O5kpGR+1dYX3uo4VJ/popbKwxrW5X1kgXNXnkEX2JP7gSYaO4l51ZoXxFWeuj0CJA1euFW8yC735janFoLO6Vo2NIJ1jpLgJIRqNhjsv7gLAu+tzqdAbwzyjCKVgn7jN6Bna/Xao69weTsvNlnccF+FzdGWjGLXMRrFA7P5cvE5J4570D/H8/L6i9YIzXJ2km5KfXxJ43BWLc3T8qJ9Xu1edWWECTSiskfbv25UI8eY3phaDzgoaNjaCdI6R4ibEjO/dhs4ZiZTVGFmy6Xi4pxOZnK0TN617hXa/irg58Wv46t2seLT+yWrzQmGZsW9KCbay8e0GOq7KCu4DLyUSf/ClWJx9PzFPFjZ7cbB5ITzbUWREeRsrFg5rZKBEiFoMOitoKAGkuAk5Wq2G2y7qDMBba49iNJndvKKZYTZBYQjTwNW06ibaPRhr4NSO0O7biuqqTDFBVxc3TPHevFAEDltMUHysflVWJYhx1VOOAy+bgilbEhl4UixOfbxtXiiC1+3bDbjC3hUD9XsyrXqq4WtctSQJhzUyUCLE215ezRgpbsLA1EFZpCdEc7K0hlX7ZL+pehQfE7VXouIhrWNo963RQIcR4n7+ptDuWyEly3ZVZm+CVrPqKaw9oZRUV8VMbdQ3fFzpDaWMK604kkDgrlow1D/eFFHiruGqmlVP2fqdqbt9K37Z6pKGQt1dL6pQI0VIyJHiJgzEReusRf0Wb5SuqXqc3StuM7qL4nqhJmuIuM3/NfT7BvjjRtsJUG2ChvpXn+q64l3HilvlJK5kTXUdK8z2y+6rf3KXpmxJoPDECqg+3nw59tTHupLtp2RDaXRig2X3CTeVI+uMu31KS2aTRIqbMHH9cNGCYe3BApkWrqZAETchDiZWUDqEh0vcLBju+ARtf/U59lFbw8u8jfXN/WMfFSfy3Z/XdQO31Lf+yKtISaDwxCrirO+Tp4x9tGGxP2Xcy1+wCZyaYpFBaC9U3O0zEiw7/tDYxFmI5ivFTZjIaZnIgOw0zBb4dpfsFm7ldF2fkTZ9wrP/rMGABkqPQ/np0O+/7ET9k6xyIsgeXv/qUzmxq03vanO/4tJCIxYFTzp4SyTe4qklxp8FTSn299Axx/VsLn/BJn6UtiLeCJXGbslsbOIsRPP1WtwUFhby/PPPM3XqVM4//3zOP/98pk6dygsvvEBBQUEw5thkubJ/JgBf75TixsqZ3eK2Td/w7D822Zallb859PtPyap/klVOBHkbPetSbF/XZtI/HC8KEkkg8NQSE8wFTS1+XNVscvV6V+nqkU5jE2chmq9XXcE3b97MhAkTSEhIYNy4cbRp0waAM2fOsHLlSqqqqli+fDnnnXde0CYcCELdFdzpPIqrGPncj+i0GrY+eimp8dFhm0tEUFsF87LAYob7DkBym/DM44s/wbZ3YeRfYdzjIdml067gjjr1Ko/Jjt6SIBLQruDB6DgdzC7Wwe7ALfEZT7uCRzl9xgH33HMP1157La+//joau7L4FouFO++8k3vuuYf16yOswmuE0j49gc4ZiRwpqGT94XPW3lPNlrN7hbBJzAifsAERVLztXTi5NXxzUFDiFBSUtFiLSZjiG9MVm6T5Yn8cBwL7ejnu8EYMKa5e+dtqtHjlltqxYwezZ89uIGxAVN+dPXs227dvD9TcmgWjumUA8PNB6dLjTJjjbRSyBovbE9vAHGF1iNTp4WM8KO0ukTRVvHVveOMak0H3jR6vxE3btm3ZtMl5/Y9NmzZZXVUSz7ioWysA1h4qDPNMIoBT28Vt235hnQate0NUHOhLoehIeOeiYB9YLAOEJc2BQLUtgMYXmyLxC6/cUvfffz+33347W7ZsYezYsQ1ibv773//y4osvBmWiTZXzOrYAIPdcFYUVelolxYZ5RmHkRJ0bqN3g8M5DFw2ZA0QQ74kt0Kpr6Pa95R245E8NH1euOkHGAEgig2DGvCh463pyRTBcY5KIxSvLzR//+EcWLVrExo0bueaaa6zZUtdccw0bN27k7bff5u677w7WXJskqfHRdG8jujhvzS0O82zCiKHGlimlFNILJ+0GiduT20K73w0LHD8urzolkUYoUnrlcS/xEa8sNwDTp09n+vTpGAwGCguFK6VVq1ZERzfzTB8/GJKTzoEzFWw5Xsz4Ps00qPjMLjAbIKEVpHUI92xs1qNQBxWP+KPjx+VVpyTSCEXQrTzuJT7itbhRiI6OJjMzM5BzabYM7pDOB5vymrflRnFJZQ0WPZ7CjWK5ObUTTEbQ+fxT8Y4hN4ZmPxKJv0jhIYlgZIXiCGBQhzQAdp0ow2T2uOxQ0yL3F3GrtD8INy27QkwyGKuhYF+4ZyORSCQSL5DiJgLo1CqJ+Ggd1QYTRwsrwj2d0GOxwLG14n7Hi8I7FwWtFtoNFPcjod6NJOws3pDLhc+uYvGG3HBPRSIJO5H+e5DiJgLQaTX0bicqLe46URbm2YSBgn1QVQjRCZERTKyguKZOSHEjgddWH+ZESTWvrT4c7qlIJGEn0n8PjULclJeXA6IKclOlr1XclIZ5JmHg6E/iNns4RMWEdy5qssIUVCyJSO4a3YWstHjuGt0l3FORSMJOpP8eQhQl6Ts333wzGo2Gp59+mqysLCwWi8MKyY2dPlmpAOw62QzFzf5vxG2XS8I7D3uUjKkzu0WqenRceOcjCSszR+Qwc0ROuKchkUQEkf57iHjLzZYtW8jNzeXZZ58lNzcXjUbjtQVHr9dTVlZm/VMsQZFEnzrLzd5T5U3aQtWAynNw9Gdxv9eV4Z2LPWkdIKElmI221hBBpqysDL1eH5J9SSTO0Ov11vOkPCYljZGIFTfmup4+ffv2JSsrC51Ox/PPP8+xY8e8ttzMmzeP1NRU61/v3r2DMWW/6No6CZ1WQ2m1gTNlzehEsu9r0SupbX9o0Tncs6mPRmOLATqxJSS7zM7OZt68eSHZl0TijHnz5lnPk/KYlDRGIlbcaLViajfccAP9+vVj0qRJFBcX8/rrr/P555+zePFij8eaO3cupaWl1r89e/YEa9o+Exulo3OrRAD2nm4mQcUWC2z+r7jf9+rwzsUZIRY3eXl5zJ07NyT7kkicMXfuXOt5Uh6TksZIxIobBa1Wy/Llyxk9ejT33nsv27dv54YbbrBWR/bEhRMbG0tKSor1Lzk5OdjT9omemcI1te9U5LnNgsKR1XD6N5ElNfimcM/GMVnnidv8X0Oyu5SUFGJjm3F/MUlEEBsbaz1PymNS0hiJeHEzceJEOnToQHR0NGazmc2bNzNw4EB2795Nfn5+kwou7tlWnEz2NQfLjVEP39VdDQ6aCQktwjsfZygZU0WHoaoovHORSCQSiUdEXLaUfTaU0WjEaDQyY8YM1q9fz3PPPUfbtm355ptviIqKuOn7hVXcNHXLjdkEX/0ZCvZCYgZc/FC4Z+SchBYiFqjoiKh3021cuGckkUgkEjdEhDr44IMPqKioYMSIEXTs2NFqDjWZTERFRXHzzTdz44038sgjj3DrrbcCMHr0aJKSksI57YDTo07cHCmswGAyE62LeMOa9xQdhS/vgWM/g0YLk1+BxJbhnpVr2g8V4iZ/sxQ3EolE0ggIu7iZMmUKubm5dOzYkfnz53PllVdy9dVXM3z4cHQ6HQDnnXceq1evplu3bpjNZrRabZMTNgBZafEkx0ZRrjdypKDSKnaaDL++Bd/9TfRrik6Aqa9Dj4nhnpV72g+FnR9C/qZwz0QikUgkHhBWcbNmzRoOHTrEb7/9hlarZcWKFXz44YcsWLAAk8nEBRdcAGBN4bZYLNYsqqaIRqOhe9tktuQWs+90WdMSNyufgp9fFPc7XgSTX4q81G9nZA8Xt/m/CpeaVhfe+UgkEonEJWFVCikpKbRp04aqqirMZjPjx4/njjvuICEhgSVLlpCfnw/Au+++y5o1a5pU8LAzurcRgmb/6SYUd7NjiU3YjH0Mbvqq8QgbgNa9ISYJ9GWyQ7hEIpE0AsIqbjIyMtizZw+LFi2yWmSGDRvG9OnT2bFjB/v2iYVkx44dtGrVKpxTDRlKUHGTETeVhfDtg+L+qAfhovtEcbzGhC7KljV1fEN45yIJCpHe4VgS2cjjJ/IIq7hp3749b7zxBk8++STvv/8+ILKlLrnkEnr16sU777wDwDPPPEOfPn3COdWQ0cOaDt5ExM2qp6GmVFQgHh3BWVHu6HC+uD2+PrzzkAQFfzscy8XNN5rK5xbpHbKbI2EPYJk8eTJPPvkkc+bM4c0337S6nlq1amW11sTERFCn6CDTq60o5HeipJrSakOYZ+Mn5adh+3vi/sRnG3esSo6I/yJ3naisLGmUOFtM/e1wLBc332gqn1ukd8j2hqYiOMOeLaXRaJg1axYpKSnceuutfPnll8TExPD999/z008/hXt6ISc1IZqstHhOlFSz71QZwztHeJq0Kzb9B0y1IiC344Xhno1/tB8K2igoOwElxyE9crvhSpyjXkzVHY3ddThevCGX11Yf5q7RXRxud9foLtbnJZ7TVD63SOyQ7e6YdYaz30hjI+yWG4CoqChmzJjBli1bmDp1KmPGjGHTpk0MGDAg3FMLC70ym4BrymSEre+K++f/MbxzCQQxidBukLif+0t45yLxicUbcqnUG0mLj/ZqMV28IZfHv9jl0sIwc0QOvzw0plEvBqFCbRkI1ufWVKwP/uCrVaypWKEiQtwo9OzZk1tuuYW7776bHj16hHs6YaNnnWtq76lG3Ibh8EqoPAsJraDH5eGeTWDoOFLcHm1+FsVIx5PF7LXVhympNlBabeDF5fsbbOtsjNdWH8ZkAZ2GRn/CjwRC4YpS9vH4F7tCJnD8EVTBEGOuRIqr/TUVoR5R4kYi6FXXQHNPYxY320WAOP1/B7ro8M4lUHS6WNweWSPjbiIMTxbMu0Z3QacBC1BSbWiwrbMxlEXiiSl9rSd8aRlwT7DimzxB+a5NFkIWz+OPaAuG4HMlUppKrJMrpLiJQPplpQKix1St0Rzm2fhAbSUcWC7u9/9deOcSSDqMAF0slJ+EwoPhnk2zwFMRcdfoLqTFR1OpNzrdduaIHJ6Y0pe0+OgGrqnFG3IpqqxFAwzJSW/wOvtFojksDv7i7DPy1TLgjaBUvmtPRFSghKo/os1XK4uv2O+vKYp1KW4ikOwW8aTGR1NrMnPgTCOMuzn4vWixkJYDmQPDPZvAER0PHeqqFR9ZHdapNBdciQj72I3E2CiHFhk1M0fksP3x8Wx/fHwDsVJtMGEBlu086ZGYagpxCcEk0J+Rp4JSOS4Aj0SUr0LVXhD4484JtZXFfn9NUaxLcROBaDQaq/VmZ35pmGfjA3u+ELe9pzS+gn3u6DJG3B76PrzzaCa4WiDtT8j+XP0qlh8NnrkyvFnImuJVsScEOnbDU7Hk7ULtqwgLlSBwN79AHF/+CtFIPMaluIlQ+rUX4ua3EyXhnYi3GGuF5Qag1+TwziUYdJsgbo/+BLVV4Z1LM8DVAml/QlZvqz7ZLt6Qy6NLRbbTI0t30emhZdz7wbYG+9n++HieuqqvQ/eWPyfvpnhVrBDMIFpfLSOeuCjVODtu3BFIy5Q/Ab72x5cv34m/rsIXl++PuGNcipsIZUCduNl2vCS8E/GW3LVQWw6JrSFrSLhnE3ha94LUbDDWwLG14Z5Ns8Z+URr4xAoGPrHCWt/jREk1Ly7fz6NLd6EO/1ZcT87GdOTe8kegNGUXVqCCaO3FqD8LpqcuSndz8mQ/gbJMeetyUwsX++MrlGJa2RdgnUOkWHGkuIlQhuS0AGD/mXJKqxpRpeL934rbHhOhKXZw12ig23hxf/+y8M6lmWIvZMCW5l1SbeDRpbsoqqwlLV5k6amFjeIk7dMu1en4jsSIPwKlqaTWOiIQQbRDctLr1RFytGD6Oy9HC64nQiFUONuv/RwdCRf748uX9+CrIFH2df+EHtbv8f+W7YkIK47GYml+Oa35+flkZ2eTl5dH+/btwz0dp4x5cTVHCitZeNN5jO3VJtzTcY/FAv/qD6XH4boPoGcTqW9jz+FV8O5UUcPn/gMBaSuxd+9eevfuTWlpKSkpKQGYZNPlwmdX1Vv8fnloDIs35PLi8v2UVhusYiYtPppR3TP4cofNSqOkB+s01EvtdoSvFV6bCsp5MhDHpKvPUvk+le8ECMjnrt6nIgqU40W9X/VjocST40uZY1p8NImxUQzJSeenAwUA3D+hR8COy0B8Fl3mLsNkERcQ7erEVTB+N2VlZaSmpro9LpvgpXXTYWhHYb3ZdKwozDPxkLN7hbCJioPOo8M9m+DR8SKIS4OqQtFrShJSlJiK+GgtRZW1DHxiBZuOit9IXLRNaFbqjfWEjQaY1L+dVeA8/sUu7v1gm9Mr1qYcKxNqXH2W9nWEHFm6FMuCq+/L1T7V1gxlrCE56SG10ti73txVvVZX1AbRb3BLbrFbl5svVhh/LFbK/vq0S0WngSsHtIsIS6UUNxHMsE5C3Kw7dC7MM/GQA9+J206jICYhvHMJJrpo6HmFuL/r0/DOpRmiBP+2SIyl2mCipNrAsp0nKak2UG0wER+tJSstHqPZZpROi4/mqav68tKMQTwxpa9V4Hy14yQnSqr5v2V7I8ZF0RRx9Vl64rZThMqynSc9Fpzqfar3oYy1JbfY50XYUzeXo/eguN7cVb1WXK3lNQZGdc+wvhd3x6Uvotwf16myv3OVtRyeN4mXZgzyeoxgIMVNBDOqewYaDfx2opQzZTXhno57lMJ93SeEdx6hoN80cbv7MzA0gu+mkeEorsZ+8VAsOGnx0Uzq38762mqDmbtGd7GWU8hKiyMxtn6P4OQ48bq4aHEKrDGY3MYySHzH389SWdAn9W/nseC036cji40vIsWZ1cWdqFCLEkdVrx1tr4hwtRBz91kGMubG1WehPNcyMQadpmHxy3AjxU0Ek5Ecy4D2aQCs3Hs2vJNxR2Uh5G0U97tPDO9cQkGnUZCSBTWlcODbcM+myaEOEFb6A6kzoJQibdsfH8/9E3qwJbeY+Gjb6ezRpbv47YSoEXWipKbeoqOMnRgbxaW926LTiKrg0koTuSgL+kszBnklktSLsyOLjSNBYn+cedprzJ2omDkixxr/A+4LDPpaZdnb1HZ1qYQXl+9v8F6dCTblud0nS60CLJKQ4ibCGduzNQDf7T4d5pm44cB3gAXa9ofUyA3SDhhaHQy4Ttzf8nZYp9JUUJ+IHRXVUxYPoIFYOVFSTbXB1qrEQv0sKfVCpF6EtuQWY7LAucpaaaUJIuFKD3YWd6Pg6jHA4cLuzOriSayQJ+ntzoSKp+/Tk8ftt3GWVeTo87G3gE3q386rukKhQoqbCOfKAcLc/vPBAmuGSESipID3nBTeeYSSITeDRitaMRTsd7e1xA3qE7ESV3PlABEA3DIxxrpA3T+hR70TrmK+d4Z9ZpR6wZBxNaEhXMHZzuJu1FTqjfW6xCvb2R9nCt642OxjhcB9ersigOytKO7epyOB4cnxrXbv3j+hR73nXPVVUyxgL80Y5HNdoWAiU8EjOBVcYcZ/NrD+yDnuHduNv17aPdzTaUhtJTzfRfSTuuMnyBwQ7hmFjiW/h31fw+CbYPJLPg/TVFPB3aW7qp8HceIckpPOt7+dwmC2EK3VYDBb3KZwL96QyyNLd9V7LFqroXVKHENy0tmSW2y9ba6p3d7iaSq4JynNwUyr92dsR2UF7MdWRIY69VrZp7tjy3479fPO5j3wiRWUVBtIi49m++PjvX4vwU5td/ab9fT9+YtMBW9C/H5EBwDe/uUoJVW1YZ6NA5RGmekdhVuqOXH+n8Tt9vehND+8c4lA3F2F2ltrfnloDD8dKMBQl+lkMFuspm/FRfXo0l31Ktkq5nslZTY+WkdWWjyPT+7DLw+NYUtusdeZNhLP8cQqE8zgbG+sQq6C0p31L1NivxzF5SjHlLNjy1WskLN5KxYjeyuKu/cyJCfd58BeT92G9oLFVeZZuEspSHHTCLisbyY92yZTVmPkXz8cDPd0GtKUG2W6I+d8UffGbIA1z4V7NhGNs4qwrvz1afFR/PLQGI4VVlrjAixQr5KtcvJUFoWHJ/VyWLHVm0wbied449qzPwZC3fTR/phx1iVemVul3kh8tNYqfhzFm9gfW56+J2fz9lQI2l84KPFjvgT2eipE7LdzJajC7fKV4qYRoNNqmHt5LwDeXneMVfvOhHlGKvQVtvo2vaaEdy7hYswj4nbru3BqR3jnEkEoJ3cli8lRMKVyAi+pNtQz/yuUVBu594Nt7KzLfAKI1mmo1BsbFGFztij4mmkjCTz2i6O3V/eOivl5YxXypqmmYrVpkRhrFT+O4k3sj61AWixcpWiXVtdvy+NP93BPhYj9dq4ElSffi6OeYoEKSpbippFwcfcMbjxfHCR/fG8bmyOlavHer8BQBS26QNbgcM8mPHQYAX2nARb48h4wNaJeYEHkxeX7Kak2UGMwU1JtQG80uTSbl1QbuPeDbcwckUO8qtKwusowgNFkoaTawE8HCqRYiQC8WcztF0dvr+59Keanxpummr72GPP0Pblz2Tqqp6MIgP9btgcLour2qO4Z1tII3nQPV+OpQPS0j5WnQsW+sGEg3VhS3DQiHp7Ui4u6taLaYOKGhRtZEQnp4Ts+ELcDrmt+Lik1E/4P4tOF5ebH/wv3bCKKuGgdafHR1BjMmCxCrNz7wTbr86O6Z1jvf1UnZB6e1Itore14UosdxT2lN5oaFPqThB5PFnNlsYP6C7C3V/fOXIyeFN5TLD5KS4MhOekuX+Nobp7Md9PRIk6XVltbgviKo3o6igCoqSt7kBofbY0pU4uCYDQF9cZq5qlQcVTYMFBuLJkt1QiypdRU15r44/tbWbXvLBoNPH5Fb26+sFN4JnPuMLw8GNDAn7eLgOLmzO7P4eObxf1rFtqqGHtAY8+WUmeVjOqe0SCDRDnZKeg0cHieKBugZIeALcPprtFdrJYfDaIkgr0FJz5aa61tE67mh02ZQDXOVCwQJkvD78k+QNVRho0nWUDutlE351TmAfiVXeQsG0hpIAlY06vdZQp6+ryj7CugwWfo7PP2B3VmGbgeO5jZcTJbqokSH6PjPzcM4frhHbBY4O9f7WH+9wcIi0bd/Ka47XapFDYAfabasqc+vxMOrAjvfEKIOqvky7p+Td/vOW09+SlXy/2zRHM9dbsEBQ2QGBvV4IpPuTq1p9pgJr7OKuSrWVwSfFz1UfIkBscfV5CzAOBAWAqcWSfUx7Yr95c7K5Cr54d1auH0OUefty/tFey3UYKHoeF3aT9OJLQukeKmERKl0/J/V/XlvrqaN/9eeZB/rwxxFlV1MWxbLO4PvS20+45kLn0S+lwtsqeWXC+sOU0Y9YlPSalVqDaYrVdwimXm4NkKTBb4fs8Z64lQcUtZgA4tEqwLjjolVlmI1C0WAGKjtA4zXcKdhiqx4aqPklpgKNlJztKyXeHOPaJYORzVotl0tMinDC77uSuveWnGIJ6+qq/LFHNHOOqnZo+rdhHKY44+b/ttlPl6UjFZ/Rkq7SDsv0t/f2/BuBiJcr+JJBLRaDTcM7Yb8TE6nl62l3/9cJD0hBhuuqBjaCaw4TXQl0Hr3tB1XGj22RjQ6uDq/wCWOjfVLVByHC64t0nGJCmuo5Ml1Tx1VV8Anvhyt7VOzRNf7iYxNoporcYqcACqDSZrbRu1Vea3E6UcfdZW5VptjvcGxRUm077Dj9Ls0d1zFz67ipJqA1lp8U4XTk8KxNm7SMF2PKjHUf5XXC32j7+2+jCbjhaxbOdJJvVvV6/btX0hO8UNpIzh6j07Q/ktKeMpn48aR8e1/WP2+3YkGpX3mBYf7ZFVTP1ZO3pfnvzeXBU0dPQd+4u03DRybr2os7Vq8d+/2s3yUAQZl5+B9a+K+xc/CFp5GNVDFy1ibobeBljg+8fg8zugtircMwsIjq6y1LVnFGEDoghfSbWh3mMKRZV6a5Coehx1sLGCcvKLjdLVM407K3QWCWbx5kQw69U4etyVpUDtIlUXl3OUqeXIzTIkJx0N4vj8asdJTBZYttMW72WfxaS4gZTX+oreaOuNpgglV+4eZ0Hazj6PxNioBllO90/oYXUdO/v+PPktebKNq0y3YNTEkatSE+CeMV2tMTh/WbKdnfklwd3h949CbTm0G9x8a9u4Q6uDy1+Ay14AjQ52fggLx4sg7EaG/QlWvbDcP6GHNaupZWKMtY6IGp0G+melNhi32mC2nuDUr1m286TDSrLKydiZaVwSPtTHhK9Cx12dIvXjjhZDRy5S9fP248wckePwWNqSW4wFcXzGRevqxYipg3VBiBm1SPKnM3ZslFiO46O11vemfK6OOpT7kpHkTBCFwo3rqphmMC5GZLZUI8uWcobRZOYPi37lpwMFtEqK5fO7LyC7RULgd2TNCNLAbSsha0jg99HUOPqTcE9VFUJMMlwxH/pfW2+TSM6WUmeiKFlMYOu1o2SHqDOgJr+8lp0nSonWauiVmcLuk6Ukx0VRUm1EqwGzRQQQP3VVX+uJNT5aS63RzKT+7azprTILKnx4ky2ldtMo32egvjtPM28C1Vvp3g+28dWOk8RF63h4Uq96+3SWMeTK5eLpewMavE/l+Uq90eqyU96bLxlJzj6jYGY3ucJZ7y5XyGypZkaUTsuC6wfRs20yhRV6bli4kbPlNYHdyamd8MU94v5Ff5XCxlM6jRINRTucLyxen90KH90o3HuNAHVVVyUuoLSuovDiDbn0aSesMsotwO6ToqKw0Wxh54lSTBZRbRggNkr0frpyQDteW32Ylokx6DRwae+2HJ43iZdmDAp76XaJd6ivvAP93XlqFQrUfhXLTWyU1rpP+31MHlDf+qC8f0c1Z8C5284+1sRZXZ0OdReqLRNjGjwHzl1K9jir0OyP5cQfl6TahRhoq5EUN02I5Lho3r5lGO3T4zl2rorr3thAfnGA4jxO/waLrxaLc8eLYPTcwIzbXEjNgpu+Fp+bRif6cb08BH7+p+iqHiY8PTGV1xisokaDiI1RTkjnKkUz1+NFVdaxJvVvh04jCvgpKO6raoOJSr2Rnw4UcKKkmt0nS61xDZGUSirxHUUIByL7RS1aAlFl19P9AQ1EFeCylYcj8eCo0rCj9+YK5WJBuVXj6DNx9rv2pkKzu7Fc7d9TlM/Llww5d0hx08RomxrHe7cOJystniOFlVy14BfWHCjwb9C9X8Fbl0FlAbTtB9MXi6BZiXfoomD0Q3D7j9BukBCKK5+A+X2I3fRKWKbkyYlJHTBpQdSdUZ+QlPoXlXojJ0qqeXTpLoZ1asHheZO4tHcba8xNYmwUSr6YkhWi+OCV4moydbvx4+xq3JsrfPW2wbQKOULZn1KKYEhOulNx4ui19uLBVZ0fTwWZ8htxVB/K24BrZXt3FZo9GcvZ/p3hKEDaWeNSf5HipgmS0zKRj+88n96ZKRRW1HLTW5u4890tbM8r8a7YX/kZ+OwO+HCmWIhzRgrrQ3xa0ObeLMgcALeugqlvQHonqC4mZsc7YZmKNwXSFFP8/RN6WLOU/m/ZHr6syyhRMqIswCNLdzHwiRV8v+cMJgvsPFFKSbWBKK3GKoyUTI2XZgyynrz9yTaRRAbq71B935srfGfbuhMD3rpIXG2vdjU5EyeOcJSV5U0AvKM5vTRjEE9M6cuW3OIG9XiABhlU9k1lHb0vxXLqrLeVs/ej7FupyaPev7v3Esr6UzKguIkEFDuiutbEc9/tY9H6YyjfcseWCYzqnsGQnHT6ZaWS0zIRnaqHDwAF++HX/8HWRaIpJhq44B4Y+5i02AQaswn2f8Ox716h019XRERAsSfBheqWCQrqdgjO0EC9OjYKgQoGlQQOX9svqINu0+Kj2f74eMC7oFVPt7XfztvjSNk+LT6axNgop3VzQhls6+w92D/uaDtv3r/yG1Z/R97OEVy3YbCfTyA+SxlQLCE+RsffJ/fhuz+P4upBWcRGack9V8HH6/fz2JK1/P4fn3HFw6/ytxf+xQev/p2tr95MyfMDYcEw2PgaGKqozBjEsalfcGTQHPJKDZwpq+FchZ6SqlrKawxU1RqpMZioMZioNZoxmMwYTWZMZgsmswWz2RKe1hBeoNfr+fvf/45erw/9zrU66HUl1RP/Ffp9O8Hbq6tonbDGXNq7bYMKwvZcOaC+WV357G8bmdOsAojDeswFCGfv4a7RXdA42N7e6qK+qve1fL+z6ryeHkeO4mvUqBfjawe15bpHFnDBvJVuLUP+tDvwtN6Po+2cxfw42qe6ArijbVwdo57GytjPMZSxdM3ScnPs2DE6derEpk2byMzMDPd0QkZVrZH8TV9y3o5HXG5nsOj42dyXJaZLWGfuCw5PVf4zrkdLnryie1DG9oby8nJ69+7Nnj17SE5ODsscDhw4wNixY8nLywu75ebDzcd58+ej3HpRJ6YP7dDg8UHZafxyqJCyGiMWIDM1ju//ejGX/nMNp0prrPEz9ug0sOPvE+o9VlZWZrWihvt9h5LG8L7z8/Pp06eP0zm6eg/OjiE1yvGSmRoHYL3//V8v9ngsT/bjCc7GUc/x01sHMfzp5ejiU0iNi+KXuWOdjqd+nfr9OHs8UPN1tA9P9ulom0g9RpV5FRUVkZ7u3I3dLMXN119/zZVXXhnuaUgkEolEIvGBTZs2MXToUKfPN0txc+7cOVq1asWGDRsiSpGGmoqKCoYNG8amTZtISkoK93TCRiR8Dvv27ePqq69mxYoVTToOzJ5I+OzDQWN43/v372fq1Kn89ttvpKWlNXg+EiyeoUS+38igrKyMPn36uLXcNMvGmdHRIii2V69ezVrc6PV6Hn/8cfr3709sbGy4pxM2Iulz6NWrV7MSN5H02YeSxvS+O3To4PA8qbyHzp07R/x7CATy/UYGZWVlAOh0OpfbNUvLjafR1hJJqFDaLzT1DD5J4yGSW4JImi8yW0oikUgkEkmzRIobiUQikUgkTQopbiQSiUQikTQppLiRSCQSiUTSpJDiRiKRSCQSSZNCihuJRCKRSCRNimZZ50YikfhAyXHRUPX4erBYoNMoGHorJLdx+pKyGgNvrDnM/tMVXNy9FZMHZpEaL5uvSiSS4CLFjUQicc+v/4Plf6vrEl9H3gb49S2YthA6j27wkoNnypnx3w0UVtQC8MPeM7y86hD/vm4Q53dpGaKJSySS5oh0S0kkEtesfg6+/osQNh3Oh6tehymvQpu+UFUI70+H4xsbvOzJr/dQWFFL51aJ/GVcNzq1SuRsuZ7fv7mBp77eQ1Wt0bptda2JLblFrDtcyKGz5SF8cxKJpCkiLTcSicQ5W96G1c+I+6P/BqMeAG3dNVHfa+CjG+HgcvjgOrh7PSS3BeDngwX8fLCQGJ2WRX8YRnaLBG4f1Zm/f7mbj37NZ+Hao3yw6Th926VSWm3gcEEFRrOtWPrYnq3526RedMmIzL5LEokkspGWG4lE4piT22HZ/eL+6Lkweo5N2ABEx8G1b0ObflBdBF/8ScTiAC8s3w/AzBE5ZLdIACAhJornpw3gf7cMJbtFPFW1JjYdK2L/mXKMZgutk2Pp2joJnVbDyn1nufb19RwrrAzhG5ZIJE0FabmRSCQNMdbC0rvBbICeV8DFcxxvF5MA17wJ/7kYDn0Puz7lUJuJ7MwvJVqn4U9jujZ4ySU9WrPm/ks4cLacPSfLaJEYQ5eMJNqnx6PRaDhSUMG9S7ax60QZN/1vE5/ffSEtEmOC/IYlEklTQlpuJBJJQza8Cmd3Q0JLuPLfoNE437Z1TxhVZ+FZ/jdW7zwMwPldWjkVJVqthp5tU7h6cHtG92hNdosENHX76JyRxFs3D6V9ejy556p4etmegL41iUTS9JHiRiKR1KeqCH7+p7h/6VOQ2Mr9ay64F1p0gYozpG99Wby0t/MUcXe0To7jlesHo9HAZ1tPsO5woc9jSSSS5ocUNxKJpD5r54O+VMTSDLjOs9dExcL4pwG4onIp7TUFXNrLd3EDMDA7jd8P7wDAo0t3YTSZ/RpPIpE0H6S4kUgkNqqLRe0agLGPglbn+Wt7XMaZlsOI1Rj4v5TPaJsa5/d0HpjQkxaJMRwuqOTjLfl+jyeRSJoHUtxIJBIbmxdCbQW07gPdxnv3Wo2GRUm3YrZouFi/BvK3+D2d1Pho/niJCEqe//0BqmtNfo8pkUiaPlLcSCQSgckIm98U9y+813UQsRO+OJPBZ+aLxD/fPWRNDfeHmSM6kJUWz9lyPf9bd9Tv8SQSSdNHihuJRCI48C2Un4KEVtBnqtcvP1NWw4mSal40TscSnQj5m2DnR35PKzZKx33juwPw2o+HKaqs9XtMiUTStJHiRiKRCJRYm8E3iABhL9maWwxAetscNKPuEw+ueASqS/ye2lUDs+iVmUK53sgrqw75PZ5EImnaSHEjkUigNB8O/yjuD77JpyG21ImbITlpcP6foGU3qDwLPzzu9/S0Wg1zL+sJwLsbjnGkoMLvMSUSSdNFihuJRFLnPrJAzkho0cmnIbYeF+JmcId0Yfm58l/iiS1v24STH4zqnsHoHhkYTBYe/WIXlgDE80gkkqaJFDcSSXPHYoEdS8R9T+va2KE3mth1ogyAITnp4sGOI2HoreL+F38KiHvqicl9iI3S8suhc3yx/aTf40kkkqaJFDcSSXPn9E4o3A9RcdB7ik9DHDhdQa3JTHpCNB3qGmUCMO4JSO8EZfnw7YN+TzWnZSJ/qksNf/SLXeQVVfk9pkQiaXo0CnGzfft2aYKWSILFrk/FbfcJEJfi0xB7TpUC0KddqrVHFACxSXD1f0CjhZ0fwu6lfk4W7hzdhUEd0iivMfKn97dSa5SViyUSSX0iXtxMmTKFuXPnUlBQgNns20lMr9dTVlZW708iiRT0ej0VFWEKkDWbYddn4n7fa3weZvdJ8Zvq3c6BOMoeBiP/Ku5/PRsqzvq8H4BonZaXZwwiNT6aHfmlzPl0p7z4CSJlZWXo9fpwT0Mi8YqIFjd/+tOfOHPmDEuXLqV169Zotb5Nd968eaSmplr/srOzAzxTicR35s2bx7Bhw8Kz8xO/QmkexCR5X5FYxR5F3GQ6sfxcPAfa9oPqIlj+N5/3o9A+PYGXZwxCp9Xw+bYT/GPFAb/HlDgmOzubefPmhXsaEolXRKy4qa6uprCwkDfeeIPY2Fjeffdd5syZw/PPP88PP/zg1Vhz586ltLTU+peXlxekWUsk3jN37lw2bdoUnp3v/lzc9rgMouN9GsJstrD3lAvLDUBUDFz5knBP/fYxHFnt077UjOqewbyp/QB45cdDfLRZ/q6DQV5eHnPnzg33NCQSr4hYcRMfH4/FYqGgoIAFCxYwZ84cEhMT2bhxI//+979ZvHixx2PFxsaSkpJS708iiRRiY2NJSkoK/Y7NZtjzhbjvQ0ViheNFVVTWmoiJ0tK5VaLzDbMG27Knvn9M7N9Pfjc0m3vHiADjuZ//xoYj5/weU1KflJQUYmO9L+ookYSTiBU3FouF1q1b88EHH1BYWMgXX3zBY489xquvvsqoUaNYvXo1NTU10tcukfjKiV+h7ATEJEOXsT4Ps6fOatOzbTJROjenlIsfEvs7tQP2fO7zPtXMvrQ7Uwa2w2S2cN9HOyirMQRkXIlE4hmLN+Ry4bOrWLwhN9xTsRKx4kaj0fDYY4+xYsUKnn76aU6ePInZbKZNmzYMHjyYXbt2YTQa62dmSCQSz1Eyl3pMhOg4n4dxG2+jJrElXHCPuP/z/IA01tRoNDwztR8dWiRwoqSav3+52+8xJRKJ57y2+jAnSqp5bfXhcE/FSsSJG8USYzAYyMjI4LvvvqN169YsWbKEU6dOAXDs2DESEhKk1UYi8RWLxeaS6n2VX0Mp8Ta9PBE3AMNug+gEOPNbQGJvABJjo5g/fSBaDXy29QS7TpQGZFyJROKeu0Z3ISstnrtGdwn3VKxEhXsCAB988AEVFRWMGDGCjh07kpycTHR0NCaTiT59+vDTTz9xzTXXMHPmTLRaLbt37+abb74hOTk53FOXSBonJ7aIwnoxSdDVd5cUwP4z5YBwS3lEQgsYdANsegM2vApdLvFr/wpDctK5ckA7vth+kpdWHuQ/N54XkHElEolrZo7IYeaInHBPox5hFzdTpkwhNzeXjh07Mn/+fK688kquvvpqhg8fjk6nw2Aw0KVLF3755Rd27dpFdXU1nTt3pkOHDuGeukTSeFGypLpP9DlLCqBCbyS/uFoM1caLi43hdwhxc+gHKDsJKe18noOae8Z05csdJ1mx5wx7TpY5z96SSCRNmrC6pdasWcOhQ4fYunUrS5cu5V//+heFhYUsWLCAdevWARAdHQ1AYmIiw4cPZ/To0VLYSCT+YDbbxI0fWVIAB+usNq2TY0lPjPH8hS27QIcLwGKG7e/7NQc1XVsnc0V/IZT+98vRgI0rCQ6RGIgqaRqEVdykpKTQpk0bqqqqMJvNjB8/njvuuIOEhASWLFlCfn4+AO+++y5r1qwJ51QlkqZD/iaRJRWbAl3H+TXUgTpx08NTl5SaQTPF7fb3AxJYrDBzuLj4+W7XaWoMpoCNKwk8kRiIKmkahFXcZGRksGfPHhYtWmStPjxs2DCmT5/Ojh072LdvHwA7duygVatW4Zxq2CmurOV0aY08WUv8R2m30ONyv7KkAPafFm0jvHJJKfSeIpp1Fh2G07/5NQ81Qzu2oF1qHOV6I6v2+dfqQRJcIjEQVdI0CGvMTfv27XnjjTe4/fbbSU9P5/rrr8disXDJJZfw4Ycf8s477zBu3DieeeYZYmK8MHk3ASr1Rt78+Si7T5ZytlxPUmwUcdE6KvVG9EYzSbE6/nPjecRF68I9VUljwmSE3f73klKwWm58ETexSdDtUtj7lXCTZfb3ez4AWq2GKYOyeG31YZZuO8Hl/TIDMq4k8ERiIKqkaRD2gOLJkydz+vRp5syZQ1VVFbfeKiqYtmrViqqqKoBmI2xKqmp5aeVBdp8sw2S2MLhDOpMHtCMjObZBPZ+d+SVMf2M9r84cQlaa7wGhkmbGkdVQWQAJLQOSpaRkSnX3xS0FIuZn71ewZymMfQwCVLfqqoFC3Py4/yyl1QZS46MDMq7EcxZvyOW11Ye5a3QXKWAkISfs4kaj0TBr1ixSUlK49dZb+fLLL4mJieH777/np59+Cvf0QkLuuUqe+WYvhRW1XNKjNXeP7kp8jGuLTP/2abROjuPOd7cwvncb/nhJV7RaWdBQ4obfPhK3fa8BnX8LflFlLQXlolt0t9Y+to/oNqHONXUECvZB615+zUmhR9tkOmckcqSgkvWHC5nYV1pvQo06nkaKG0moiYgiflFRUcyYMYMtW7YwdepUxowZw6ZNmxgwYEC4pxZUzGYL9320nYc/38XYnm2YM7Enwzq1cCtsFNqmxjFnYg9OlFQzZcEvPPL5bxRV1gZ51pJGS00Z7PlS3O8/3e/hFJdU+/R4EmN9vE6KTYJOo8T9/d/6PSc1o7plALDmQGFAx5V4hoynCS/BzkSL9Ey3iBA3Cj179uSWW27h7rvvpkePHuGeTlCp1Bv5/ZsbaZkUy71ju9HRVcNBF8RE6bh6cHsevrwX7dMTuGHhRpZsOh7g2UqCSmm+aCQZbPYsBWM1tOoOWUP8Hs6veBs13SfWDfidnzOqz6juIgnhpwMFspp5GJg5IodfHhrTwGoTyYtiJM/NW4KdiRbpmW4RJW6aCx/9msfv3ljPxL5tGderTUDG1Go1DM5J577xPfhAipvGQW0VfPsgfHYbdBod/P1te0/cDrw+ILEtirjp5re4mSBu8zZBZeCsLCM6tyRap+FESTXHzlUFbFyJf0TyohjJc/OWYFvOIt0yJ8VNiHl/43He25DL7HHdPe/F4wVms0UGTzYGNr4Ob0+ClCyY+ByktQ/u/gr2Q94G0GgD4pICOHhGpIH7HG+jkNoe2vQDLHD4R/8nVkdCTBTn5bQA4OeDBQEbV+IfkbwoRvLcFDy1LjmznAWKYI/vL1LchJD3NuTy4ebjzB7XnZQgCZBj5yp9dnFJQkBtFXx8M5zYCpe/AF3GBCxDyCVb3xG33ScGrNXBwbN+1Lixp+sYcXt4pf9jqbiozjX180EZdxMMfHHjRPKiGMlzU2hK1qVgIsVNiFi8PpePt+Qz+9LuJPgafOkBRwsrZV2PSGXHh7DoCug4Ci64B6JiQ7NfQ42txcHgmwIyZGGFnqLKWjQa6Oqv5QaEyAM4vCqg1YqHd2oJwJbcYhl3EwRO/bCAD6tv49QPC8I9lZATrvicxmBdigSkuAkB/1lzmE+35TN7XHcSYoKbfb/3VBl9s1KDug+Jlxiq4fO7RKG6S5+E7KGh3f+epVBdJFxgfrZbUFDibbLTEzzO7nNJh/MhOgEqzsCZXf6PV0ffrBRiorQUVdZytLAyYONKBHdFfUl7TSF3RX0Z9H1FWrCv2oLi79y8eX1jsC5FAlLcBJlnv93LTwcLue/SHoFZBFxwpKCCtilxJAXRMiTxArMZNi8UsTXtBsCYhyHOgfC0mGHDG8Gbx+Y3xe15t4AuMMeGEm/TvU0ArDYgrFgdR4r7R1YHZkwgNkrHgPbiM/81tzhg40oESWMfgNRscRtkIskds3hDLpV6I2nx0dw1uovfc3P1+kgTdY0FKW6ChMVi4f6Pd3CiuJo/jelKTJRnH7XBZPZ5n9/sOs1DlwWmCJrER4x6OLUTPr8TFl4KZ/fA+Kch50Lnr9mxBFp2Ds58Tm6H/M2gjYZBNwZs2IBlSqnpPFrcBlDcAAzOSQdgyzEpbgLO0Fkwe5e4DTKR5I55bfVhSqoNJMZGMXNEjtdzsxcszl6/eEMuj3+xy2fh1JyFkbzEDwIms4W739tCm5Q4fndetsttLRYLLyzfT0GFnrJqAwDJcdE8NaWvV5aeospaDEYzHVom+DV3iRdUFYlA3fxNUFUMGoSISMmCrmNhxN3ug4XzNkLxMRjxKBCEuIVN/xW3vadAcmDKDkAQLDcAnS4Wt7nrwFgLUYFpu3JeTgve4Ai/5hYFZDxJeIikPlSKtUYRI97Ozb56s7PXv7b6MCYL6DT4JOqac5VoKW4CzGdb81m07hije7Tmwq7OO5nXGEw8vWwPBeV6UuKjyUiKpXOrRDQaDccKK3lh+T4eu7KPx/tdsuk4kwcGJgtG4oYti2Dnh6KjdtZQOO8PkOSDcCg5Lsa58Ss4dDTw86w8B799LO4PvyNgw1osFg6crbPctA6g5aZ1b0jMEL2v8jdDRxfWLi8YUme5OVxQSXFlLemJzaNXXSQRjj5Twdynv0LLXhw5Qu36un9CD5/258l+/CVSe4hJt1QAeeabvSzZlMddo7s4FTa1RjNzPt3J7A+3E63TMiA7jS4ZSaTER1ubY1qA64d38Hi/W3OLSY6LYsYwz18j8RKTAX56Ad6aKOrFXPIwjHsCel3hm7Ax1cLP/4Br3xEiKRhsewdMesgcCO0DF8RcUKGnpMqANlCZUgpara0VQwBdUy0SY+icIcojbMuTrqlw4CimxJ3LxF+XSiTF6NjjSVCwvesrkPux/2zV/3v7uUfq5yzFTQAwmszcvXgL5yr0/HV8d1okOk7xnffNXv70wVYSY3X0b59Km5Q4tA7cFjUGE62SPEsTrtIb+WrnSZ6f1rT7cIWVbYvhrQkipfrSJ4S7Kc7PAozb3xeuopQgpe2bjCKYGWDY7QGtpXPgtHBJdWyZSFx0gIPkFdfU0cA2zR2YnQbAjrzSgI4r8QxHMSXuFkVPF01Hi7F9wG9jjD3xNcbIk/dq/9mq//dWrERSLJQaKW78pKBcz4z/bqBbm2SmD+3gUKzUGs3M/nA7Z8v19M9KpXVynNVK44hao9njKsPvbsjld+dlBz0Tq1lSeQ6W/B4OrYTxT0Gfq0S6sr+UnRAVgy+41/+xnHHgOyjNg/gWogN4ANlvDSYOoNVGoXOduDnxK+grAjasVdzklwRsTInnOLIgKIvikJx0Bj6xgoFPrKi3IHu6aDpajF9cvp+SuhjGmSNyAmpdCIZQcjSmpynf9q/15L3af7bq/70VK5Gami5jbnzkZEk1T369h8IKPdcOyaaTk6rAzy/fx+GzFWS3SPDIGlNabSAmSutS/Ch8vfMkLZNiuOmCjt5OX+KO9a/Ars9g2B3QpnfgxrVYYN0rngUb+8PmukDiwTcG3O11MFANMx2R3hHSOoh4pOMboFtg6vIMaJ8GwI68EiwWi0e/L0lwUeJWLnx2lVWIqANfPY1rcRtXsnkhy3mB15Imkzn6j37P25HVw5d4E3WsirvAX1dxLfav9STORv3ZOhrbH6ESKTE40nLjJRaLhb8s2c5fP9rBqG4ZPDihp0NhY7ZYmPPpTvKKqujTLtUjYWMyWzhcUMH/Te3ndtufDhRwurSG567p79P7kDih7CS8ezUUHoTLng+ssAHY+6WIgel5eWDHVVN4sC5mRROUFF3FctO9bRDEDahcU6sDNmTPzGSidRqKqwzkF1cHbFyJZ7iydtw1ugtp8dFWF5K3r3dkObh/Qg+y0uIZ1T2DU8vmkVRzigcSv2HmiBy/LS9qy4Y/FiH1a91ZS1ztx/613lpSfH0PizfkOrS4RUoMTsDFTV5eHn/4wx8CPWxEYLFY+POS7aQnRvPXS7s7DaasMZi494NtxEZp6Z2Z4nGNm9xzlWSnJ7gtwrc9r4Stx4t5beYQeQUaSH59Cz68AYbcBENvDXx7hIozcPRnEbcTTH59S9x2nyisIAHEYrFY08CDYrkBm7g5siZgQ8ZG6ehd16h2e15JwMaVqNi8EOb3tcV6qXC14M0ckcP2x8ez/fHxThdkbxdMxYKxbOdJXjFcySkyYORsn8ZyNLYiHtyJEneiTnmtu8DfITnpTvejzOPF5fsbCA132McmefqaC59dZXX9lVQb6n2WkRKDE3BxU1RUxKJFiwI9bNgxmS3c9/EOEmJ0XNbXeRBoYYWePy/ZRlZ6PO3S4j0WH5V6I5W1Jh6Z5LoI39HCSr757RRv3TwUnVYKm4BQWwWf3S76Gk18FloEqaDewRUw8HrQBjE+ylAN298T94feGvDhT5bWUKE3Eq3TBK9Bq5Ixdfo3UUsoQAywBhWXBGxMiYq180Wc19r5DZ7yZsFbvCGXF55+kIpne1qFki8LplIjZol5HCsnrrRaMf0RJPa4s5K4E3WeZEydKKlmS26x2/04Ehru8CUjS5kTUM/ipnxuQETE4Hgdc/Pll657iBw5csTnyUQqNQYTMxduZEiHdMb2cp72++y3ezlaWEmPtsle9ZAymS0cOFPOM1P7uRRDB86U8/Gvebx9y7DAZ6k0V3Z+DBteFaKjw4jg7uvcYZFCHkx2fw41pcJiozSjDCAHTguXVOdWSUTrguTVTm4DGT2hYB8c+1lklQWA/u3TgFwZVBwsRs4WwqbOQqLGm7owr60+zIeGT0kyForxhs6yvl5ZQD2J51DHnqi3tY83+b9le6kxmLhyQDtemjGofgyL7gfbe1K5eB3Fldz7wTaW7TzJpP5iHPUchuSkezxvZ+/B2X6V7V5cvt9639fxvX2N+nN8/ItdmCz146bCidfi5qqrrkKj0bjssNuUXCUWi4Xb3vmViX3a1p0cHfPYF7soqqylX/tUorTenfQPna2gQ4sEWrqIy9l9spSvdpxk8a3DSY7zLJNK4gKLBVY/C8fXwYSnIdbP1G5P0Fc47i0VSH79n7gdcrOoGxNg9p0OcryNQqeLhbg5siZg4mZgtvjsd50ow2gyExUscdZcGTorIDFed43uwgc/XMNdUV+SlD1cuLrqxIU3FXc9EVSvrT5MtcEEwLKdJ3lpxqD6C/7ae23WKNV7czSPZTtPYrLYxlHP4cJnV/lUKdj+PTh7/74WFfRFNNrvSy1sfK2kHAy8/nVnZmby2WefYTabHf5t3bo1GPMMG3M+/Y1urZOdChuT2cJ9H22n2mCiT7sUr4XN6dIaorQaHp7kPHD14JlyvtxxkvduHSGFTSAoPwPvThWdsi99KjTC5tQOSA/y1czZvaIVhDYKBs4Myi72ny4DoGfQxU3gi/l1bpVEUmwU1QYThwoCl2YuCSwzR+TwwCPPk/TQPtGeROXq8so95SIGCGzxJtE6DRpgUv921v1b3SojZ0NqdgNrlKN5TOrfDp3GNo677X3Bk3F8CZj2NzBaETZPTOkbEVYb8MFyM2TIELZs2cKUKY6vptxZdRoTLy7fT0lVLdOGtHf4fEWNgQc/3Unr5DjapnqfbluhN3KmrIZXrh/sdJvjRVUs2ZzHe7cNl7VsAsHWd2HL/+CCe6Bl19Ds02IRhQCnLw7ufra+I267TwxoHyk1iuUm6OKm40jQaKHoMJTkQZrrHm2eoNVq6JuVwoYjRezMK6Vn2xCIWolg80KH7h2322cPF//XiQtnFgq1uwbEgrucF0iqOWW1uti7dJR4k6y0eH55yIkL14k1ytE8XpoxyGqxcbS9Mi/1/97iykKjvL9KvdEae+Ppfvxp06C4xPRGk9U1FgkCx2vLzQMPPMAFF1zg9PmuXbvy448/+jWpSOCf3x9gz6ky/nBhJ4fPv7h8P3/9eAedWiX6JGyMZjMHz5Qz7+p+TgOD84qqWLTuGG/fMpQUabHxD7MZlj8Me76AifM8Ezb6cjixFb76M3x2Gyy9y7d9H18PGT0g0XmvMb8x6mHHB+L+4JuCsotao5lDZ4XFo2dmkIVBfBq0qxP9RwOXNaXUu9ku424ChxsLCeAy2Njl9nkbPeo67rDCrnFyPauLvXViSE46Oo2t95g9/qaM+1Jcz9P9OtpGHehrb91xN6Y/hfhmjsghMTaKaoPZ64DmYOK1uLnooouYOHGi0+cTExO5+OKL/ZpUuFm07hgbj5zj9os6o3UgPJ76eg+HCyro2y7VJzeRxWLhwOkKOrZKJC3BcRO/M2U1vPXLUf53y1CXsTgSD6gshHcmgy4axj7mvspwaT58dCN8cgts+o9w8yS1EZlI39zv3b5rSmHHEpjwjO/z94T930B1MSRnBiWQGOBIYQVGs4XkuCja+SDovabz6Lodrw7YkIp7eacUN4HDE+HixL0TqO0dVdjNHPdHqzBylPK8JbcYk0XcOsLflHH713vqUnr8i12cKKnmxeX7nQoSZezHv9hlfV4Z//4JPRoIlUDXsrHHk1pFoUZG1NnxxfYTfLIlnz9e0tWhsHn4898orNDTr32qx/Vr7DlZWkNCjI65lzlO+y6pquX1NYf5743nedxjSuKEnR/Be9eKK7++17iuClyaDx9cB98+KCrl5lwAGd0hNQsSWkCbPiLjqabM8/2vexlG3AUxQUqbVthW5/IaeD3oglN4fN8pm0sqJEkDanFjNgdkyP7tRVDxvlPl1NQFkkr8ZORsiE8XAfPOrDdDZ9myqVxZeNTbO7PYOLAUqS0PDawQmxcy9ruxTKr9FhAL/eINudYFuVJvdFlc0Nnzzqwh936wjS5zl9EyMcZxcT3dDy7rASnxK0ADAaOem06DNTvJ/jPw9r04w1GKubNWEe5qFYUaKW5UnC6t4T8/HeGPl3RtkGptNlu47+PtGExmerZNdthDyhPKawycq9DzzNWOqxBX15p45cdDzBrZiXZp8T7tQ4KIc1n1tKj5MuH/XLuh9OXCSrPsPmjdG9qfJ9wi9mh10LqXcFN5wvENIli5/+98egseU3pC1OgBGPj7oO1mb10wcY9gx9soZA+D6ESoLICzuwMyZPv0eFomxmA0W9h7yguRKnHO0FkQkwQ1xc6tN5sXwjcPeOeacobaUuShSyyTAv4U/RVAg2yjkmqDNVbEnvIaB7Vj6vZ56ocFDq0hStbU7pOljsWGB/WAnpjSl/sn9GggYBRmjsixBjA7c6vZb58YG+W128iRRSbS+3QpSHFTR2mVgVsXbeb2UZ1pkVjfVVRjMHHPkm0kxUbROSPJ56tWg8nMwbMVPHdNf4fiyGS2sODHQ0wb3J6rBzsOYpZ4gKEallwvXEKXPgmxThZjixm+/BN8dJNwO3UYDrEeNIPUeeCKrDgjYmCu/Ld3c/eFHR+I95JzIbQMnkl4vzWYOESBuFGxIrAYRPPSAKDRaKzWG1mpOIC4cyOtnQ8WE2h0jrfxRKQ42pcXLrHMSXOtbRk8cZ2orSh3je5im+Oqp6A0j7uivnQ4lqusqcUbcnmh8nIq4jLZmHWTbWGvG3um7gdrcC+I7CNn83XlVnMkGly5xZyJDEcWmUBWIA5mqwYpbhDi5eb/bWLmiBwyU+tbSypqDPzlw+20T49v8Jw3WCziSrFb6ySncTpvrzvKBV1bcqNshOk7Jcdh0ZXQdZxoGqlxcoh//xi8N01YeDpeCEmtPRu/uli4qFxhMsCa5+Ci+yEmAF3EXWGx2CoSB9FqA/XdUiGj61hxq1imAsDAbHGlK8VNYLj3g210+awtH8ZNc+52UgTJ5S80KIZ34bOrqFj5QkOR4kzwqF1WnsTm1G2/2DSuQfE5RezcP6FHg5eprSgzR+TYhJQFSM0maewDVsuMWhy8NGMQh+dNcpg59drqwyyouJgJvMpfjwyxLewqkWZfy8aVq8mZyHAkGlyN9eLy/dY4H3cEsgu4+j0E2orT7MWN0WTm5v9t4or+7eicUf+qvaiylvs+3kGXjETSnQT+esqRwkoykmN5YEJPh89/t+sUqfEx/GVcd7/206zZthg+vhlG3S9cGo7QV4htzh2CrPOEpcMbS1xlAVzyiPPnLRb4+UVReC6YzTEVjm+AoiPCfROgYneOKKqs5XRZDRBCtxTYgqOPr4fayoAMOahDGiDFTaBQ3DAXnn7XuRVFJTAcZhDZZTYBtgX/mwfgk1kwvy8bP3qh/gLoKjbHDm8X/AbPKUJq7KMN9umpBcJR4PNdo7vUE2meWkZ8ET7OBITeaKp36ylKfNG9H2xr8JwnYkX9HgJtxWnW4sZoMjNr0a+M6NySfu3rV459Yfk+HvpsJz3aJvtdOO9chR6DycwTk/s6fH7r8WIOFVTy3DXuu4FLnPDjM7DrU5HmnZLV8HmLBb7+C3x0g8goan8eRHuZ8VN+WlQYduW62vEBtOgC5//Ju7F9RQkk7jPVM5eaj+w5KeJTclomhLaQZMuuopWEqRaOrQ3IkEqPqdxzVZyr0AdkzOaM4ob5pe0NDq0o6kXOWQaROrPJarHJHi7cWBaTaCtSmkeHPW/4vADWW/C9cYMpuBBSXgsS3Q/MXD+JX8YeFeJENXYgLCPOxnAmIGKjdPVuPUVdldkeb8VKoBtuNmtxc8e7WxjcIZ0LutSvP/L4F7s4WlhJv6xUr3pEOaKq1khecTXPXzPA4fNHCipYvvs0/71Rdvj2CZNRXNVVnIFxf3ec5l1+Gt6/Fgw1Ii4lKcP7/VgsUHgQrnzZ+TYntoqic5c+6f34vqCvECd9gME3BHVXe06VAtCnXYgL32k00PVScf/gioAMmRofTdfWQghK643/KG6Y6Xf93eHir17k7Bcw6yKc/yQ80QL+M1oE9pfmiTiry18QgqnPVEjN5njvO8hKi+efnbd4LU5m6n7gl9h7bf2iSvM4tWyeazeIvQjyRRQ5wkWskD/uGeW1936wzeEYzgTEqO4Z6DTi1hsCWZU5kO4uaATi5tlnn2XOnDm8/fbbFBYWBnTs87u05PwuLa3/G0xmZn8oWin0y0r1uzGg0WRm/2nRENNR2vjZshoWb8jl7ZuHea2YJYjA4femQdt+ogO2fXyNxQJf3gNf3A1t+4u0bl/7LRUfg5R2zmNoio6KCsHT/uedm8sfdn8Ohkph3VAquQZrV3WWm97BLt7niG6KuPlefKcBYFCd9Wbb8ZKAjCdxjpJxc1nNN1y1eoLNWqFm9+fCQnNyGyKoBTDpRY2a85fxwr6WVOiNDO/Ugl8eGkOfIwuhNE/E6niKWlCMnM0pMnjFcKXLejJKLJCyn6Llz0FpnrhV4bVLxUGskCJMlPgXV2M5E0DKPJbtPOlwDGcCwl3NH2f7dRZf5KzBZyiJaHEzdepUvv76a1q3bs3s2bNZtmwZgNftHfR6PWVlZfX+AAbWneBAVF/9y5LttEiM8SsjSsFisbD3dDmdM5IaZF8BlFUbeG3NYd648TxSE2T1Ya+pPAfvXAW9JtuCTtUo1hqzSVhr/HHZGGtEuvWVLzl+vvy0OGHO+MCnejZ6vZ6KCh96HW1dJG4HzQy6oFLcUn3apbrZMgh0GgW6GCjJFdazADCogwgq3pbn+mQugbKyMvR6H9x3mxfCcx2Zufpifq/7gZstn9vaIdQ9x7Mdxf0+U4ULqt0goO5Yjoq11qi51bDY9lrgNeNk8i2tRKyOp4ycDXHpUCt+aysnrmR18pWASA8/9cOCBlYZ+/38s3oS+ZZW/LN6Ur33uZy7+WPSGs9dKnWi7cKVnRrEHwE265T6M1LhTEwp1pJJ/dt5lRnlqZXFUxEXzCwoT4lYcfO3v/2NgoIC1q5dy3333cewYcP46KOPOHv2LEVFRV6NNW/ePFJTU61/2dn1+9TM//4A9y7ZRlZ6PBnJgSmad+xcFS0TY5gzsWEAcY3BxMurDnLzBR3JkrVsvOfAd8JiM+JOyB7a8PkVj4hWCW37Q6uu/i/8p3dB2z6izo09ZiP89CJMW+h5xpUd8+bNY9gwJwHQzjizB/I3i+rJA673ab+eUl1r4nBdo8neoXZLgRCMOReK+we+C8iQyoXNjrxSTOam0QsvWGRnZzNv3jyX2zi0JKydL7ILa4q5K+pLPoi+hoq4TFsKd91zrJ0vfj+PF8Htq2HSP4RVY8yj1ho1Wo3G9logc9wfmR7/XxGro+DOZTR0lrjIqRb7VKwY1vTwqC8buIrs91PW90Yurn2Jsr431nufSTWneCDxG8+sFHXC7srvLmB0+VdWUfXPzlvqVRgefmKR9TOqWPlCvbRxZ2JKeU8vzRjk1MXjbWC1Gk9FUKDjZ3xBY4nALpdGo5H333+f8ePH07ZtW5588kmefPJJnn32WcrKyigqKuLKK69kwoQJHo2n1+vrXXmUlZWRnZ3Nyh1H+efqPE6V1tC9bTLx0YFxDZ2r0FNQrudf1zVMBazSG/n3qoNMHZglU759oeIsvD8dxjwsatOosVjgq3tF/E3WYHG17y8lx0WRv2scnDAtFvj5H+Jqc+RffN6FXq9n586dDBs2jLy8PNq396DG0bdzYOPr0PMKuO49n/ftCdvzSrhqwS+0Soph88PjwhMbtvENUTk6ZyTcsszv4UxmCwOfWEG53sjX94ykb1YYLFIRzt69e+nduzd5eXlkZGQQG+v8wu/CZ1cxuvwr/hT9FZmT5toCg1c9JbxMYx+1PaY0xDy8sv5zjvCm4eb8vkKcxKULEePoNer9522sv03dcx/GTeNvx4cyqX87q7tFcbP8s/MWITocvM7jpqDKPIFTZJAcFyWsUqnZImZJPddVT4FBT4lRywuG37Es5jK2p/xVvF6ja5Ba7wmR4DLyh7KyMlJTUyktLSUlxfnFVkRabqKiopg5cyatW7fm1KlTFBYWcuDAAe6//36uu+46amtr+frrrzF7WJI9NjaWlJSUen8gekQVVdXSr31qwIRNda2J40VVPD+tYQBxabWBf3x/gGuHtJfCxhfKTor2CBf9taGwMZtEPyijXpy4AiFsakpFS4apbzh+fttiEYfjh7ABcXwmJXnhNquthO3vi/vn3eLXvj1BcUn1ykwJX9B797oLmePrxdWsn+i0GoZ0FK6pTUe9swQ3N1JSUhwLG5Wl5K7RXYSwocBm+Rg6C+Ycg4eO2RZgdUNM9XObF1LxbE9eePrB+tYfb9o2KHEsGpwH65rGcaH+JSoO/VJ/G5VA+dvxobYMILtqxB32vAGleZQue4yKZ3uK5x24mFySPRzQgDaazDgjSV0vdFyrR/n8EluSRgVPRL3NNMsKsZ2SReZDteeZI3KshQI9ma+7IGVvCWZVYjURKW4AtFotWq2WzMxMXnjhBTp37oxer6d3794MGjSIDRs2UFtb69c+DCYzPdr43krBHpPZwv4z5Tx1Vd8GAcSF5Xr+9cMBbrmwI9cPb3xqOeyU5sOS38OoB0TfJzUmo0jxTmwFrXsGJv7EbIJTv8HUusaZ9hz4DqrOBb8hpiN++wT0ZZDeCToHp0mmml0nlUypMFo30jtCRi9xQj/4Q0CGHNpRFGPcfEyKG59QBejOHJEjLDbuCuqp4142L6xXxC+p5hS3GhYz9rux9evZrBQVgVn5lPNx1RYZC6LXlYN5OK2ro3ovk/q3QwPERGmtAcVKNeLjve/gFBmYLZb6MUB147oKTraStxGwiKriNcXWzuf2NYDUn5kJLVEaM7drv+DClZ3Y2MuDz9oF3sTEOAtS9lWkhCoeJ+LEjSMvWUxMTL3b0tJSOnfu7PdVZMdWiQG7ErVYhLDJTo+ndXL9+ikF5XoWrD7EXRd3kW0VfMFkgE/+ABfPgVS7z8+ohw9/L2rXpGU7fr0vnNkNLTs7rkZ8+jdRc+Xq/4QuM0rBYhGdygHO+4Pv2V9eoHTQ7t8+zK4bpSjivq8DMtzwTuK73XS0yOskBQm2OjRKpp6qVovThc8u7kVZ6NbVdsWMljiNkUwK6tezUX5irn5qijjZ/bkQDDFJTuvRpMVH855pHIvPr3NvKjV16sTCSzMG0S4tnqvNKzDVlEN8urUa8fDfPcDKiStZoLmek7RiY9ZN1nGV+MkTJdU8unSX807aioWpz1Qq4jJZUd6Rimd7Ou1VxdBZ/DPqNvItrfi3/gpOlFRzx94BHhcv9CeAWL2tfZCyryLFft/BsuREhLj54IMP+O9//8tvv/3mMGtEESCnTp1iwYIFvPDCCzz88MMufcChJq+omqSYKB6e1Lve42fLa3h19SHeuGEIVwxoWAtA4gFf3gs9LhfdudUYqoWwadGp4XP+UHYKsMDlLzZ8ruIsbH4Tfveu4wDjYHN0DZzZJer5BLm2DYjgd6WnVL9wx6X0rMtQOfSDqFnkJ/3apxITpeVcZS1HCgNT/bhZkbdRWNLyNjZ46tQPC/iw+jYRLGuPynqjBNFeEHMILWbi4xLq1bO5a3QXEVgcny4sMnauKWVh3Jh1U716OPX6Nqlo0EBSLYpUMTN3je7Cg9EfkUoFlXojXT5ry70fbLPGq3yiGc8FNS/x1yNDrOMqwck6jZiqdR91LrcVT14hXFm568Rkci5gAq/S27SXpJpTTntVgS2w+TPteLdfi71Y8CeAWL3tSzMG1XNneSKQnHUQV+87WJacsIubKVOm8Nxzz7Fs2TKmT5/O008/zcaNth+LckVlMBhYsGABr7zyCj/88AP9+/cP15QbcK5CT0Wtkf+bWr8C8dmyGl5bfZj/3Hge7dOD3GOoqbL8YdGo0j7d22QQMTatuvucpeSQ2ko4dxiu/q/j51bPE66xuDBkDQGse0XcDpopTvhBZv/pcgwmCy0SY2ifHubMvsxBkNxOuDSO/uT3cLFROmu9Gxl34wMu+jr9xbyI9ppC/mJe5Pi1+jKoLmb4iUX88tAYksY+UK+1wfDfqfo2mcZxqjrKYddxZWH865EhwrXT/jEu1L/EHXsHOF0wG7Q9cBC/MnNEDqnxokRHrclsjcFRatDojSaHC/vMETk8MaVv/U7addlUY0y/CFdWXbXlipUvUKk38rZGWHB2d1ZZYewyvxRB8PCk3taMKmexMI6qQP8xaQ3Ludvv4oOe9r1ytL0jFm/IpVJvJD5aS6XeGFDrTVjFzZo1azh06BBbt25l6dKl/Otf/6KwsJAFCxawbp1Qt4rVJjo6moceeohVq1YxaFDDLKRwUakXFYhfnNa/noursELPa2sO898bz5Pp3r6yeSEUHxUF+tRYzPDxTZCeI+JsAoXJKKoMX/Vqw4Dk2ir4/lEYehv0uCxw+/SGk9vh0PeiWOHwO0OyS8Ul1S8rNfwVtLVam2tq75cBGVJxTa07fC4g4zUrXLQjiDbr691a2bxQ9IqymDCj5YXKyxsuaMrC/skseFakTG8ydeMUGcJ9pOoxNSQn3aGrpLTaQFp8NENy0l1bDobOslVBthdpXcZiRMtPZpEcoq7CGxulq7+wq8RIg07aI2dTEZfJKt2FFEW1YYXmAiriMnnNOJmSagPfxl1O0kP7nDbSVKOeuyK0vtxxktHlXzHmuzGweSFDctLRaWBITrr1NQ8kflMvRshXvE3xdrf9a6sPU1JtoNZotlm6AkRYxU1KSgpt2rShqqoKs9nM+PHjueOOO0hISGDJkiXk5+cD8O6777Jq1SqSk5PJzMwM55TrUak3sv+MUoHY5qIoqzbw6o+HuPPiLrSTwsY3DiwXfZpG/rVhXMunsyChpchUCiSndkBGT0huW/9xs0lYbAbfDAOmB3af3vBTXTXWfteKhp8hYGe+CCYOe7yNQq+6om37lgkx6icXdhXi+JdDhZhlvZvA0fcaYRHpe431ocUbcjm1bJ6wkmh0/CPqNhZUXCwWtFV1QcOrnmoQP5NKBcN0B1k5caVwgal6TG3JLa4nMu4a3cXqFkqMjWJLbrF3Lg+1xSRvI1GYGaI9QFp8NC/NGMT9E3rwx6Q1rI29t74VxF6MqMcZOoukh/Yx/rGvuTLqdW6vuosJvErmuD/WW/idNdL0hLuivqQdhbB2vuNqwy4qIntjLVHEFeDRa9VibPGGXAY+saJeLJInRQd9JaziJiMjgz179rBo0SK0dYGRw4YNY/r06ezYsYN9+/YBsGPHDtq0aeNqqJBTqTdy4Ew5z13dv14F4upaW4G+K2WMjW+Y6grjXTxHVClVs/Qukb3UolNg93nusGitMNGuWJnFAutegpwLYNDvA7tPb8jbXBdIq4GL7gvZbn87IcRN2ONtFHIuFMK2ughy/W+kOahDOokxOooqa9lzqiwAE5Rs/OgFTu1aw9E244UYqRMBr60+zCuGK4UF5vIXrIv7PztvgeoSQMR4vVB5uSjY12eqiM2JTydz0lzRE0pfAfHp1LQ9j/VxfxavVaG4hRx23naGWpjYtWioiMvkg+hruH9CD+v4Dq0gduLBvm2Dgno+9m6dBhYlNwHDSvHByQPa1SuQ6PA9OxhP7TLyVuj4EiejWGnUFhpPig76in9dIf2kffv2vPHGG9x+++2kp6dz/fXXY7FYuOSSS/jwww955513GDduHM8884w1UyoSqKgxcvBsOc9PG2D1ywLUGk28tOog1w7JZtp5AczcaU6YTfDhTOgzpaEF5eu/iLiXTMdNSH2m5LioafO7d+s/bjGLE1iLznDxg4HdpzdYLKLqMsDA30NGj5DstqpWCHiwddIOO7ooUbhw6yLYvRQ6j/ZruJgoLSM6t2TlvrP8fLBQFvPzFVWdmOw9r5NJIcbTy4G639DQWXXBqFfSa/RfmInoij2z63DY9SnC1qLhZWawoOJilqZN5JdpY+qPXXkOjFUAdKr+DrCQuXcebBauxYqVL/CacTKjumfwS+wi0M22dtl2iVJHR50WPnI2i03jeI1O3DXOrthd9nDMpSf4obwjZ61xLp24a/QyZg6tC5I1TmaG5VM+ME7mAdWuZo7ICdgCXn+sQcDz4vG659wxJCed06XVDMlJbxBL4w4lsNgbS8tdo7vw4vL91vvBJuwBxZMnT+bJJ59kzpw5vPnmm1a/fqtWrWjVSpiMI0nYlFTVcvBsOS/YCZsag4l/fn+Ay/tmMvN8WcfGJ8xm+PhmaD8EOl1c/7lv54geTpkDApt+XX5GjHvtovrjWizwy0uiKeXYxwK3P1/Y/j7kbYCoeFGZOUTszC/FbIE2KbG0SYlz/4JQ0ecqcbv3SxFY7icXdRPnmbWHCvweq9mhuF8Ut9La+bzFVPItrVjB+fWsGfUsE2rXk9IoE9GV2t7qoFhBLMZq1Y7rXmMxiRieVU9Z6+QM2fOM0yJ+DnFiJXFqncjbiBYzvU17eW31YV5bfZjR5V8x9ruxViuVkt00qntGYLqI43vKtLPXqd1Xoejg3SAWKciEXdxoNBpmzZrF888/z5///GcmT57MtGnTePnll7npppvCPb16nCqtJq+4mn9NH0SKStiYzBZe+fEQUwZmMeuiALtLmhPfPSTERPeJ9R///jE4dwiyhgRW2FQXw7mDQtio07otFtHaIKk1jHkkcPvzhbJTsPxv4v7ohwIfZ+QCxWevBCZGDB1HQUIrUUTx6Bq/hxvZLQOAzUeLqa41+T1es0IRKRasQqbjxHu4Qvsaf9P8pX4tGfUCr6r1Qlw6FjSAhT5HFjZYNF8zTqbYkkgNMaIEQlSCyBTsO82W6WSBirhMtBoNUZjF4+7iVRxVRVa5pf7ZeYtD15faXaW4vuyrMyuL//ATi1wLLQf9sBZvyOWFpx+0VUBWPgcHIkrZ3pXocddk05GLrCkQdnEDot3CjBkz2LJlC1OnTmXMmDFs2rSJAQMC7H7wEbPFwqGzFVTqTbx83SDiY2wLocVi4X+/HOWCzi25SbZU8J09X0LhfnGyU1N+WhTNa39eYOvKVBfD6d1C2KjjehRXVELLhvE3ocZkgE9ugZoSYbE6/08h3f2240LcDO4QYeJGF2Wz3vz2qd/DdclIJCstnlqTmbWHCv0er1mhiJS6FG7FDeSwlozSQmF+XcmM2btEw8yHjvG9diRGi5Z1tV0b7CKvywwqiScePRW6VC6Meo/FF68Rr1UyncY+StJD+0id9KT435OeS3Up2jMMn9oWflXszPATi8ikQAgUBwHCDzzyvNU15LQ6s7vAYAdZUa+tPswMw6ck1Zyq1zDTYYsL3Me/OLPKRISgcdfs1A8iQtwo9OzZk1tuuYW7776bHj1CE1fgjupaEzvzS0mKi+LFaweg1dosBwaTmbfXHaN1Shx/ubR7GGfZyNm3TPxYL/hzfcuMvkwEEGcNbhhY7A/VJULY/O5tiE22PW42wZrnIKM7jHdR6j0UmM2ieOHx9RCTDNP+Jxb1EGGxWNh6vASAwZFmuQFx1Q6w9yuRpu8HGo2GS3uLhIUVu0/7O7PmhROXTr10ZHUlYyetFEZpdxClMXOp+Wd4tmO9xW5LbjGvGSdzigxeM06uv5Db799ZIG5dJ+56Y4+cTU1UCsmaGpt1RtUnyloYUInJsRdo6gXZfr/2Is6Z0HIgfu4a3cUaIKx+v2oRpS5S6M6lFBEixhlOUt4DQUSJm0jjbHkN+8+U06NNMn+/sk+954oqa3n22330y0rl6av6OhlB4paKApHiPPYxSMqwPW42iToXbftCTGLg9ldTJixB174NsapCfEY9rHxSuL5Gzw3c/nzBUCNE3Y73xaJwzX9DlvqtcOxcFUWVtcREaenTLkwFC12RPRzSOkBtOez/xu/hxteJm5X7zmKSKeF+Uy8dWV3JWLl2MenrCYS4usbFGmhQrO+u0V1YnXwlKyeubJA+DXh29b/yKWGtVY89dBZxiamkUiGsM3XYFwZk6Kz6As3dgqzU8vFk0XYgxmaOyOGBR54n6aF9Dd9v3fbqmjjhFi9+tU/wMuXdG6S4cYDeaGLPqTJKqwy8MmMQs+2sMjUGE6+uPsSskZ24+5KGZlSJhyhVhkfObliM77PbREuFQFbh1VeIWjbT3qpfYbimTFRC7nlFSNOsHaHL3wj/vQR2LhEn06mvh6VooBJv0z8rlVhVDaeIQauF/teJ+zuW+D3c0E4tSI2Ppqiytn59EInXKFVnrRV61QvYmEfFfV2sra7N/L7QZaz4rUcniPRv1WI3U/cDv8Tey0zdD7aFXPeDTdB4cvWvUd0ZOdsmiFQ9pRQcWkLUAk15P3UFBRuIqrXzrbV8GDnbr8XfmXDxNgA4mPjVPsGDlHdfkeJGhdliIa+oir2nRAPMf/xuIFG6+h/R6dJq5n9/gKmDsrhqUAD7GTU3LBb4/E6xcLfoXP+5r/4sYl/SOgRuf7WVcHKbaKugFkzlp0Xl4eG3w9A/BG5/PpL4xS1wdo+I+Zn5KfT/XVjmoSzwEemSUhhQJ24Or4Syk34NFa3TMqanaOMhXVP+odQzSYyNalizRbk/tk7kWBDCJG8jzDkGD58SzynuH3AsXtSP2TfwdIQiqib9Q8xBeX1dR257y8kvY48yc/0kYT1WRFB8urhAAvGauoKCDUTVyNli2zrLcDB6J6kFX7iJJKGlRoqbOir1RnbklaDTanj194N5YELPes/XGs18siWPxRuP8+/rBnHLhTIrymfMZmGZSW4DXS6p/9zyv0HFGWjbL3D7qykTbRWmvl7fQnRmt6g8fPGcepVUw4lFGyPaTfzp14afTQjZeFS0IzgvksVNyy7Q4QIhhLe/5/dwE/oI19Q3v52S1Yo9xYFLqMFiZ7+NqiaOVeSo3RL2YsaR60ItaNRWFfW+7IKA64kYTwN96/pAkbdRdBpXu7Wciaqhs+pt69Xi72mArSeusSAF6toTbreYM5q9uLFYLBwvquJIQSXzru7Pk1P6orVLNz5ZUs2z3+6lfXoCH94+gg4tZRNMnzHWwpIZYmEaMKP+c+Wn4exeaDc4cCnfNaU2V1SSqsr1oR9g22K44XPoPiEw+woA5besFleXCS3CNoczZTUcKahEq4HhnVuGbR4eMfhGcbv1XSGa/WB0j9Ykx0VxsrSGTcdkI02PcLDINrAq2G+j/t+RW8JeeDjaxpGbyD7w15UAGDrLtv3mhQ1dR+pUdWVs+3m56Iqu3tarxd/TAFtn4sxB3aHmSrMWN9W1Jn47UYpWA69cP6heGwWF4+cqefPnI7x181DuHdst/M0DGzOGGnjvGug0SsS3qDHqYendIjMqUFlB1SVwaqcQNoorymKBX/8Hp3fBDUshLsIq0salhXsGrK9rItk3K7VeocqIpPcUiE2Fklw4vMqvoeKidVzeV/SuW7rtRCBm1/RxtMg6srzEpYtu7psXureaeBKHoR5Dvb3iEtJXCIuKer/2KPNc9RRjvxvL6PKvGmZhTVvY0KXmifXH11gSTwNsnY3voO5Qc6VZi5ujBZX8/co+PH1VP4ei5UhBBe9syOWdWcNpHUkVWhsjtVXw3jTofZUQN2osFvjkD9Cqa+AyoyrOCrfTtW/bhI2hBlY9LYKJpy0MaWp1Y2LdYVHr5fxIt9qA6Aem9Pza9Ibfw00ZJIokLvvtFDUGWdDPLZ5aXmKTRLaSM2uNp24UdynWapdQ3sb6+7VHmacFMingT9FfOXcdfTILnmghbpV5KK61QATDepo67g4HdYeaK81a3Lx47QCHosVssbB6/1k+3JzHu7OGO7ToSLygtlJYbPpNg+xhDZ//7FaIT2vYS8pXSk9A0RG47n2bZaaiQMTz9LgMxv09MPtpoqw/Iiw353dpBOIGRIwSwMHvRQNUPxjRqSWZqXGU1xj5fs+ZAEyuGaIWL/ZZSa4yjDxxo3iynVpceWJdqYv7yZw01+Y6shdbuz8XLqjdn3s3X09x1VXcG1xZjEIYhxMJNGtxgwMPU3WtiX+uOECl3sTHd54f+Wb5SKe2ChZfIxo+Zg1p+PwXdVV3A1XHpegYlJ+C6e/bCv8V7Icfn4aL/grn3RKY/TRR8oqqyCuqJkqrYWjH8MX9eEXLLtBtAmCBdS/7NZRWq+Hauqa37/pSt6O54W7BtM9KcpVh5Ikbxd7F5UlBPXc42t5ebPSZKoKHlQrqaveXOlB6fl82fvSC96nf9u8/GMXtglgwLxJp3uLGjrJqA//8fj9XDmjHE1P6NEgDl3iJsRY+mC4Chx118l7xMFQVQuve/u/LYoEze0RRt+mLbS6no2vg17dEWnUY6sU0NlbvPwvAoA5pJMY2IrfdyL+I2+3vicB0P5gxLBudVsOmo0XsP13u/9yaMu4sDvY1YRzUlQE8FyT2Li53C7avC7r9vHMugMeLhDtbmYd99lTdvjrsecO71G9HLq5gFLcLYsG8SESu3nXsyCth/g8HmDkihxtkV2//MZtgyfXQ43IRJGzPyieFGGk3yP/MKLMJTmwRlppp/wONVoidbe/B8Y1w4xeBLQbYhPl+rxA343q1cbNlhNHhfLEQmWrhl3/7NVRmajyX1r3/dzccC8DkmjDuLA6KaFEsNrs+tdWKCcQ+3S3Y6uc3LxTtF57r6N41Yz9vVzE7yr7r/j/e+w7v6r44EmCeij1vXE1BLJgXiTR7cVNrNPH2L0fZfKyIj+8832qSlvjJZ7eLBafjyIbPVRaKgnrtzwOdn24/ox6Ob4DU9jBlgXjMbIK1/xSi6Xfv+L+PZkJ5jYH1dcHE43o3MnGj0Yiu6QCb34SSPL+GUy5wPtmSz7kKvb+za7p4mkE0crZw62Bp0F7Br3266iWlDtAF0RKhpth5gLEjvMmIqvt/+O8e8Dz1e/NCIfbi032zqDQzV5M3NGtxU1Vr4oXl++nfPo3/3HgeCTGNyAwfyax+VmSxdB/f8DlDtRA+7QZCdLx/+9GXQ94maNMHLntePGYywI//J1xdE+cFrl5OM+Dng4UYTBY6t0qkS0ZSuKfjPZ0vgY4XCevNqqf8GuqCLi3p3z6VGoOZN9ceDdAEmwF29WPqPX75C2IRj/NxIfcG+wadSksENGIO6sBmV9aPYFs71s4XgqumzLfXN1ZXUwiCm5u1uHn1x0NcN6wDd0ZY2ehGzbbFopP1eQ5OBmYTfHwzZPSo343bF0rzRQ2bq/8Llz4pHjNUw/ePQZcxcPGD/o3fDFGygxqd1UZBo6k7FjSw80PIXe/HUBruGdMNgHfWHaOkqjZAk2wGOLMmDJ0lWiw8dCxwYkFZJJU2CcpiqVzTKLeKCJj0DzEHtbspnNYPxaJlMbnfv6/B05GYJRWCz7xZi5tpQ9ozY1gA+xc1d4qPieDdS/4GWl3D5z+/XaR7q7t/e4vFIurXVBXBjA9t7RQMNfD949B/Ooy4y/fxmylVtbbU50sbq7gBEd+lVC3+6s/iuPCRcb1a07NtMpW1Jl4NYF+gJo87a0IgF1v7NgnKYqn0khrzqPjflfvMk95UwUKxaHliffFVEESi6yoEFqfmLW5kfE3gMFSLq6eL54jOvvZ895CIj0n3I1jbWCOuuKITRHE+JSPKZBBuiAHXweAbfB+/GfPtb6ep0BvJaZkQ2f2kPGHc3yGxNRTu98s9pdFomDNR9Jj73y9HOVLgZyBsc8GdNcHZYuuL6FEWycz+9QWKuzmonz+0UlhODq30fL+BxFPXl7uWC84+t0h0XYUguLlZixtJgLBY4NNbYeAMSGnX8PmqIlFrJrO/7/soOwV5m6F1L5isqmViNsGaZ6H7RBhyk+/jN3M+3iICcKcNbt/4W4wktIAr6zKm1r8C+77xeahLerbmkh4ZGEwWnvhqDxaLbKjpN+rF9pNZ8Pc0+L9M1/2QHC3g6hTqysKGfZ48FUv2LqxIxV3LBWeWmWaWJaUgxY3Ef358BpJaOzbrWiyw9E4hbLQ+BGybTaIPVMVZmLEExj2hGtsMP70IWefB+Xf7Pv9mzvFzVWw4UoRGA9cMaR/u6QSGnpfD8Dr35Ge3i2PIRx69ojfROg1rDhTw8a/5AZpgM8FdnMjuzwELGKpc90NytICrH/Okx5Uz7F1YgSQU8S6RaJmJAKS4kfjHxv/Aqe0w5GbHz391DyS09K1BZVUR5K4T2Q2/W2SrOAxCNP3yb2jTWwYP+8lbv4hsoJFdW9Euzc8Mtkhi/FOQM1IUdnxvmmjJ4QOdM5K4b3wPAJ74aje55yoDOcumjTuB0WcqoBGu5rGPOs60AsdxMc6aZzp63hXBtGyEIt4lUPMPVeBxiPYjxY3Ed377RFx5jX5IFM6zp/y0+GvZ1btxzUaRCVV0FK5dJDIc7Nn8X0huJ4KXJT5zpqyG9zcdB+DOi5tY1qAuGq5bDBm9REuOt6+EwkM+DXXbRZ0Z1qkFlbUmbn9nC+U1hgBPtpHiT7zH5oXCjTTpH/DwKbE4OxMDeRsbup0iwd0S6niXYAqDUAUeB6qPlhukuJH4hqEa1i+AMY+Azklj0W8fFPVmPI3hsFig5LhI4U1qDde9Jzp427P9fXEVN+Fp3+cvAeCNNUeoNZoZkpPOBY2lUaY3xKeLCtWtukNZPrw1QcRueYlOq+Hf1w2kdXIs+8+U86f3t1FrNAdhwo0MT+I9nFljHL3WVRFA+8c97Wvly2Lt6YIb6niXYAqQULm3QtFHCyluJL7y5b0iO8mR+ABRlMpQLbp9u8NiFjE1ub+IjKrrP7IV5bNn91KoOgdXRFBaYyPl0Nlya3O/P4/t1vgDiZ2R3AZu/gYyB4peZm9PEq05vCQzNZ43bzqPuGgtaw4UcOfiLdQYTIGfb2PCkwXR2eLlqPmkIzHwySxRXTh7uO3xzQvFY6V5IhDZkRDxNbvI1Zx9ef+BxNFnFihCZQnztKq1n2gszTD8v6ysjNTUVEpLS0lJcbI4S5zz4zOiiJ6rejKf3Q7xqZCc6XwbfTmcOwS1lZDQCi57znUPqH3fwNk9Ig28iS3Ee/fupXfv3uTl5dG+ffCDek1mC9NeX8e24yWM7pHB/24e2nTFjYK+Aj6/A/Z9Lf4fOFMcc7HeVWP++WABt73zKzUGYfF69feDaZMSF4QJhxflmPT7POmoMaTC/L5CRKRm29ok2PNEC+GS0uhE80r160DE6xiqXI+hnkdthWjB4Gp7V3MON558Zk0YT9dvabmReMeuz0Qvp+F3ON+m7ARUF0FS2/qPm4xCFJ3YBsfWQuFBaNEFZn4GV//HtbDJ2wT5m+saYzbxRTgEvLzqINuOl5AcG8W8q/s1fWEDQsT87l245BFAA9sXwxsXeV3J+KJuGbx9yzCS46LYklvMpJfWsny3f53ImzSuLAKeXLX3mSqETZ+p9V+nqSsUqov1rgieq6wsT+YcbmR2lEdIy4203HiOvgIWXQmXPuFciFgs8P61kDkAYhJtj5XmiwrGqdkwei6kuLDo2HPuMGx4VcRO+NuPKkIJpeXms635/PWjHQC8MK1/82wWe2wtfHaHiMMBOO8PMPYxr7rHHyus5I53t7D/TDkAY3q25r7x3enTzofMwAjEI8tNsC0crsb3dt+RbI2ReIyn67cUN1LceIbFAkuuF8XysgY7327536DijGhmCSL25swu4Xaa/LL3HbqrS0S/qN9/AolNMOC1jlCJm49+zWPuZ79hMlu44+LOzL2sV9D2FfHUlIrjddti8X9CS5F9N/hmW/Vrd0MYTLy86iBvrDmC0SxOpRd3z+DmCzoyqnsGOm3jtYh5JG6C7SJp5i4YtzRDwSbdUpLAsuIRcYJxJWxACBulSnHZSSFsprwKU1/3XtgArH9ZxPY0YWETCmqNZuZ9u5cHP9mJyWzhmsHtmTOhZ7inFV7iUmHKArjpK2jVQwSqL7sPFgyD7R+Ith7uhojW8cCEnqyYPYorB7RDo4E1Bwq45e3NjHxuFc9+u499p8uabmVjT10kvqb7+hMU7O++GwOR2DcqQpCWG2m5cc/P/4RTO+Ci+9zHuyy+BnLOF/E0tVUw7S3fRA3A0Z+FOLrqVd9e34gIpuVm87EiHv9iN3tOlQGins2DE3qgbcRWhYBjMsCv/4M1z4mMKoCU9jD0DzDw96LhqwfknqvknfW5fLo1n5IqmzjqkpHIxL5tGderDf3bpzUKi07AAooh8BYYb8ZrytYfablxup0UN1LcuGbrO7DrU9GM0JP2Ce9MEdkL8WnCYuNroGrFGZGVdfM3EN30MlHsCbS4MZrM/HL4HP/75Sir9xcAkJ4Qzbyr+zOxr2cLdbNEXwGb/iNivCrF54ZGC51GQc8roMsYaNHZ7XGtN5pYufcsS7edYPX+AmpNtpo46QnRXNC1FSM6tWBwTjo92iQTpYs8I3pAxU2gF2FvxmuGAqApI8WNC6S4Eej1eubNm8fcuXOJjY1tuMG+b2DtP2HCM54H8urL4cenYeJzvk/MUA3fzYWLHxAxPkHG7ecQAnwVNxaLhWqDicLyWvKLqzh4toJtx4v56WAhRZW1AGg1MH1oB/56aXcyksPz/pwRCZ+9Qww1QtRveRvyN9V/LrE1tBsomri26AKp7UXJg4SWQtRH1X8f5TUGVu07y4rdZ/jpQAHlemO952OjtPRom0zX1kl0yUiifXo8manxtEqKIT0hhqS4KKLDIH7ciZuI/O6CKGT8er+NUGBF5PeLFDcuKS4upkWLFuTl5TVrcVNWVkZ2drbjz6EkX9QEGfUgJLVyPdAX94C5Fq56zXEbBm/Z8Dq0Py9kXb5dfg4hYu/evYwYMYJNmzaRmek4k2zVgULeWJuHwWTGaLJQYzJTU2u2BrLakxKnY0KvDK4dlEn79Mi0fpWXl9O7d2/27NlDcnJyuKfjEE3pcaIP/0BU7k/oTm9DY3Ydi6MfeBP6C+c4fM5oMrPrVAUbDhfwxqcraNltMFW17isdR2k1xERpiNZq0Go06LQaNBrRyFqjqbuv0aBVPaa1f165T33Dk6MyABoNVJ47zboXZjn9XVSv+w9nv/g7raf8nfgLbnf7HkLCguGiFEVcmsjWHPFHGHJjQIb26zyhzCslC/640f32EUAknBcdocyrsLCQli2dx2I2S3GzefNmhg0bFu5pSCQSiUQi8YGvvvqKK664wunznuU7NjG6dhWNHBd8tpqEJOdXi2fLqlmyOY+s9AS7x2uIjdLxh5GdgjbHkyVV7D5ZxnPX9A/aPhrDVXMoiITPITc3l5EjR7Ju3TrS0tLCMgdn/PuHAyTHRdMzM/CfTXVVJfdMv4yXP/yW+ITEhs/Xmnhp5UG6tE4iygur4IGzZTw40bdssMXrc3l15hCfXuspFRUVDBs2jE2bNpGU5F2F5FCxb98+rr76alasWOHQVdoY3kMgke83Mjh16hRjx46lb9++LrdrluJGpxOVLVu1yXQtbkylJLesJSG1frxJ2yQTp0qqadXGi0J0XpLcwsSvBblBrXmi1+t5/PHH6dy5c0T5VENNJH0Offr0iSgTMIB+Qzmj+7alVVLgP5vaWj033H0fnXv0Jiam/vgWi4W/fbaLXr16kRznXcZdelQFCa1zfIoxSjmmoVev4Nb/UY65/v37h/2Yc0evXr0cnoca03sIBPL9RgbKBWhUlGv5Enkh+hHEN7tOExula/B4XLSOGqM5qLUrYqN16IPcdTg2Npa///3vEXXghgP5ObjmXGUtLROddH73k5iYWG780wMNhA3Ac9/uJyFW57WwAUhLiGbhz0d9mpNGo8HkJI4pUDSFY64pvAdvkO+3cSHFjQv0RhOx0Y4/oqTYKBasPhzU/WsAc5BPshKJKxQBH+reUy+vPEhRVS3t03xrt5EaH01ptfsifM5ee7a8xqfXSiSSyECKGxfoDWaHlhuAzNQ4TpZUB1V8tEiM5URJddDGl0jccbqshrQEH4sw+shrqw9z7FwV3Vsn+SyqonVajGbfLJ+tkmLIK5K/O4mkMSPFjQvMFovTSqJROi0tEmOY/8OBoO0/My2OxRuPB218icQdSzbl0T4twf2GAcBisfD8d/s4dLaC7m2S/C5sF63TUuaD9SYjOZbvdp/ya98SiSS8SHHjBLMH8TStk2M5V1lLda0pKHNomxLH6VJ5BSkJH/klVWSlB78T+2s/HmbOp7+hN5jp0y7FqcXUG5Ljovjvz0e8fl2r5FgKyvV+718ikYQPKW6cUFZtcFsVVKPR0D49nme+2UNtEIJ/M1PjOVUqff+S8HGyuIYsH+Ne1JTXGHj66z08/90+jhRUUF5jwGKxYDCZefKrPRw9V0nnVolkt0hAG6D4nuTYaCpqjO43tKNVUiyF5bUBmYNEIgkPzTIV3BOKqwzERrnXfslx0ZhT4YmvdvPwpF4kxATuI02Ki6JS7/3JWSIJFJW1RpLi/Dum//X9AfKKq8lKi8doNrN4w3FqDCYMJjMWC7RJiSM7PT7gQcsJsTryir23qibG6Kislb87iaQxI8WNE77YfoIYD03jqfHRRGk1PL1sLw9O6EFaQmDTZi0WS8izVSQSf4PlzWYLT30trJq9M1NC3glbq9F45F62R/7WgkR1MRQegqIjokt3dbHoIxcVK7quZ/SCjiMhJjQxXqHGbLZwqKCCvafKOFZYRUl1LSazhZS4aDq0TKB/+1R6tEmWx1+AkOLGCXqjmaRYzz+exNgoOrZM5B8r9qPTaslIjuXu0V38PlBT4qMpqNDTOjkyewNJmi6nympI91GoF1fW8sw3e2mVFEtOy4aVh0NFlFZLpd5Iohe/ZQCdRoPBZA5Lw8pGwbnD8OtbkNQaElpBbBJoo8FiEk1Hq4uh4gyU5kPxUbF9VaH7caPioNdkuOivojFpI6esxsDKvWf4Ye9Z1h4sdFueoH16PFcPyuKG8ztGXJPbxoYUN07QG01eFy6Lj9HRvW0KeoOJgnI9jyzdhVarISFaR0KsjnvGdPM6nqBNShyHz1ZKcSMJOYfOVpCZ5v1xd65CzzPf7KNLRmJA3bS+kBir40RxNd3betc6Ij0xhtOlNWS3aJpWBL85uxfWv+L965LbQcu6TuqJrSA6AYw1QgTlb4aS4/DbR/DbxzDibhj7KEQHP6A9kOiNJn7cd5bPt53gx30F1Jps8Zjx0Tr6ZqXQuVUSLZJiiNJqKKkycOhsBdvyiskvrualVYd446cj3D6qM3eN7hL231BjRX5qTqg1monxIObGEbHROtrXnRRNZgvVBhOlVQae/GoPj17R2yvzfJvkWL7YfoLzuzjvfiqRBIMVu0/T2oerx9dXH6F9WnxEnJTjY3R8ujWfuZd7ZwVIS4jmTJkUN05Jz4EL7oWKs8Iio68AsxE0WiFG4tOERSc1C9I7QYvO0LKrsPA4w2KBk1th7XzY+xVsWABHVsPvPxJiKMLZfbKUj3/NZ+n2E5RU2Sw0XTISuaxvJpf0bM2A9qlOSxxU15r4Ye8Z3lx7lB15Jby86hBfbD/J/OkDGJLTIlRvo8kQ/rNPBGIOYFVWnVZDUmwUSbFRnKvQ88RXu3n0it4em7tbp8Rx4EyF3/OQSLzlbLmeXpne97kqrTHQNjUyLI0J0VGUVnlfTiEtIZof9p7hvI5yUXFI237iL5BoNJA1BKYvhgMr4Is/wtnd8N+xcOPSiHRTldUY+GL7SZZsOs7uk2XWx9ukxHLVwCyuGpTl8W8oPkbHlQPacUX/TL7bdZqnvt7D8aIqrn19PQ9d1pPbLuos43G8QIobBxSW64kLQJ0Ne1omxaLTaqwCx5NaHq2SYjlXKWtuSEJPYYWelkneuWb1BpGdFOrgYWfERWup8aFMQ1p8DCdldfDw0X083LYK3rsWCvbCO1Pglm+FSysC2H2ylHfX5/LF9pNU1x3z0ToN43u3Zdp57RnVLcPn34BGo+Gyfplc2K0Vjy7dxRfbT/LMN/vYd6qcZ6/p77NHobkhxY0D3t90nITYwIsbgLSEGIwmCy+vOsT943u43V6nDX4TP4nEESazxeuA2gU/HiYtPrTtGlyh0Wh8anCbGh/NnlNl7jeUBI+0bLjlG1h0JZzZBe9cJQRPUkZYpmOxWFi9v4DX1xxm49Ei6+PdWidx3bAOTB2URYsANphNiYvmX9MHMrhDOk9+vYfPtp3gbLme128Y4lWyS3NFfkIOKK0ykNUieEFsaYnRHC2o9Hj7KK1GNPEMgjVJIgkkRZW1tA9BRWNv0PqQ+ZQcF+VTAUBJgEloATcshbfGixTyD2fCTV+K9PEQYbFYWLn3LPN/OGB1Pem0Gib2bctN53dkaMf0oLmLNBoNN13QkZyWCdz93lbWHipk5psbWXTLMFJD3POtsSHtW3aYLRZqTc4bZgaCKK0Wk9ni8RVlRnIcueeqgjYficSeGoPJa6uNxWKhxmAiLjqyRHhstJZzFd5VHE6MlQU0I4akDJjxIcSmQt4GWP63kO1614lSpr+xgVvf+ZXdJ8tIiNFx20Wd+PnBS1hw/WCGdWoRkjiY0T1a88FtI0hLiGZ7XgnXv7mBkipZRdsVUtzYcaK4OmguKTXx0TpOl3nWWqFNSiwfbs4L8owkEhsF5XpSvXQv5RVVe11PJhTER+t438sGtDqtbwUAJUEioztMWyjub34Tdn0a1N1V1Rp54qvdTH5lLZuOFREbpeWOizuzds4YHp7Um3YBaEniLQOy01hy+whaJcWw+2QZv39zoxQ4LpDixo7FG3NJiw9shWFHJMdH856HJ9w2KXGc8VAISSSB4Gx5jdfi5u11xwIacxAo4qJ11BiC09xWEkK6XQoX3S/uf/lnKDoalN1sPV7MZf/+mf/9cgyzBa7on8mP949m7mW9wn5892ybwvu32QTODQs3uS0M2FyR4kaF2WKhvMZIsp+9dDwhIcbzE27rlDjOlsmMKUnoKKkyeN1TqrzGQEoIfjveEhclxU2TYfRc6HA+1JbDZ7eDKXCuQ4vFwps/H+F3r68n91wV7VLjWPSHYbxy/eCwWGqc0b1NMu/fNoIWiTH8dqKUm/+3ifIaKXDsaRTixpdsB19Y8OMhUuKiQuJDjYnSojd4lqKaFBslG/lJQsq6w+dIiPHcPVtabSBKp43IOhyx0Vr0PqSDSyIQXRRc/R+ITYH8TfDziwEZtsZgYvaH23l62V6MZouoNTN7FBd3D09mlju6t0lm8azhpCVEs+14Cbf8b7OMEbMj4sXNI488wo033shzzz3H9u3bg7Yfi8XCmbIaWqeEpviYVqPBgneiLVQiTyKpqjV6JW5eX32YFgFuGBsofG2gqdOKLCtJhJHWASb9U9xf8zyc2OLXcCVVtfz+zY0s3X5S1CGb3IeXZwwiJS6ys5F6t0th8azhpMRF8WtuMX94ezNV8iLYSkSLm2uvvZY1a9Zw3nnnsWrVKj755BPA+0Ver9dTVlZW78+eBT8eIiEmKmIb5aXGR3O2XLqmmiJ6vZ7y8nIAysrK0OvD/z1X1ZqI9yLrqbiqlrQmlpoaH6OjrJnGM+j1eioqIrgyer9p0Odq0ajzszug1rds0jNlNUx7fT1bcotJjovi3T8M46YLOkakBdIRfbNSeWfWcJJjo9h4tIg/vC0tOAqRuZID69evZ//+/fzwww/8+c9/5sEHH+Tzzz+nqKjI/YvtmDdvHqmpqda/7Ozses/XGs2cLKn2qUmgv3h6RdkmJY53N+QGeTZNhKoi+P5R+PAG298XfwR9ebhn5pB58+bRu3dvALKzs5k3b16YZ4RXKd1Gs9mngn+hRKfVeB13kxATRVkzrXUzb948hg0bFu5pOEejgUn/gORMOHcQfvi710OcLKlm+hvrOXS2grYpcXxy5wVc0LVV4OcaZAZmp/HOrGEkx0ax4UiRjMGpI2LPRrGxsSQlJXHw4EEAevTogclk4u677+b+++/n22+/9XisuXPnUlpaav3Ly6ufVv3C8n20TY0nShvaj0On8dzs3T49gfxiWQ7eKfoKYaJ++wr46EaISYZ+10L/34m/1r3h7Umw6b/hnmkD5s6dy549ewDIy8tj7ty5YZ6REPyxHpZ5X7DqcMSb8GOjdBRVepc2m9CMLTdz585l06ZN4Z6GaxJawJS6zuSb3oDDqzx+6dmyGq7/7waOnauifXo8H995Pj287BwfSQzqkM67tw4nOS6KzceK+f2bG70+3psaEStuunXrhlarZf78+dx9993069ePKVOmMHPmTIxGI//f3n2HR1GtDxz/zta03fSETkRaKNKbUhXBQhEsWGhWfjbsIl4rV8Vyrx0Vr16lKOBVwQ4ozQJIExQQKUroJRDSky0zvz8OwUbZMruz5XyeJ48x7M6+u9nMvnPOe94za9YsSktLfZqistvtOJ3OP33VeHXJNtxejXQDlviZTApuj28jN/XSE9ldJBv5AWKFRPEu2LkSFjwqkpZ3LwNXGZw1Fs55EBr1AkcupOSIr3odoe+j4gT4v9HgiZw/fLvdjsMhTqxOpxO7PXzdV0/E7dV83sOmqNxFeoTW29SwW0wBJTfxusy25uIy4jXuC52uF9/PuUmM2p7CkQoXw9/8/lhiM2tMt5jY/b1t/TRmHF1F9eOuYi6bvIzdcbw/WuSt2wRUVcXhcPD555+zdu1aFi9ezKBBg3jqqacASE5O5u6778bj8QQ1N/r20u3sKtNonGtMxm5SFFxeL778GkTH1DhbzlpUAEtfhH0/iWHoGooJEjMgKRNS60KPu8CWfOrj2ZKg++2wbRHMvgEufTtUkUc9l8f37QrKXB4a2iP7w8FuMfHpur20qpvq832SbBa+3VpIzwhdMSMdde4E+HWxmJ765Da4bOqfzxd/UOX2cu2UVWzeX0au086713WlbgQt8w5Wq7qpvDemKyPeXMHWA2UMmfQdb13diZZ1fH/fx4qIS240TcNkMuHxeHA6nfTs2ZNVq1b9aSpp69at2GzBXykWHCqjSf1cw2oFFMCfPTFrNtGMlB2XQ2bVf2Htu2LY+bRe0GoomHR8q57eBwq3wMJ/wtkP6nfcGOLyqth8+LsoKndhi9Al4H9kt5op87NQ25Fg4aAs4o98tiS4+D/wRl/4+WNYMwU6jP7bzVRV47aZP7C6oAhngoVp13ahQWZkJ+WBaJzj4IMbz2T0WyvYvL+MS19bxnPD2tK/ZS2jQwuriEhuZsyYQVlZGV27diUvLw+Hw4HFYkHTNBRF4eKLL2bChAkMGDCAOnXqMGfOHObOnUt6enpQj3taVoqhm1FqiATHV+lJNvYWV1IvPfb+IAHQNJj/D9i/Afrc79toTKA6XQvfPS8TnBOwaG7SD62m0+FPoXi3mPKrebf+MZHRVC7NAawp4KwLmY24dlMnqk2RdTWcYDFR5WevG0eChW0HI3jFkPS7Ou3gnIfgy4fgi/ugfhfIyf/TTZ6cu4l5G/ZjM5t4Y1Qnmho0Yh8OddIS+d//ncnNRzfbHDNtNWPPacLt5zTBFOsXx0cZntwMHjyYgoIC8vLyeO655xg4cCBDhw6lS5cuKIqC2+2mYcOG/Pjjj7zyyitkZWWxZMkS8vPzT33wU7BFwC7b/lzxZqbY2HG4IjaTG1cF/G8UpNYXXUhDPRJgMkP3O+C7F2Dh43D2P0L7eNGg4jAsegL2ruV9uwaHmkBuK2h6vkg0T/Y7qS6Fkj1QuJk3zU+ApkJuS27bfQ6HLLnhew4nYDYpePzsWeNMsFJSGZ+rpaJSt1vh1yWwbQG8NwquXwh2UTf03sqdvP71rwA8c+kZdD4tw8hIwyI10cpbV3fi8c9+5u2l23lxwRZ+2FHEc8PakpVifF1fqBma3CxZsoStW7fy008/YTKZmD9/PrNmzWLSpEl4vV7OPPNMrFaxCqNBgwY88cQTmMK8oimUNDS/Rm6yUux8+uNezjw9+pYrnpTXDdMugpZDoG778D2uYoKzboOFj8Hqt487lB3zVC98+5yoWVDdcFpP6Hk3mP2c9rU7ILuZ+MofCJ5qOLCRF4reBHclnN6HkVt6oSrGXFAEMm3mSLBQIpfURg+TCYZMhsk9oPAXUX9z8RusKijiH3N+AuD2vk0Y3LauwYGGj9Vs4pFBLTmjXir3z/6Jb7YUcv4L3/DvS9vEfC2ZoZmC0+kkNzeXiooKVFWlX79+jBkzhqSkJGbOnMmuXbsAmDZtGkuWLImpxAYAzb8BirQkK8UVMXiyff9qaNo/vIlNDcUkCpJXvQVH/Ns5OqpVHIbP7oLXe0HRbyKx6zVO7Nvjb2JzPBa7mCo46zbodhOUHWCqdxzTs94m3VsY/PEDYFL8G72xmE14/SmKk4yXki0WCpgssP59ShY9x/9NX4Pbq3FB61qMPbuJ0REaYmj7enx8S3ea5KRwsLSakf9dwSMfb6DSFbuLVAzNFrKzs9m4cSNTpkw5lrh07tyZYcOGsW7dOjZt2gTAunXryMqKsdEKRM2NyY/sJslmoSLW3oxfPQIJqZDX3bgYbMnQ406YNTz2E5zlr8DbA2HmFaJg++wHodXF4vtQsTvFaE7fhyGrKS8lvMZ05UGmn74ARQvf9gZ2i4lDcd77Iy406Ar9RSPM5K//SYuKFTSv5eBfl7aJm3qT42ma6+DjW7ozsltDQKwWvvDFb1izo8jgyELD0OSmXr16TJ48mQkTJvDuu+8CYrVUnz59yM/PZ+rUqQA88cQTtGzZ0shQQ8afkZtkuzm2NtBc/TbsWgnthhsdCThqiRGcWcOhdL/R0ehL9cKiifB6H9ixHNqP+MMoTRib7ykmqN1G1Dp1uxlK9zLNO47pjReJYvIQS7Ca/V79ZLeYZDv7aNT5elalX4AZlUm2F3nrghSSbIaXmBou0WZmwuBWTLmmM7lOO78WlnPJq0uZ+MXPfnfwjnSGz/MMGjSICRMmMG7cON54441jc+NZWVnHRmv0WPYdiTTNv1qABKs5doYRS/aKJd/d7xQfepHAUQvOHAszLo/YrRr84qmGuePh9d5Qtk8kbx1GQ3IEjILaHaLGqvc4OLKD6dp9TM9fHtKHTLCa+WTdHr/uk5ViZ6dsnhl1Zq7cyZV7h/G92hwHldT+bKQ450gA9GqazfzbezG0fV1UDSYv+ZWBL33L+t3FRoemG8M/VRRF4dprr+Xpp5/mtttuY9CgQVxyySW89NJLjBo1yujwQs6fQVKxk3gMcFfBrKtEPYY9wrqgptUXIxvvXiYKnaNRxWH4+FbR98NkhrMfgBaDRT+QSGNNFJsg9rgLdn7P9IRnSFJDs/w6wWqiyu3fNFiuM4GP1vqXEEnGWrfzCA99tAEXVn4662XIbAzFO2H6xVB5xOjwIkZqkpVnL2vL6yM6kJViY8uBMoa88h2vLt6GGgO1ZoYnNwAWi4UrrriC1atXM2TIEM4++2xWrFhBmzZtjA4tpBTF940zY8oH14ir9tR6RkdyfLktofG5YgRHDV9NSFC8nt/31ppxueg50/dhOP3s8E49BcqWDJ2ug9P78Lr3IaY3/Ub3h0iwmv0eeq+bnsguOXITNQ6VVXPj9NW4vCp983O55tyOMPwDSMmFAxvERUu17F30R/1a1mL+Hb3o3zIXt1fjqbmbGPXWCgrLoruBZUQkNzWaN2/O1VdfzU033USzZs2MDicsYiBB9s/Cx0UBcf0I3nEYIO8sUR/ywTVhqQcJSHUpLH4S3h0Gb5wt9tvqMBp63yde30iZ7vNHTr4YadqzlunOSboWHJsUxe+LiTppCew9UqVbDFLoeLwqt874gT3FVZyWlcyzw44WEKfnwfAPxXln5/eimN4lE9Y/yki28drwDjx1cWsSrCa+2VLIgBe/5YcoLjaOwrNf7Ii7kZt1M2D719BuhNGR+KZpf0hMh8/uNDoSobIIvv4XfHg9/OcceOdSqDgELQZB30eg5UWhXfUULhY7dLoGHHWYlvA0Zk3fgl5fNtutYbeYcfnZ/E8yxpNfbGLptkMk2cxMHtHhzzvV12olEhxbCvz2NcwYJhOcv1AUhWGdGvDJLd05PTuZfSVVDHt9OR/7WacWKWRyYyAFxf8+GtGaDJXug+WvigJik/GdoX12xjCRVCyYEP7HLjsAc++DqYPhP2fDrJGiC3DdjtDrXvHV7Hxw1A5/bOHQtB/U7cgUy2O6JTg2i8nvnb7tFhOlsplfRPtwzS7e+PY3AP51aZvjb61Q7+gUVU2C884lsbFwQGdNch18dEt3+ubn4PKojJ3xA29886vRYflNJjcGMing8fqZrET4BoXHparwv9Fw5q2QmGZ0NP5RFOgyRixZX/Xf0D+e1wOLHhfFwO9fK2pROowWUzU97oD8AZDVJDrqaPTQsBvkdWdKyku6HC7BYuagn7UEeVnJvPXddl0eX9LfDzuKuO9D0YH4lj6NuaD1SZL9Bl3FCI7dCQXfiQuHisNhijR6pNgtTB7RkWvOOg2Axz77mWfn/+LXqKfRZHJjIJOi4PGjYFVVNaKyB9XccVCvE6Q1MDqSwCgm0ZtlzVT4cVZoH+vtC6G8UKwk63EHNDxL1ArEswbdwJ7K9AafBH2oBKuZ2Wt2+3Wf1nVTo7r2IJbtKqrg+qmrcHlU+ubncOe5TU99pwZdYNTHkJgBu1fDf88Tm8NKf2I2KTw4IJ97zxP1ry8u3MpzX20xOCrfyeTGQIqfIzfVXhWbOcp+ZT+8Awc3QfMLjY4kOLZkUai7bBJsmBO6x+l9n+jmG8od0aNR60ugYBnT228O6jCBLAevk5bIgdJqXH7uKi6FVnGlm2veXklhmYv82k5euLyd7x2I67SDq78ARx2xD9Wb/eDgL6ENOAopisJNvRvzwIVio+oXF2zhP19HxxRVlH1SxhaTouD2o1ix2u3Fbo2iehXVCyv/A91uic7ptL9KTIee98C3z4oaolCIxhVO4WAyQ9f/gxX/wawFXv9it/i/HBygdb1UXlgQXGIl6afK7eWGqavYvL+MHIedN0d1JNnuZwfinOZw7TzIbAIlu+C//WHnitAEHOWu69GIcec1B+Dxz39mzg+RP9Ilz6QGUhTw+FFQXFbtweHvH7CRlr0EdTtEX53NyaTkiNqh90ZGb5O/aJWUCQ27MSVvfsCHsJoVv/7manTKy2Dldjk1FQncXpVb3l3D978dxmG3MOWaztRJSwzsYGkN4Nr5Ytq8sgimDILNgb+/Ytn/9WrEtd1FDc697//I6oLIrlWSyY2BRM2N7yfa0ioPKQlRlNz8MheanWd0FPpLayCWic8aEb2r16JVo97w6+KAX3dFUQikzXdqohWXR5Wrpgzm9qrcPmstX/18ALvFxOsjO5Jf2xncQZMyYORH0KQfeCpFH5yf3tcn4BiiKAr/uCCf81rWwuVVGTNtNXuOVBod1gnJ5MZAigJePwqKy6o8pETLyM2BTWIaxx7kiSdS5XWH9IbwyVijI4kvFjtkNQ35PlTH065BGs99JaemjFKzLPmzH/diNSu8NrwD3U7P1OfgtmS4/F1ofSmoHvjgOvhhuj7HjiEmk8Kzw9rQoraTwjIXN76zhmpPZO53KJMbAymK4ldBcUmVm34tckMYkY4W/lPsZxTLWg0VfTIWPm50JPGl2QWw+YvA7x9g88z2DdJZu+NI4I8rBays2sO1U1byxfp92MwmXr2qA32a5+j7IGYrDHkdOl4DaPDRzTLBOY4km4XJIzqQmmhl3c4jPPHZz0aHdFwyuTHYN1sLfb7t4XIX9dIjcPPDv9I0UXCbcZrRkYRe5xvENEmoCoylv0tMA5MNpzewGhiTgl+F/Mce1mbGo2py1VSY7S2u5PLXl/HNlkKSbGb+M6ojfUN1kWcywYXPir9rEBvQrv8wNI8VxepnJPHcMLH345RlBczfEHnnP5ncGEgBv+b/iypc1E5LCFU4+jmyAxy1jI4iPExm0WTv0zuMjiS+NOzKK/UXBnRXk6IEnKA0ykrmzW+jYylsLFi5/TCDXv6O9btLyEy2MeP6rvRqmh3aB1UUOP9p8XetqWK7k1+XhPYxo9DZzXO5vsfRAuMPfmRfcWTtwSaTG4P5MzjuVTWs0dDnZt0MyGlhdBThk9UYvC748T2jI4kfddrDnjUB3dVsCjy5ya/t5Oe9smV/qKmqxmtLtnH568s5WFpN81oO5tx8Fm3qp4UnAEURIzgth4oanFkj4EBkTr8Y6Z7+zWldN5UjFW7ueX8dagTtBB0Fn5QSRNkGmwc2Qm4cJTcA7UeIDsZSeFjsYEkMaGpK9JcK7O8pLyuZgkPlAd1X8s2uogqueuN7nvxiE15VY3DbOnxw45nUzwjzlLzJDBe9KjpkVxfDjCvEcnHpGJvFxHPD2mK3iJ3Epy0vMDqkY2RyYyAN33vbHS53kZFsC2k8uindF7ubOZ6Io7b4wC3Za3QkxlO9cPg3mDtebPz55cNwaCtUHtH3ceq05ZXTv/c/PE3DHOA+JmaTEshKcskHqqoxbXkB/Z/7mmW/HiLRaubJoa15flhb/xv06cWaIFZRpTWAot/Efm9qZK4OMkrjnBTGny8a/E384me2F0ZG8h8l64pjk6Zp9GnmW8X/niOVgTeqMkK4OhKrXijbJ7ZFcFWIn5nMoJhFy/7EDNHHIiE19LuR1+0Aq94Um1zGE68bFk8UV7XVpYAC9mTRBkAxgacalr8i/i0xXdQz6CHzdNi2yO+7qZqGzRL4dZ35aGfxqJgijhIb95TwwJyfWHN0NVrHhuk8c2kbTsuKgG1IkjJEgvPGubBtAXzzLPS6x+ioIsrIbnnM27CfZb8e4t73f2TmDV193wojRGRyYyBNw+cryL3FVYzs1jDEEUUR1QOf3C529LWngC0F7I6j/+YFzStqfzzVR7+qRMKTkg2974dknfpj/FHd9vD96/ofNxKVHYBv/i0SGk2DxFRIzoaMRidObDUNDv8Kn94JF/47+ATYWRdK/G8Dr6oEtUdberKNfcVV4Z8miUElVW6e+3IzU5cV4FU1UuwW7u7XlJHd8gz/cPyTWq1hwLMw50ZY/MSx3eolwWRSePqSM+j//Nes2H6Yt5du55ruxq6WlcmNgfxJbg6VVdMwGk6mHheYQvy2WjBBNAlMqw+ZjX3/kPS6xY7bn90pkqHBL+s7wpSYDlXF4tPTFINX9eUHYdFE8RytCZCcBc6Wvo+IKYoYbSkqgE9ug4EvBPf6m8xiNQuaX8dRNQ2rJfDHTU+2sudIpUxugqCqGrN/2M3ELzZRWFYNwAWta/HggBbUTo3QEeq2V8L2b2HtO/DB9XDjd2JURwLE8vDxF+Tz4Jz1PDPvF/rm59Ig07i/kRg8A0cPVdN8voIsqXSTlWIPcUQ6qC4RiUOofH4PHPoV6rQFZx3/PhzNVnDWFiMsZoto0qU3Z20o3qn/cY2iaSKZnD0GvnwIktLFa5+TL0ZqApnqS28IFhvM/0fw8SVlkuH1vVcUiL87SzDJpx8XJdLfbdxTwmWTl3HX/9ZRWFZNo+xkpl7TmVeu6hC5iU2N858WF1Sle0R38mha6BEGV3VuQJfTMqh0e7nvwx/RDHx9ZHJjIK8fc/8aRNYw7YmontDVtix8HEr3ig9XS5CJXkYj8d9Pbg82qj9LzoGSPfoe0yhlB0SPj8ojkNUUcluK0Sk9RrvSGojCcy3IhnjOOtT27Ao+Hj9UuVWSbHLQ21+lVW4e+XgDA176hlUFRSTZzNx3fnPm3taTnqHuXaMXewpc/AaYrPDzJ7KD8V+YTApPXXwGCVYTS7cdYuZK4y70/E5uKisr+fbbb9m4cePf/q2qqoqpU+VyWF+pqobdh+TGyOzXb6pHFJHqzeuG/Rsgt5V+U0lZTcFVJlb16CU5C36LgYZfXz4sXpfsZpDZKPhk8q8Uk+g0vCjIrStS6zG+0Tafb65pGgrBvX+qPd7o2eMtAmiaxuc/7eWcfy/h7aXbUTW4sHVtFtzVi//rdXpQxd2GqNMOzj466vjFODjk+/svHuRlJXN3v2YAPPHZz+wtNmZzTb/eVZs3byY/P5+ePXvSunVrevXqxd69vy99LS4u5uqrr9Y9yFglVm2cepSjwuUlOVquFEM1cvPxWHG1b9Vx2FpRxGhE0Xb9lncmZ4valGjldYvXurII6rTR9/X+q5QcMToUDGcdKPa9qNjtDa7eBqDS7SXJHuKVdzFiz5FKrp+6ipveWcOB0mryMpOYdm1nJl3VPvKnoE7mzLHQ8Cxwl8OHN4i/G+mYq886jbb10yit9vDA7PWGXKD7ldyMGzeOVq1aceDAAX755RccDgdnnXUWO3bsCFV8Mc2rQoL11L+C4ko3qUnWMESkA9Wr/8jNV4+At1rUs+hNMYmppPk6Ld9OzoSKQ/ocK9w0TdQRJKZCdtPQjMD9kS1FLN8P5sSXnANl+32+eZXbS4IPFxQnU1zpJjNaek4ZRFU1pi7bzrnPLuGrnw9gNSuMPbsxc2/vSY8mUTIFdTImMwyZLFpM7F4FS54yOqKIYj66espmNrFg0wHmrPV/VWOw/Dp7LV26lIkTJ5KVlUXjxo355JNP6N+/Pz169ODXX+V+K/7yqqpPJ9qSKjfOhChKbvQcudFUOLhZFLCGSlo9KNapbsOa/Hu/nWgz734Rf0oYd563JYnizECZzIDmc4JU4faSaAv8/en2qlhNJpRw9XGKQtsOlnHZ5GU89NEGyl1eOjRM5/OxPbizXzMSrDE04pVWHwY8L77/+l9y/6m/aJrrYOw5jQF45OONHCgJ795TfiU3lZWVWCy/T48oisKrr77KwIED6dWrF5s3b9Y9wFjma5FwSaUbZ2KUTEtpXtFPRi9z7xdTPeYQXimbbaJAsFSH7sK2ZDFUHW0WTxQjTulh7qWUmAFLXwruGCm55Hh9+91Vurxc2aVBwA+143CFXAJ+Ah6vyqRFWzn/BVEwnGwz88/BLfnfmG40yXUYHV5otBoK7UYAGnxwHZT6PooYD8b0Op3WdVMprnQz/sOfwjo95Vdy07x5c1atWvW3n7/88ssMHjyYQYMG6RaY9LuSKg/9WkTJLtt6FhSrXjhSEJ4P3LT6YslzsMzW6Jt/d1VA4RbIaR6+ztI1EtOD368n83SebbLep5tWub1kOwIvjv7tYDmNsiOga26EWb+7mMGTvuOZeb/g8qj0bJrN/Dt7MSLSmvGFwvlPQ05LKD8A740UTUMlAKxmE/+6tM2x6an/rQrfyka/PoWGDBnCjBkzjvtvL7/8MldccUV0reyJEhUuD2nRUnPjKgdLgj7Hmne/mCIJ9bYJcPRDtjg+94354h6xND6Uo2MnYraI1zyY1z2zCRz8xaebqpoW1LYJG/eWcEPPRgHfP9ZUub08NXcTgyd9x4Y9JaQmWvn3pW2YcnUn6kbTdjHBsCXBZVPBngo7l8Nnd8n+N3/QrJaDO85tCsCjn2xgx6HwTNv79Vc+fvx4Pv/88xP++yuvvIKqBtm3Qvobl1uNntVSW76E1LrBH0fT4MhOsUIqHBRFFAN/9XB4Hi9SLHocUMSybKPYUsQIXaBS64n7n+IDxatqmIIYmTpUVk2K3SJ73Bz17ZZC+j//Na8u3oZX1Ti/VS2+vLMnF3eoF381SVmN4ZI3xaj1D9Pg62eMjiii3NCzEZ3y0il3ebnjvbV4vKHPE6KswUDsEP02fFPtVaNn6WnxTkitH/xx5j8oWpuHY9SmhrOOPg34TObomJrSNDi8HTKM3QOGpHRY/lrg91cUyGrK9FZrTnqzyiCLiZf/epiujUKwJ1kU+njdHoa/+T0FhyrIddqZPKIDrw7vQI5Dp1HbaNTkXDjv6KqpRY/D95ONjSeCmE0Kz17WlhS7hdUFRby4YEvIH1MmNwbxqhpmH1vAV7tVkoI4KYdVyW6xoWGwjmwPf3GrNUnMlwebmCRm+LU82TALHhWbjerdoM9fCWlQdSS4YzTqDb+efIfwCpcn4L8jTdPYtK+Em/s0Duj+saZvfg4NMpIYfWYeX93Zi/4to6QmMNS63AA97xXff3EvfPeCsfFEkPoZSTwxtDUALy3aytKt/m2b4i+Z3BjEo2pYfCy0UzUtOvay8bpFcaolyNqNrx4VS5KNqAFJygy+sDg5W7+l5aGiqWLaLz1M034nU7MBZjB1N6l1obwQq3biYs5Kl5fLOwX2fH/eW0rjnJTo+DsMgySbhbm39+CRQS1xREubinDpcz/0uFt8/+VD8Pm98VnLdxyD2tRhWMf6aBrcOuOHkHYvjorkprS0FIiybQhOwe1VsZh9O1GaTQpeNQqe+5KnIa978Mc5/KtxUyV6dM1Nqw+b5+oTT6h89fDRab8IqR+xJQe/4WiDLrx12sIT/nOl20uuM7BRqoWbDvDooFaBRhaTZO3RCSgKnPMgnHv0ImnFZHjnEqg4bGxcEeKRQS3Jr+3kULmLm95ZQ7UnNIlfxCc3o0ePZuzYsezevRtFUWImwfGoGhYfV22YFAVPpCc3mgZbv4Qm/YI7TvEucSUfyrb/J2NLgerS4FY7pDWEoiAKZENN9YotC1LrGR3J7xLS4Psg6m4AGnaH7d+e8J+9qoY9gCZy2w+Vk5FsI0N2JZb8cdZtcOkUMd29bSFM7gm7VhsdleESbWZeG94eZ4KFH3YcCVn/m4hPblavXk1BQQFPPvkkBQUFASU41dXVlJSU/OnLaB6vitXHIW6zScHrjfDkZulLR3frDnZK6pHfd+w2gqIcHUUIYlrJWcevrrvV1dXHRidLyiqornYF/ti++OphMXUWzmLtU0lMhari4I5hSwK7g2zP3xv6BXPy/GZzIfdfEMIO2RGourqasrIyo8OIfi0vguu+Eue04p3w3/7w/etxv1S8YWYyk65qj9mk8OGa3by8cKvujxGxyU3NkvJWrVpRt25dzGYzTz/9NNu3b/d7meHEiRNJTU099lW/vg6reYLk9mpc0Nq3vZKsZoVKdwTP2bqrYP0H0HxgcMepLAKvSxS5GiklB775V+D3N5n9mmOfOHEiLVq0AKB+j8uZ+Nrxe0npwusWK8KcdUL3GIEw2/RZYXb62TyX8/d2FS6vij2APaU8XpXCsmoa56QEH1sUmThxIp07dzY6jNiQ2xJuWAwtBoPqFn2lZo8BtzG7ZUeKHk2yeWRQSwD+/eVmZq3Ud4/KiE1uTEdXEo0YMYLWrVtz4YUXUlRUxGuvvcbs2bOZPn26z8caP348xcXFx7527gxybl8Hbq/qcyFeos1McWWELi3WNPjfKGh9CdiD/ACY/2D4+tqcTFJG8PPjSRlQ4tuWAOPHj2fjxo0A7PxmJuP/74rgHvtk5o4Xq9kiadSmhmIKPsHJyYeDm/52ZVzlVn3apPavNu4toUUdZ3AxRaHx48ezYsUKo8OIHQmpYoqq/0SxPc2Ps2DKICg7aHRkhhrRtSE39T4dgPEf/sTH63RoxXFUxCY3NUwmE/PmzaN3796MHTuWtWvXMmLECAoLxTIyX4ab7XY7TqfzT19Gc3tVn/eLSrJaKInU5OaLe0XtRv0gr/JUj9jbKClLn7iCYbIcXb3jCfwY2c3gx5k+3dRut+NwiNEqZ0oSdnuIajtK90F1sRiZikTWJNFKIBiKCVIbUN/9259+XO3xBjRys3J7EXf0bRpcTFHIbreTkhJfo1UhpyjQ7SYYOUckO7tWwFvnifq3OHZP/2Zc3qk+qgZ3zFrLJzolOBGf3Jx33nk0aNAAq9WKqqqsXLmStm3bsmHDBnbt2hW1nTC9qkaij8WNSZE6crP0JVE42/rS4I817x/gqBX+vY1OJDFN7EYeqKzmPm8JEBaaJpalZjaJnNf4r+zJsPKN4I+TdxYTs+f/6UfVbpWhHfzrv+TyqJRVeagTL9sISOFxWk+4boFodnpoK7x1vj7NQ6OUoig8MaQ1l3Soh1fVGDvzB2asCH6KKuKSm7+OxHg8HjweD1dccQVXXnklTz31FPfddx9Wq/VPO5RHI18TsyS7mSWbI2z4cv2HsGEOnHlr8B+Wmna0s3EErd5JyoLlrwR+/4w8KNquVzTB++phsRLMFsE7WttSxN5kwcpqCoe2omi/1z1Ve1Qy/VzttGlfCfm1Y3Q3a8lYWU3g6s8hPU9sHTJtaFwvFTeZFJ66+Ayu6tIATRNTVME2+YuI7GDGjBmUlZXRtWtX8vLyjg3Re71eLBYLo0ePZuTIkTzwwANcd911APTu3Ttuhk0ddisHSyNop1mvB5a9DD3uDH51FIgRhYT0yOm5AmLY+PCvgd//2NSWCj52og4Zd6VY/VW7jbFxnIo1Edw6bKqnKJDbkmm5qxi+sQsgCor9bTb3895S7u7XLPh4JOl40hrAyI/FCqqDP8PMq2DkR/qcU6OQ2aTw2EWtSE0Un3fdTg9uqxPDP00GDx5MQUEBeXl5PPfccwwcOJChQ4fSpUsXzGYxbdOxY0cWL15MkyZNUFUVk8kU1YmNR1Ux+zHakZJgobQqiPoPvX35gBhaTc7W53hF26HWGfocSy81XXM1VdRxBCKtPhT+IopcjTT3PrGVRSQWEf+RyaJfJ9eGZ8KmzwCR3KDhd3fhPUcqaZobvecZKQqkN4ThH8Kb/WDHUrGSamD8btmgKAr3ntccVdWCLjkx9JJyyZIlbN26lTVr1jBnzhyef/55CgsLmTRpEkuXLj12u9TUVJo0aYKmacdWUUUzl0fFZvH9eTgiKbkp2Qu7VkHT/vocb8EEccUeiVcrtpTg+t3ktBCrIoy08J+iMDopWjZ8VERCGazUelC6709TU/4oqXSTkmCJ2po+KYrkthA7iqPA6rfhh3eMjshwJh22OTE0U3A6neTm5lJRUYGqqvTr148xY8aQlJTEzJkz2bVLfLBMmzaNJUuWxMyJRiQ3vl9FJ1rNkdPn5tM7oOM1gY9m/JWRWy2cSmI6fPdi4PfPzocDG/WLx1+uCjj8m5jfjxYWu1g1p4fcFkxrsUrU8fl56th2sIymObLeRgqTpv2hzz/E95/dBQd+NjaeGGBocpOdnc3GjRuZMmXKsRGZzp07M2zYMNatW8emTZsAWLduHVlZEbBEWCdVbi8XtvZ9F11FUSKjo6XHJT54Mk/X53glewFFLAGORIlpwe1WnZxpbJHg3HGQflpk1TKdit0hVuHpoV4n2L0Kl1fF5uNWJzX2lVQx4AzfmmxKki563AWN+oCnEt6/RjRHlQJmaHJTr149Jk+ezIQJE3j33XcBsVqqT58+5OfnM3XqVACeeOIJWrZsaWSouqp0eamd6ufy0kgYtVr9X6il4+aBXz4UuaM2AJaE4LuIWuzGdCJd9LiY3klKD/9jByPBCVU6bY9ydI8vf6eBAfYXV3NadrI+cUiSL0wmGPofUct4YKOYUpYCZngBy6BBg5gwYQLjxo3jjTfeODb1lJWVdWy0xmaLwHqMILg8KmlJ/q3cgAjYFX3HcmjQVZ9jlR0AT5VYlRSpFOVo19wg9nrKyYdV/9UvJl+oHji0DTIbh/dx9WBL1mc5OIjfX1ImDtd+7H4mNyVVbrJTAttBXJIClpINg46OXC6bBNu/MzaeKGb4eLWiKFx77bU4nU6uu+46Pv74Y2w2G19++SVff/210eHprmb+39/6IbvFRLnLS4rdwF/ZkZ3ialgPX4wTXXwjnd0p6oKymwd2//pd4eePodvN+sZ1Ml/cJ/aOMvufQBtOMQGaSND0mE6r257p2St50Xqt/6FEwmipFH+anQ/tR8KaqfDRTXDjUpH0S34xfOQGwGKxcMUVV7B69WqGDBnC2WefzYoVK2jTJsL7cgSgwuUlyeb/SdvwLsWaBmaLPtNjCx8TH2JGb5Dpi4RUsYtvoFLrBb+lgD+WPAXVJZCSG77H1FtiuniP6CG3FezfQGaKf6O/Mq2RDNXvcXDWE20yvnrU6GiikuEjN3/UvHlzmjcP8Ao5SpRWuXEk+P+yJ9ssHKlwUdeoVvBVxWDV6erh0FbIioJRGxA1IIcOBH5/RRGvW+URUaAcSpoKhVvEKFM0jzo4aonnoYcEJ1SXkhnANLAkGSbBCYNehOlDYcXr0GqofiUBcSIiRm7iSWmVh+t6NPL7fsl2C0XlBo7clB/U58N5wT/FdEMkbwPwR3oUFee2gB+m6RPPycwdD8lZYE0I/WOFksUOmle/2puUXFKqfN+7R48GYpIUtMbnQNvhgAYf3SJXT/lJJjdhpGmaXxtm/lFKgoWvft4fgqh8VLYfkjKCP87hbZCh01LycKgpKg5mh/DclrB/g34xHU95oVim7/Rvc8iIlZKr69RU98Mf+nxzr6Zh0aGJmCQFrf9j4m/h0Bb4+hmjo4kqMrkJo+JKN87EwIbHDW/kp2kEXYlQXSamTqJl1KaGLUXsfh6otDyxMWgozf+HaNYXKyMOydkiodZjOwY/k0uLScGjRkBfKUlKTIcLjiY13z0P+34yNJxoIpObMDpU5uL6AKakABKsZqqMTG5syWLpdjAWPBqdha4JqbD81cDvb7GBN4RTil8+JBohxtKKCpNZTLF99Ujwx0pMEzVjPlIUxfi2C5JUo8VgaD5AjB5/dIvYuFg6JZnchIlX1fCoKhnJgfXsSbSaqHLrsOdOoGzJwc/5lu6FFN87M0eMBKdYgRQsNQS/v4pDULw7spshBspZV6w002OvqZQcEsp93ydMpjZSRLnw3+Iia+9aWPay0dFEBZnchElRhYv0pMCbERo+cmNNCm7kprwQTFaxnDzaWJPEPk3BSM6GUt+LWn2iqaKnTXZT/fb6iiQms9jwU4/Rm5yWdD88O/jjSJIRHLWg/0Tx/aIn9FtNGMNi8IwYmQ6VVnNLn8A7xlrNJtxeg0duPEGsGiraHtndiE+mpo4lmBEERy04skOfeGrM+4co8o6l6ai/Sq0rRqaCnSbKaQ4Hf/H55gpi1ZQkRYy2V8Lp54C3GubcpE89WgyTyU0YVLg82K1m7AGskqohkhsDT7Z2R3CjFz/OEkt8o5U1EUqDWK2WkgO/LtIvnorDYnl+aj39jhmJTBaRFC+cENxxkrL82m3cmWilsKw6uMeUJD0piuh9Y3PArhViewbphGRyEwYHSqq5pntwNREWs4LHyJEbszW45dBeF5ijeI+wBCcsfTHw+yfnQNlB/eKZd7/YOypWVkedTFp9OOJ7vcxxKQqYLJi8viUsGck29hTLviJShEmtB/0fF98vfAwO/GxsPBFMJjch5lU1qtzeoDsLR/3y1GhPbuyO4IqKU3LE0mY9zH9QjCTZU/Q5XqQzW8XzXfREcMdJP42UIt8+DDKSbcxdvze4x5OkUGg/Epr0E9NTH14PniA29o1hMrkJsYOlVWQ7gp+OiYiOqUHFcHRDxGhld4g+PYFKyvBrWuSE3JViBVEsro46GWcdKN0X3DGyGtO5ZL5PN8122Dkop6WkSKQoYufwxAzR92bhP42OKCLJ5CaENE2jqNzFrWc30ed4uhzFINZEcAe54shIJktwBXyKSRTFBlsYO2+82Jk9FldHnYwtWWzHEMzrl9lE7GvmgxyHnQMlMrmRIpSjlkhwQEyXb11gbDwRKM7OkOFVVOEiLcmGWbZyh3ZXBb9HUyQI5sM1OVP0+glU2QFR1J2cGfgxopWiiAQnmBVnCU6o8m1qMTXRSnGlgXu5SdKp5A+AjteK72ePgRKdW01EOZnchNDBkmpuPUefUZuol5IT/Ru/WexQeTjw+6efBus/CPz+Xz0MmVG0L5feUrKDK+oGsCVhdpWe8mYRMQ0sSafS/3HIbS1WTv7v6tB2Qo8yMrkJkUqXF5vFFNAmmTEpJTe6p6VATK2VHQj8/jktYP/6wO5bug9QYrunzakkpAbfKTqrGX2O+LaJps1sotIle4lIEcyaCJdNAbsTdi6HufcZHVHEiOvkRtU0theW8cu+kmNfvx4sw6NDm/xDZdVkpkRxX5e/CrZWxGQJ/hhGsyTAmqmB3z+rCRzcHNjrsPhJUVQbz2rqloJRpw3s/dGnm+Y47Ww/VB7c40lSqGWeDkMmAwqsfANWvml0RBEhrpObbQdKSU2y8dhFrY99ZTvsbNlXSkkQ8+2aplFa7eHG3jpPIRiZHFQWid2xg2GxgSeKizQt9uC2oFAUSG/of28KdyVUl0Zvh2c9mSzBNZN01vN5h/ZcZwIfrd0d+GNJUrg0vwDOfkB8//k9sHmesfFEgLhObmqnJTH2LyuZburdmIcGtqSwrJo9RwIrgC13eUm2mTHF0rx96T6xz08w7DptQGkUiz345CyvOyx/xb/7zP8HpNWLj4Z9p2JL9jk5OS5FgaQMEstOXZic60xgX0mU14lJ8aPHXdD2KtC88L/RsON7oyMyVFwnN9edoGtwgtXMwwNbUu3xUlThf4OkQ2XVjDozL8jo/szjVTGbDfx1bZwjliAHo93w4HrFGM1sE80Ig5HTAg5s9P32XhdUFovtAyRRY/DDtOCO0eIizvrxH6fcKyzXKZeDS1FEUWDgC9C4r6hvfOcS2L3a6KgME9fJzamMPz+ffcVVVHt8LyrUNI0KV/Adif/K5VWxGZnc7PsJarUO7hiJ6cEnB0YKttcNiJ2uU3Lh8K++3X7BBLHSTI7aCHokmGn1ofYZ9N325ElvlmK3UFYdxJYjkhRuZitcNg0aniVGyadeBAXLjI7KEDK5OQmr2UReZjLbD5aj+VjvUlrlwZFg0X0pqcujYrMY+OsqPwCO3OCOkZgW5cmNObj9tWr4MzVVuj/41z2WmK36LHdtej4UbqZv6ccnvIlcDi5FJVsSXDnr9wRn2hD4+VOjowo7mdycwg09G5HpsLOryLf6m0Nl1Vxzlv6t8V0eA0duSveLUZdgJaRGd0GxHqt1AGq3gT3rTn27kr2iCNtkCf4xY4VeyY2iQJcxsPptzO4TT5UmWM2UVMneIVKUsTvgqvfFHlSeSpg1HL75N+iwEjhayOTGB3f0bYrbq55yBZWmaVR7VHKdCbrHUOn2kmA16Ne1+i2odUbwx4mF5eB6qNkIsuIUDQG/+Zdosy79zmQFVadkw+6EtlfS5/sbsFYd/3eR67SzvVAuB5eikC0JLp8Bna4DNDHFPfMKKC80OrKwkMmNj+49rzm7iypO2gPnULmL1ERrSB6/vNpLit2gK/jdq6Fuh+CPo3qjv3ZEr/BrtYYfTtEzp6pYLv/+K8Wk79VnTj60vYJe399A333//fs/OxL49Ee5O7gUpcwWuOBfotDYbIfNc2FSF1j/YcxfaMrkxkeJVjN105PYcej4PTa8qsbBkiruPLdpSB6/vNpDshHJjaaJEYZkHVbreKpF3YoEtVrBvpN0K3ZXig/yeNsg81RCkRxnNBI9Qgp/oe+q/8Pi+r1dQa7Tzn65HFyKZooCHUbDdV9BTkuoKIT3r4apg31uaBmN5JnTDzf3aYzFpHC4/O9FsbuLKqidloglRHUx5S4P5+TnhOTYJ3VgI6Tn6XMsTxUoMrkBxGtatP3E/77kKX3qnCTfmK3QfiQ0PpfeS0fTt2o+IEZu5HJwKSbUPgNuWAS9x4tRnN+WwOQe8N4o2LPW6Oh0J5MbP917XnP2F1dS+ociw/JqDy6Pyq1nh26TzJJKN1lGbOew+i2op8OUFIhpFnNopu3CRq+RXMUkapA8J1g9VnlErC6TwiunOXS/A76fTN/qr0hJsFDuksvBpRhhsUPv++Dm76HVJeJnG+fA673gzf6wdkZ09yL7A5nc+MlqNnHf+fkcLnexeV8JJZVudhyu4O7+zUL6uEUVburo3DvHJ/vWQ24rfY61bFL015DoOSvirHvi0RtPJViTdHwwyWdJGXDmWFj2CrbKgwA+t4KQpKiQcRpc8ibcuBRaXyoutHYuhzn/B/9qArNGwLqZwW0UbDC5xjQAzkQrD1zYguJKNy8t3ELt1AQcCaEdkah0eXAmhPnX5T5aa2DRacSoolDM+UpCaj345TPIPk6dluqV9UknoiBqwUJZnJ6cBV3G0HPFTUyxPszhcldsbYQrSQC5LeHiN+Dcf4rO3+tmiAajP38svgCym0P9LlC3vVgIkZ0vVmJFOJncBCH1aJITLmFvKrbmbfHm14Omiv4kFps+x4sFqfXg4Ka//1z1RP+qslBSzKJ+yxrikczUetD2Ct7c8jKrCtvJ5EaKXc7a0Ote6HkP7F0rmv5t/RL2rhPnqIObYM2UP9y+nqgbTKsPjtqi63pylqgTTEyDhDTRa8fuFBfHBpzPZHITBbyqhslkwIfdrpVw+jn6HOvLh2OjhkTP2QlHLfh18d9/Xl4IFv17JcUMs1Xskh7q5AYguxlsmc/yFcvomHdh6B9PkoykKFCnnfg650EoPwQ7lsKuVbDnB9i/QYzAl+wSXwU+HNNkERve2hxgTwFbyh/+6xTf2x1H/98hvlpcBNbgzoEyuYkCB0urwl9MrGlwaBt0ul6f4xX9pk8jQCNpqr5Lsy3243fb9brlqrKTMVtFW/mUMK0ebD6AW7a+A8jkRoozyZmQP1B81Sg/BIe2wpECKN4FpXuhbL9oGVJxGKqOQFUJuErF7VWPWExSVez74za7QCY38WBfSRW1U8N8Jb/vJ8g4XZ/hxK8eAWuyfrU7RlG9YNIxuTFZQT3Oaik5LXVyZpt/J8pgZZwGZfvEaJHdEb7HlaRIlJwpvhp0OfntVBVcZeKrukwkO65y8X11qfj/Y98f/W/Nly0l6DDjMrmpWflQUR4dS9527C3kqq4NKSkpOfWN9bLoRajTAUp1aD2/Z4soQquI8j16vFVQjT6vCYgRmrIKKCk59rstKasAVwlUa3CK7T7ilssEK98DZ/PwPWZuV/jkfuj3ePge02A178m9e2WHZilYSeLLivg6Ve6yZ88J/6nm/aieolO5osXhGsddu3ZRv359o8OQJEmSJCkAK1asoFOnTif897hMblRVZc+ePTgcjvCvQIogJSUl1K9fn507d+J0Oo0OxzCR8Dp4vV62bt1K48aNMZvjp94mEl57I0TD83a73SxbtoxWrVphsfx9kL+0tJQWLVqwceNGHI7Yn66TzzcyqKrK/v37adeu3XHflzXiMrmRhJKSElJTUykuLo7YE2w4yNfBOPH62sfC846F5+AP+Xyji+xQLEmSJElSTJHJjSRJkiRJMUUmN3HMbrfz8MMPY7dH+RLtIMnXwTjx+trHwvOOhefgD/l8o4usuZEkSZIkKabIkRtJkiRJkmKKTG4kSZIkSYopMrmRJEmSJCmmyORGkiRJkqSYIpMbSZIkSZJiikxu4lxpqdiWXi6ak6+BFH5r166V77soE2/nzGh9nnG5K7gkjB49GkVReOyxx6hbty6apsXtXlsPPPAABQUFtGrViv79+9O2bVujQ4obTz75JEVFReTn5zNgwACysrKMDiksBg8ejMvlYsqUKWRlZWEyRde15jPPPMOhQ4do3bo17dq1o0WLFkaHFHLxds6M5vNidP01SbpavXo1BQUFPPnkkxQUFKAoStRm6cG49NJLWbJkCR07dmThwoW8//77QPResUSTIUOG8Omnn5KTk8Mdd9zBZ599BsT+a3/LLbewf/9+5syZQ05OTtQlNpdccgkzZ85EURRef/11Hn30Ud5++22jwwq5eDpnRvt5UY7cxCFVVTGZTMd2+zWbzTz99NPcc8895OXlGR1eWC1btoxffvmFlStXYrfbadWqFWPHjuXOO+8kPT3d6PBi2v3338/Bgwf59ttvAZg/fz7vvfce559/PmazmczMTIMjDI3KykoKCwuZPHkydrudadOmsX79ejIzM2nfvj19+/Y1OsST2rx5M9u2bWPhwoWkp6ezdetWPvzwQ6ZPn47H4+G6664zOkTdxds5MxbOi9F1uSDpouYqccSIEbRu3ZoLL7yQoqIiXnvtNWbPns306dMNjjB87HY7KSkpbNmyBYBmzZrh9Xq56aabuPvuu/niiy8MjjA2eTwemjdvfuxqcMKECSxYsIA+ffrw8ssv8/DDDzNv3jyDowyNxMRENE3j4MGDTJo0iXHjxpGcnMz333/PCy+8EPF/f+np6TidTjZt2oSmaTRu3JhRo0YxYMAAPv30U5YsWWJ0iLqLt3NmLJwXZXITx0wmE/PmzaN3796MHTuWtWvXMmLECAoLC4HoGX4MRpMmTTCZTDz33HPcdNNNtG7dmsGDBzN8+HA8Hg+zZs2itLQ0Ll6LcLJYLAwfPpycnBz27t1LYWEhmzdv5u677+byyy/H5XLx6aefoqqq0aHqTtM0cnJymDFjBoWFhXz00Uc89NBDvPLKK/Ts2ZPFixdTVVUVse85h8OB1WrlzTffPFZvkpuby5AhQ0hLS2PVqlUGRxg68XLOjIXzokxu4th5551HgwYNsFqtqKrKypUradu2LRs2bGDXrl0xXSgHYqjZ4XDw+eefM2rUKGrVqsWgQYN46qmnGDBgABdddBE//fQTHo8n5l8LI5hMJkwmE7Vr1+aZZ56hUaNGVFdX06JFC9q1a8fy5ctxuVxGh6k7RVF46KGHmD9/Po899hh79uxBVVVyc3Np374969evj9j3nKqqJCQk8NZbb/HBBx9w1113Hfu3hg0b0q1bNz755JOY/L1BfJwzY+W8KJObOPLXLNvj8eDxeLjiiiu48soreeqpp7jvvvuwWq1YLLFdjqVpGiaTCY/Hg9PppGfPnqSkpLBz585jt9m6dSs2m83AKGPT8a72al7nmv8WFxfTqFGjiD55+qvmebvdbrKzs5k7dy45OTnMnDmTvXv3ArB9+3aSkpIi8or4j38z9evXZ/78+bz55puMGTPmWPzl5eVkZmbGzO8t3s6ZsXRelLuCx7gZM2ZQVlZG165dycvLw+FwAOD1ejGbzSxYsICRI0fywAMPcOONNwJQVlZGSkqKkWGHxIlei5rlnAUFBbRp04bu3btTp04d5syZw9y5c2nfvr3BkUe/E732f7Vnzx5mz57NQw89xKJFizjjjDPCHKm+TvX3t23bNi6++GLS09MxmUxs2LCBzz//PGLecyeKv6bAduvWrQwdOpTU1FRMJhMbN25k3rx5ERN/IOLtnBmr50WZ3MSwwYMHU1BQQF5eHps3b2bgwIEMHTqULl26HLtNcXExBw4coEmTJsdOWLHoVK+F2+3GarWyY8cOXnnlFbKysrjwwgvJz883OPLod6rXvuYk6na7eeSRR/jwww959913adeuncGRB8fX91x5eTnr16+nsrKSRo0a0aBBA4MjF3yNv6ysjHXr1lFWVkazZs2ievVQvJ0zY/q8qEkxafHixVqLFi00r9eraZqmzZs3T7vmmmu0ESNGaN99993fbq+qarhDDBt/X4ua20nB8/e1Lykp0fbs2RPuMHXn7/OONNEefyDi7ZwZ6+fF6E05pZNyOp3k5uZSUVGBqqr069ePMWPGkJSUxMyZM9m1axcA06ZNY8mSJTEzR348/r4W0XwlFmn8ee0XLlyIw+Ggdu3aBkcdPH/fc5Em2uMPRLydM2P9vBhd0Uo+y87OZuPGjUyZMuXYm7Jz584MGzaMdevWsWnTJgDWrVsX8+3u5WthHH9e+9zcXCND1VW0v+eiPf5AxNtzjvnna/TQkRQ6c+bM0XJycrR33nlH07Tfh1HHjBmjjRgxQtM0TauurjYsvnCSr4Vx4vW1j/bnHe3xByLennMsP9/oX7smndCgQYPYt28f48aNo6Ki4lhb9KysLCoqKgCiYkmfHuRrYZx4fe2j/XlHe/yBiLfnHNPP1+jsSgott9utvfvuu1pSUpI2cOBA7eKLL9acTqe2du1ao0MLO/laGCdeX/tof97RHn8g4u05x+rzlUvB48SmTZtYtmwZlZWVnHPOOTRr1szokAwjXwvjxOtrH+3PO9rjD0S8PedYe74yuZEkSZIkKabI1VKSJEmSJMUUmdxIkiRJkhRTZHIjSZIkSVJMkcmNJEmSJEkxRSY3kiRJkiTFFJncSJIkSZIUU2RyI0mSJElSTJHJjSRJkiRJMUUmN5IkSZIkxRSZ3EgBmzRpEnl5eSQkJNClSxdWrFhhdEhSHPv6668ZOHAgderUQVEU5syZY3RIUpybOHEinTp1wuFwkJOTw0UXXcQvv/xidFhxQSY3UkBmzZrFnXfeycMPP8yaNWto06YN/fv358CBA0aHJsWp8vJy2rRpw6RJk4wORZIAWLJkCTfffDPLly/nyy+/xO12069fP8rLy40OLebJvaWkgHTp0oVOnTrx8ssvA6CqKvXr1+fWW2/lvvvuMzg6Kd4pisLs2bO56KKLjA5Fko45ePAgOTk5LFmyhJ49exodTkyTIzeS31wuF6tXr6Zv377HfmYymejbty/Lli0zMDJJkqTIVVxcDEBGRobBkcQ+mdxIfissLMTr9ZKbm/unn+fm5rJv3z6DopIkSYpcqqpy++23c9ZZZ9GqVSujw4l5FqMDkCRJkqRYd/PNN7N+/Xq+/fZbo0OJCzK5kfyWlZWF2Wxm//79f/r5/v37qVWrlkFRSZIkRaZbbrmFTz/9lK+//pp69eoZHU5ckNNSkt9sNhsdOnRgwYIFx36mqioLFiygW7duBkYmSZIUOTRN45ZbbmH27NksXLiQ0047zeiQ4oYcuZECcueddzJq1Cg6duxI586def755ykvL+fqq682OjQpTpWVlbF169Zj///bb7+xdu1aMjIyaNCggYGRSfHq5ptv5t133+Wjjz7C4XAcq0lMTU0lMTHR4Ohim1wKLgXs5Zdf5plnnmHfvn20bduWF198kS5duhgdlhSnFi9eTJ8+ff7281GjRvH222+HPyAp7imKctyfv/XWW4wePTq8wcQZmdxIkiRJkhRTZM2NJEmSJEkxRSY3kiRJkiTFFJncSJIkSZIUU2RyI0mSJElSTJHJjSRJkiRJMUUmN5IkSZIkxRSZ3EiSJEmSFFNkciNJkiRJUkyRyY0kSZIkSTFFJjeSJEmSJMUUmdxIkiRJkhRTZHIjSZIkSVJM+X9eouXrb9ei8wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012
0DiagonalAx...OffDiagona...OffDiagona...
1OffDiagona...DiagonalAx...OffDiagona...
2OffDiagona...OffDiagona...DiagonalAx...
\n", + "
" + ], + "text/plain": [ + " 0 1 2\n", + "0 DiagonalAx... OffDiagona... OffDiagona...\n", + "1 OffDiagona... DiagonalAx... OffDiagona...\n", + "2 OffDiagona... OffDiagona... DiagonalAx..." + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Creating mock dataset AB\n", + "nlive = 100\n", + "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", + "meanAB_=meanAB.flatten().tolist()\n", + "covAB_=covAB.tolist()\n", + "samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds)\n", + "samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012logLlogL_birthnlive
weights
03.159818e-2680.0320580.9928430.610632-621.584807-inf200
13.485225e-2010.0356740.8505970.156593-467.213587-inf199
22.431671e-1960.0062680.8096860.011415-456.060616-inf198
34.560066e-1930.1990280.9874290.044495-448.524102-inf197
46.901140e-1880.1489170.9265060.702908-436.596827-inf196
........................
12302.385761e-010.4042000.2593180.318285-0.021252-0.5689815
12312.395665e-010.3885960.2373880.289041-0.017109-0.3378704
12322.406134e-010.3894500.2422440.298375-0.012748-0.9852763
12332.418517e-010.4030890.2502710.281706-0.007615-0.3378702
12342.422749e-010.4074970.2560890.301366-0.005867-0.3378701
\n", + "

1235 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 logL logL_birth \\\n", + " weights \n", + "0 3.159818e-268 0.032058 0.992843 0.610632 -621.584807 -inf \n", + "1 3.485225e-201 0.035674 0.850597 0.156593 -467.213587 -inf \n", + "2 2.431671e-196 0.006268 0.809686 0.011415 -456.060616 -inf \n", + "3 4.560066e-193 0.199028 0.987429 0.044495 -448.524102 -inf \n", + "4 6.901140e-188 0.148917 0.926506 0.702908 -436.596827 -inf \n", + "... ... ... ... ... ... \n", + "1230 2.385761e-01 0.404200 0.259318 0.318285 -0.021252 -0.568981 \n", + "1231 2.395665e-01 0.388596 0.237388 0.289041 -0.017109 -0.337870 \n", + "1232 2.406134e-01 0.389450 0.242244 0.298375 -0.012748 -0.985276 \n", + "1233 2.418517e-01 0.403089 0.250271 0.281706 -0.007615 -0.337870 \n", + "1234 2.422749e-01 0.407497 0.256089 0.301366 -0.005867 -0.337870 \n", + "\n", + " nlive \n", + " weights \n", + "0 3.159818e-268 200 \n", + "1 3.485225e-201 199 \n", + "2 2.431671e-196 198 \n", + "3 4.560066e-193 197 \n", + "4 6.901140e-188 196 \n", + "... ... \n", + "1230 2.385761e-01 5 \n", + "1231 2.395665e-01 4 \n", + "1232 2.406134e-01 3 \n", + "1233 2.418517e-01 2 \n", + "1234 2.422749e-01 1 \n", + "\n", + "[1235 rows x 6 columns]" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samplesAB" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012
0DiagonalAx...OffDiagona...OffDiagona...
1OffDiagona...DiagonalAx...OffDiagona...
2OffDiagona...OffDiagona...DiagonalAx...
\n", + "
" + ], + "text/plain": [ + " 0 1 2\n", + "0 DiagonalAx... OffDiagona... OffDiagona...\n", + "1 OffDiagona... DiagonalAx... OffDiagona...\n", + "2 OffDiagona... OffDiagona... DiagonalAx..." + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Creating mock datasets A, B and AB\n", + "# Creating mock dataset A\n", + "nlive = 100\n", + "meanA = [0.1, 0.3, 0.5]\n", + "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", + "#samplesA.gui()\n", + "#plt.show()\n", + "\n", + "# Creating mock dataset B\n", + "nlive = 100\n", + "meanB = [0.7, 0.2, 0.1]\n", + "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", + "#bounds = [[0, 1], [0,1], [0, 1]]\n", + "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", + "# Make a plot\n", + "axes = samplesA.plot_2d([0,1,2])\n", + "samplesB.plot_2d(axes)\n", + "\n", + "# Calculate covariance of AB using equation 19 from paper\n", + "covA_inv = linalg.inv(covA)\n", + "covB_inv = linalg.inv(covB)\n", + "covAB_inv = covA_inv+covB_inv\n", + "covAB = linalg.inv(covAB_inv)\n", + "\n", + "# Calculate mean of AB using equation 20 from paper\n", + "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", + "meanAB = np.asarray(meanAB.transpose())\n", + "\n", + "# Creating mock dataset AB\n", + "nlive = 100\n", + "# Matching the input for the func correlated_gaussian\n", + "meanAB_=meanAB.flatten().tolist()\n", + "covAB_=covAB.tolist()\n", + "\n", + "samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds)\n", + "samplesAB.plot_2d(axes)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for -: 'method' and 'method'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 14\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n\u001b[0;32m---> 60\u001b[0m samples \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB,samplesAB,nsamples)\n", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 11\u001b[0m, in \u001b[0;36mtension_stats\u001b[0;34m(A, B, AB, nsamples)\n\u001b[1;32m 55\u001b[0m \u001b[39m# Create a new sample\u001b[39;00m\n\u001b[1;32m 56\u001b[0m samples \u001b[39m=\u001b[39m Samples(index\u001b[39m=\u001b[39mA\u001b[39m.\u001b[39mindex)\n\u001b[0;32m---> 57\u001b[0m samples[\u001b[39m'\u001b[39m\u001b[39mlogR\u001b[39m\u001b[39m'\u001b[39m]\u001b[39m=\u001b[39mAB\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39;49mA\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39mB\u001b[39m.\u001b[39mlogZ\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'method' and 'method'" + ] + } + ], + "source": [ + "nsamples = 1000\n", + "Beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " A.stats(nsamples)\n", + " B.stats(nsamples)\n", + " AB.stats(nsamples)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples\n", + "samples = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for -: 'method' and 'method'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 14\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples,A,statsA\n\u001b[0;32m---> 60\u001b[0m samples,A,statsA \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB,samplesAB,nsamples)\n", + "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 11\u001b[0m, in \u001b[0;36mtension_stats\u001b[0;34m(A, B, AB, nsamples)\n\u001b[1;32m 55\u001b[0m \u001b[39m# Create a new sample\u001b[39;00m\n\u001b[1;32m 56\u001b[0m samples \u001b[39m=\u001b[39m Samples(index\u001b[39m=\u001b[39mA\u001b[39m.\u001b[39mindex)\n\u001b[0;32m---> 57\u001b[0m samples[\u001b[39m'\u001b[39m\u001b[39mlogR\u001b[39m\u001b[39m'\u001b[39m]\u001b[39m=\u001b[39mAB\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39;49mA\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39mB\u001b[39m.\u001b[39mlogZ\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples,A,statsA\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'method' and 'method'" + ] + } + ], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " B.stats(nsamples,beta)\n", + " AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA\n", + "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " B.stats(nsamples,beta)\n", + " AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " #samples['logR']=AB.logZ-A.logZ-B.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA\n", + "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012logLlogL_birthnlive
weights
06.440561e-1310.9029580.0059860.528754-304.249343-inf200
19.059360e-1100.9705940.1742340.381037-255.553874-inf199
21.502676e-1070.9155260.1261740.752995-250.442669-inf198
31.175806e-1040.9622780.1902550.655991-243.780207-inf197
43.785914e-1000.8310710.0732960.879531-233.400534-inf196
........................
10732.001752e-010.1215240.3232210.499609-0.027063-0.8550425
10742.012080e-010.0864160.2903010.546931-0.021917-0.4891124
10752.013631e-010.1002400.3089050.484046-0.021146-0.4891123
10762.029350e-010.1163190.3142690.498682-0.013371-0.4891122
10772.031425e-010.0991590.3033260.539819-0.012349-0.4891121
\n", + "

1078 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2 logL logL_birth \\\n", + " weights \n", + "0 6.440561e-131 0.902958 0.005986 0.528754 -304.249343 -inf \n", + "1 9.059360e-110 0.970594 0.174234 0.381037 -255.553874 -inf \n", + "2 1.502676e-107 0.915526 0.126174 0.752995 -250.442669 -inf \n", + "3 1.175806e-104 0.962278 0.190255 0.655991 -243.780207 -inf \n", + "4 3.785914e-100 0.831071 0.073296 0.879531 -233.400534 -inf \n", + "... ... ... ... ... ... \n", + "1073 2.001752e-01 0.121524 0.323221 0.499609 -0.027063 -0.855042 \n", + "1074 2.012080e-01 0.086416 0.290301 0.546931 -0.021917 -0.489112 \n", + "1075 2.013631e-01 0.100240 0.308905 0.484046 -0.021146 -0.489112 \n", + "1076 2.029350e-01 0.116319 0.314269 0.498682 -0.013371 -0.489112 \n", + "1077 2.031425e-01 0.099159 0.303326 0.539819 -0.012349 -0.489112 \n", + "\n", + " nlive \n", + " weights \n", + "0 6.440561e-131 200 \n", + "1 9.059360e-110 199 \n", + "2 1.502676e-107 198 \n", + "3 1.175806e-104 197 \n", + "4 3.785914e-100 196 \n", + "... ... \n", + "1073 2.001752e-01 5 \n", + "1074 2.012080e-01 4 \n", + "1075 2.013631e-01 3 \n", + "1076 2.029350e-01 2 \n", + "1077 2.031425e-01 1 \n", + "\n", + "[1078 rows x 6 columns]" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.3384253.174730-1.1636942.028366
1-4.0202712.933097-1.0871741.833509
2-4.4464153.220232-1.2261842.031067
3-4.0390502.963091-1.0759591.550850
4-4.0109462.912096-1.0988501.853250
...............
995-4.2840073.195151-1.0888561.625164
996-4.3971973.220436-1.1767611.863146
997-4.0334772.979882-1.0535951.658587
998-4.3899843.176785-1.2131992.053731
999-3.9008492.810499-1.0903491.616558
\n", + "

1000 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " logZ D_KL logL_P d_G\n", + "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", + "samples \n", + "0 -4.338425 3.174730 -1.163694 2.028366\n", + "1 -4.020271 2.933097 -1.087174 1.833509\n", + "2 -4.446415 3.220232 -1.226184 2.031067\n", + "3 -4.039050 2.963091 -1.075959 1.550850\n", + "4 -4.010946 2.912096 -1.098850 1.853250\n", + "... ... ... ... ...\n", + "995 -4.284007 3.195151 -1.088856 1.625164\n", + "996 -4.397197 3.220436 -1.176761 1.863146\n", + "997 -4.033477 2.979882 -1.053595 1.658587\n", + "998 -4.389984 3.176785 -1.213199 2.053731\n", + "999 -3.900849 2.810499 -1.090349 1.616558\n", + "\n", + "[1000 rows x 4 columns]" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statsA" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " statsB=B.stats(nsamples,beta)\n", + " statsAB=AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA\n", + "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logR
weights
06.440561e-131NaN
19.059360e-110NaN
21.502676e-107NaN
31.175806e-104NaN
43.785914e-100NaN
.........
10732.001752e-01NaN
10742.012080e-01NaN
10752.013631e-01NaN
10762.029350e-01NaN
10772.031425e-01NaN
\n", + "

1078 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " logR\n", + " weights \n", + "0 6.440561e-131 NaN\n", + "1 9.059360e-110 NaN\n", + "2 1.502676e-107 NaN\n", + "3 1.175806e-104 NaN\n", + "4 3.785914e-100 NaN\n", + "... ...\n", + "1073 2.001752e-01 NaN\n", + "1074 2.012080e-01 NaN\n", + "1075 2.013631e-01 NaN\n", + "1076 2.029350e-01 NaN\n", + "1077 2.031425e-01 NaN\n", + "\n", + "[1078 rows x 1 columns]" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "EOL while scanning string literal (, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[133], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m statsA\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n" + ] + } + ], + "source": [ + "statsA\"" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.1717443.056473-1.1152711.786759
1-4.0468643.009728-1.0371361.597706
2-4.3112283.202833-1.1083951.809025
3-4.1209472.972869-1.1480781.879480
4-4.3511523.157193-1.1939602.091767
...............
995-3.9253182.862501-1.0628171.614719
996-4.4804333.319033-1.1614002.062474
997-4.3017203.160843-1.1408771.703830
998-4.1772713.036093-1.1411782.059596
999-4.0980362.980327-1.1177081.819270
\n", + "

1000 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " logZ D_KL logL_P d_G\n", + "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", + "samples \n", + "0 -4.171744 3.056473 -1.115271 1.786759\n", + "1 -4.046864 3.009728 -1.037136 1.597706\n", + "2 -4.311228 3.202833 -1.108395 1.809025\n", + "3 -4.120947 2.972869 -1.148078 1.879480\n", + "4 -4.351152 3.157193 -1.193960 2.091767\n", + "... ... ... ... ...\n", + "995 -3.925318 2.862501 -1.062817 1.614719\n", + "996 -4.480433 3.319033 -1.161400 2.062474\n", + "997 -4.301720 3.160843 -1.140877 1.703830\n", + "998 -4.177271 3.036093 -1.141178 2.059596\n", + "999 -4.098036 2.980327 -1.117708 1.819270\n", + "\n", + "[1000 rows x 4 columns]" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statsA" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " statsB=B.stats(nsamples,beta)\n", + " statsAB=AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA,statsB,statsAB\n", + "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.2801043.103178-1.1769262.203933
1-4.6271343.400734-1.2264002.354423
2-4.6072453.402678-1.2045672.375870
3-4.2828273.037355-1.2454732.120491
4-4.4541023.259298-1.1948042.230798
...............
995-4.4802523.255807-1.2244462.220415
996-4.4484043.214183-1.2342212.128176
997-4.2972243.076654-1.2205712.316718
998-4.6741193.454976-1.2191442.371506
999-4.4302023.204460-1.2257422.408287
\n", + "

1000 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " logZ D_KL logL_P d_G\n", + "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", + "samples \n", + "0 -4.280104 3.103178 -1.176926 2.203933\n", + "1 -4.627134 3.400734 -1.226400 2.354423\n", + "2 -4.607245 3.402678 -1.204567 2.375870\n", + "3 -4.282827 3.037355 -1.245473 2.120491\n", + "4 -4.454102 3.259298 -1.194804 2.230798\n", + "... ... ... ... ...\n", + "995 -4.480252 3.255807 -1.224446 2.220415\n", + "996 -4.448404 3.214183 -1.234221 2.128176\n", + "997 -4.297224 3.076654 -1.220571 2.316718\n", + "998 -4.674119 3.454976 -1.219144 2.371506\n", + "999 -4.430202 3.204460 -1.225742 2.408287\n", + "\n", + "[1000 rows x 4 columns]" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statsB" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.9906023.574315-1.4162872.634555
1-5.0828373.619382-1.4634552.569358
2-5.1766143.761474-1.4151412.692252
3-4.7960053.440258-1.3557472.369404
4-5.0481693.595502-1.4526662.506467
...............
995-4.8756113.548798-1.3268132.363104
996-4.8812223.493873-1.3873492.525472
997-4.8709383.538388-1.3325502.511589
998-5.0845793.585871-1.4987082.551930
999-4.8901433.492245-1.3978982.433410
\n", + "

1000 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " logZ D_KL logL_P d_G\n", + "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", + "samples \n", + "0 -4.990602 3.574315 -1.416287 2.634555\n", + "1 -5.082837 3.619382 -1.463455 2.569358\n", + "2 -5.176614 3.761474 -1.415141 2.692252\n", + "3 -4.796005 3.440258 -1.355747 2.369404\n", + "4 -5.048169 3.595502 -1.452666 2.506467\n", + "... ... ... ... ...\n", + "995 -4.875611 3.548798 -1.326813 2.363104\n", + "996 -4.881222 3.493873 -1.387349 2.525472\n", + "997 -4.870938 3.538388 -1.332550 2.511589\n", + "998 -5.084579 3.585871 -1.498708 2.551930\n", + "999 -4.890143 3.492245 -1.397898 2.433410\n", + "\n", + "[1000 rows x 4 columns]" + ] + }, + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statsAB" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "samples\n", + "0 3.087781\n", + "1 3.498871\n", + "2 3.512691\n", + "3 3.682961\n", + "4 3.614406\n", + " ... \n", + "995 3.525633\n", + "996 3.702340\n", + "997 3.607038\n", + "998 3.669652\n", + "999 3.523506\n", + "Name: $\\ln\\mathcal{Z}$, Length: 1000, dtype: float64" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statsAB.logZ-statsA.logZ-statsB.logZ" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " statsB=B.stats(nsamples,beta)\n", + " statsAB=AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=A.index)\n", + " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA,statsB,statsAB\n", + "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logR
weights
06.440561e-131NaN
19.059360e-110NaN
21.502676e-107NaN
31.175806e-104NaN
43.785914e-100NaN
.........
10732.001752e-01NaN
10742.012080e-01NaN
10752.013631e-01NaN
10762.029350e-01NaN
10772.031425e-01NaN
\n", + "

1078 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " logR\n", + " weights \n", + "0 6.440561e-131 NaN\n", + "1 9.059360e-110 NaN\n", + "2 1.502676e-107 NaN\n", + "3 1.175806e-104 NaN\n", + "4 3.785914e-100 NaN\n", + "... ...\n", + "1073 2.001752e-01 NaN\n", + "1074 2.012080e-01 NaN\n", + "1075 2.013631e-01 NaN\n", + "1076 2.029350e-01 NaN\n", + "1077 2.031425e-01 NaN\n", + "\n", + "[1078 rows x 1 columns]" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [], + "source": [ + "nsamples = 1000\n", + "beta = 1\n", + "def tension_stats(A,B,AB,nsamples):\n", + " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", + " statsA= A.stats(nsamples,beta)\n", + " statsB=B.stats(nsamples,beta)\n", + " statsAB=AB.stats(nsamples,beta)\n", + " # Create a new sample\n", + " samples = Samples(index=statsA.index)\n", + " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", + " # do the same for logS, logI, d_G, p, return these values in a table\n", + " return samples,A,statsA,statsB,statsAB\n", + "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
logR
samples
03.673867
13.654226
23.620559
33.650832
43.903685
......
9953.578809
9963.778822
9973.559742
9983.635960
9993.725074
\n", + "

1000 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " logR\n", + "samples \n", + "0 3.673867\n", + "1 3.654226\n", + "2 3.620559\n", + "3 3.650832\n", + "4 3.903685\n", + "... ...\n", + "995 3.578809\n", + "996 3.778822\n", + "997 3.559742\n", + "998 3.635960\n", + "999 3.725074\n", + "\n", + "[1000 rows x 1 columns]" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tension.py b/tension.py index 5d9c98cb..0a7dd4c1 100644 --- a/tension.py +++ b/tension.py @@ -1,6 +1,28 @@ +import numpy as np +import scipy as sp class TensionCalculator: def __init__(self,A,B,AB,nsamples): - self.nsamples = nsamples + self.nsamples = nsamples # draw from random compress t self.A = A.stats(nsamples) self.B = B.stats(nsamples) - self.AB = AB.stats(nsamples) \ No newline at end of file + self.AB = AB.stats(nsamples) + +def logR(self): + return self.AB.logZ-self.A.logZ-self.B.logZ + +def logS(self, A, B): + return self.stat(A, B, 'logL_P') + +def d(self, A, B): + return self.stat(A, B, 'd_G') + +def D_KL(self, A, B): + return self.stat(A, B, 'D_KL') + +def p(self, A, B, d=None): + logS = self.logS(A, B) + if d is None: + d = self.d(A, B) + else: + d = np.ones_like(logS)*d + return sp.stats.chi2.sf(d[d>0]-2*logS[d>0], d[d>0]) \ No newline at end of file diff --git a/tension_stats.py b/tension_stats.py new file mode 100644 index 00000000..31c20890 --- /dev/null +++ b/tension_stats.py @@ -0,0 +1,40 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +#%% +# Creating mock datasets A, B and AB +nlive = 100 +meanA = [0.1, 0.3, 0.5] +covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, mean, cov, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +nlive = 100 +meanB = [0.7, 0.2, 0.1] +covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, mean, cov, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + + +nsamples = 1000 +Beta = 1 +def tension_stats(A,B,AB,nsamples): + # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian + A.stats(nsamples) + B.stats(nsamples) + AB.stats(nsamples) + # Create a new sample + samples = Samples(index=A.index) + samples['logR']=AB.logZ-A.logZ-B.logZ + # do the same for logS, logI, d_G, p, return these values in a table + return samples +samples = tension_stats(samplesA,samplesB) +# %% diff --git a/tension_stats_2.py b/tension_stats_2.py new file mode 100644 index 00000000..6f44e7c2 --- /dev/null +++ b/tension_stats_2.py @@ -0,0 +1,93 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +#%% +# Creating mock datasets A, B and AB +# Creating mock dataset A +nlive = 100 +meanA = [0.1, 0.3, 0.5] +covA = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +# Creating mock dataset B +nlive = 100 +meanB = [0.7, 0.2, 0.1] +covB = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +# Calculate covariance of AB using equation 19 from paper +covA_inv = linalg.inv(covA) +covB_inv = linalg.inv(covB) +covAB_inv = covA_inv+covB_inv +covAB = linalg.inv(covAB_inv) + +# Calculate mean of AB using equation 20 from paper +meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose())) +meanAB = np.asarray(meanAB.transpose()) + +# Creating mock dataset AB +nlive = 100 +# Matching the input for the func correlated_gaussian +meanAB_=meanAB.flatten().tolist() +covAB_=covAB.tolist() + +samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds) +samplesAB.plot_2d(axes) +#%% +# Set parameters +nsamples = 1000 +beta = 1 + +def tension_stats(A,B,AB,nsamples): + # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian + statsA= A.stats(nsamples,beta) + statsB=B.stats(nsamples,beta) + statsAB=AB.stats(nsamples,beta) + # Create a new sample + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsAB.d_G + samples['logL_P']=statsAB.logL_P + # do the same for logS, logI, d_G, p, return these values in a table + return samples,statsA + +samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) +print(samples) +# %% +# Calculate the exact solution of logR +def get_logR(meanA,meanB,covA,covB,V): + #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) + return -1/2*np.asmatrix(meanA_-meanB_)*linalg.inv((covA+covB))*(np.asmatrix((meanA_-meanB_)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + +V=1 +meanA_ = np.array(meanA) +meanB_ = np.array(meanB) +logR_exact = get_logR(meanA_,meanB_,covA,covB,V) +print(logR_exact) +# %% +def get_logS(meanA,meanB,covA,covB,d): + return d/2 - 1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(np.asmatrix(meanA-meanB).transpose()) +logS_exact = get_logS(meanA_,meanB_,covA,covB,3) +print(logS_exact) +# %% +def get_logI(covA,covB,d,V): + return -d/2 -1/2* - 1/2*np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) +logI_exact = get_logI(covA,covB,3,1) +print(logI_exact) +# %% diff --git a/tension_stats_3.py b/tension_stats_3.py new file mode 100644 index 00000000..6f44e7c2 --- /dev/null +++ b/tension_stats_3.py @@ -0,0 +1,93 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +#%% +# Creating mock datasets A, B and AB +# Creating mock dataset A +nlive = 100 +meanA = [0.1, 0.3, 0.5] +covA = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +# Creating mock dataset B +nlive = 100 +meanB = [0.7, 0.2, 0.1] +covB = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +# Calculate covariance of AB using equation 19 from paper +covA_inv = linalg.inv(covA) +covB_inv = linalg.inv(covB) +covAB_inv = covA_inv+covB_inv +covAB = linalg.inv(covAB_inv) + +# Calculate mean of AB using equation 20 from paper +meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose())) +meanAB = np.asarray(meanAB.transpose()) + +# Creating mock dataset AB +nlive = 100 +# Matching the input for the func correlated_gaussian +meanAB_=meanAB.flatten().tolist() +covAB_=covAB.tolist() + +samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds) +samplesAB.plot_2d(axes) +#%% +# Set parameters +nsamples = 1000 +beta = 1 + +def tension_stats(A,B,AB,nsamples): + # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian + statsA= A.stats(nsamples,beta) + statsB=B.stats(nsamples,beta) + statsAB=AB.stats(nsamples,beta) + # Create a new sample + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsAB.d_G + samples['logL_P']=statsAB.logL_P + # do the same for logS, logI, d_G, p, return these values in a table + return samples,statsA + +samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) +print(samples) +# %% +# Calculate the exact solution of logR +def get_logR(meanA,meanB,covA,covB,V): + #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) + return -1/2*np.asmatrix(meanA_-meanB_)*linalg.inv((covA+covB))*(np.asmatrix((meanA_-meanB_)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + +V=1 +meanA_ = np.array(meanA) +meanB_ = np.array(meanB) +logR_exact = get_logR(meanA_,meanB_,covA,covB,V) +print(logR_exact) +# %% +def get_logS(meanA,meanB,covA,covB,d): + return d/2 - 1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(np.asmatrix(meanA-meanB).transpose()) +logS_exact = get_logS(meanA_,meanB_,covA,covB,3) +print(logS_exact) +# %% +def get_logI(covA,covB,d,V): + return -d/2 -1/2* - 1/2*np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) +logI_exact = get_logI(covA,covB,3,1) +print(logI_exact) +# %% diff --git a/tension_stats_4.py b/tension_stats_4.py new file mode 100644 index 00000000..51218f87 --- /dev/null +++ b/tension_stats_4.py @@ -0,0 +1,114 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +import matplotlib.pyplot as plt +#%% +# Creating mock datasets A, B and AB +# Creating mock dataset A +nlive = 1000 +meanA = [0.1, 0.3, 0.5] +covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +# Creating mock dataset B + +meanB = [0.7, 0.2, 0.1] +meanB = [0.1, 0.3, 0.5] +covB = np.array([[.01, -0.009, 0], [-0.009, .01, 0], [0, 0, 0.1]]) +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +# Calculate covariance of AB using equation 19 from paper +covA_inv = linalg.inv(covA) +covB_inv = linalg.inv(covB) +covAB_inv = covA_inv+covB_inv +covAB = linalg.inv(covAB_inv) + +# Calculate mean of AB using equation 20 from paper +#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) +meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) +#meanAB = np.asarray(meanAB.transpose()) + +# Creating mock dataset AB + +# Matching the input for the func correlated_gaussian +#meanAB_=meanAB.flatten().tolist() +#covAB_=covAB.tolist() + +samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) +samplesAB.plot_2d(axes) +#%% +# Set parameters +nsamples = 1000 +beta = 1 + +def tension_stats(A,B,AB,nsamples): + # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian + statsA = A.stats(nsamples,beta) + statsB = B.stats(nsamples,beta) + statsAB = AB.stats(nsamples,beta) + # Create a new sample + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G + samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P + # do the same for logS, logI, d_G, p, return these values in a table + return samples,statsA + +samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) +print(samples) +# %% +########### Using exact solution ############ +# Calculate the exact solution of logR +meandiff = np.array(meanA)-np.array(meanB) + +def get_logR(meanA,meanB,covA,covB,V): + #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) + #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + +V=1 +#meanA_ = np.array(meanA) +#meanB_ = np.array(meanB) +logR_exact = get_logR(meanA,meanB,covA,covB,V) +print(logR_exact) +samples.logR.plot.hist() +plt.axvline(logR_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logS(meanA,meanB,covA,covB,d): + return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) +d=2 +logS_exact = get_logS(meanA,meanB,covA,covB,2) +print(logS_exact) +samples.logS.plot.hist() +plt.axvline(logS_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logI(covA,covB,d,V): + return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) +logI_exact = get_logI(covA,covB,d,V) +print(logI_exact) +samples.logI.plot.hist() +plt.axvline(logI_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% diff --git a/tension_stats_4.py.zip b/tension_stats_4.py.zip new file mode 100644 index 0000000000000000000000000000000000000000..88df2608706b21718b03ed9542fa3aebb9cd3f44 GIT binary patch literal 1721 zcmbu9X*AS(7{~u(W{lm`2t&#mQyNRC8LOt}*=OZ0);sA`Luj=)T-%t1*79k3NAZs81;QIi; z4JY#DDFgWCf`^i}1&`33%eoqp)Yd~rm2vIS6l038d2M!Ap-OX3;o#<%p?BTXSB*0( zN^8ESi$^M$^bN_~En$QOAq1Yi-#Jpws(~Ydwz|jZbE7A18y;A1*Cd=0! z+!kW0&qJEN{ac&DCc`KBw>7OAHD$806u$H^ta56=6RzM99{XU2>b7k67dnnRD)+89 z;#w!=*&Gw381wA}(e^UFh7`&jfyu?JAXFfkOVvWHRK$0Q}1=&U(7x2wh-)!+r|l4lWu7-Qz2{1#U}P2${-t#A(U9_~_=T#853pPKatd^l!wAdV4 zquFSn|lR;x^g%Yt0Q z@1WFY|A^V>=J7t5HM5vcm+iq^=6eRrd7d8HQGa3a)5g#&8#K@<|yo6dnCw zljL*#miZ>S0dzJq(-9R3f2D!!7hyN?v0V!nC@^U_BzG$Dy-7ZBM_tBvq zZ~DWIb_W}M-nmT9`jzxO6l!Om6Np+rajT&qJ-(mODs&O=`Bhs#SY>~n?D4yw5*clP zx#A|K&S|{abxQvyxHmDQRg7Ibd-CL+O^wPeJTT0Q@X;O&m`g&i??4WW0fz(mgc*a z7EOB&rwSU|Kz1@n`=U)oyA;^%8?kKHzITt zzJ}nMz*8kypSZ#2?={n{DZwewf7=IY5Rd6zs*^N5DRaD1#OUvZB zj*+~V2boM5#^A-xFz9vRV@Dnsii*>y&i=BSS92U%uB3f}>b`A!kQXnny9vcw!-NKM zTNP>`0I)?p>`!?(#wVKspNAeEw#Q6QIk;${J^llY2?qZ{<5}X4vpz%;amm)kX-U#4 z1$#jtQx>camj^BHRTNxa)P_TMnwlh*+GJiq9pxodUD~EJR8m;N$#ubIGT6BVd4*sp zPp_KP&pW-AUQEuFr@Y^TZ!Q`__-Gy8$_*1@Qewsl{G?lHvDP2~De&K9|8d7HvVRvV sVe9oD%lw4%|MdUy@2yLH7b^h{1^(aNu+~t)Ejs~z_4DU*z99ho30mgWqyPW_ literal 0 HcmV?d00001 diff --git a/tension_stats_5.py b/tension_stats_5.py new file mode 100644 index 00000000..6ffc9c70 --- /dev/null +++ b/tension_stats_5.py @@ -0,0 +1,113 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +import matplotlib.pyplot as plt +#%% +# Creating mock datasets A, B and AB +# Creating mock dataset A +nlive = 1000 +meanA = [0.1, 0.3, 0.5] +covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +# Creating mock dataset B + +meanB = [0.7, 0.2, 0.1] +meanB = [0.1, 0.3, 0.5] +covB = np.array([[.01, -0.009, 0], [-0.009, .01, 0], [0, 0, 0.1]])*0.01 +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +# Calculate covariance of AB using equation 19 from paper +covA_inv = linalg.inv(covA) +covB_inv = linalg.inv(covB) +covAB_inv = covA_inv+covB_inv +covAB = linalg.inv(covAB_inv) + +# Calculate mean of AB using equation 20 from paper +#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) +meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) +#meanAB = np.asarray(meanAB.transpose()) + +# Creating mock dataset AB + +# Matching the input for the func correlated_gaussian +#meanAB_=meanAB.flatten().tolist() +#covAB_=covAB.tolist() + +samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) +samplesAB.plot_2d(axes) +#%% +# Set parameters +nsamples = 1000 +beta = 1 + +def tension_stats(A,B,AB,nsamples): + # Compute Nested Sampling statistics + statsA = A.stats(nsamples,beta) + statsB = B.stats(nsamples,beta) + statsAB = AB.stats(nsamples,beta) + + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G + samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P + return samples + +samples = tension_stats(samplesA,samplesB,samplesAB,nsamples) +print(samples) +# %% +########### Using exact solution ############ +# Calculate the exact solution of logR +meandiff = np.array(meanA)-np.array(meanB) + +def get_logR(meanA,meanB,covA,covB,V): + #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) + #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + +V=1 +#meanA_ = np.array(meanA) +#meanB_ = np.array(meanB) +logR_exact = get_logR(meanA,meanB,covA,covB,V) +print(logR_exact) +samples.logR.plot.hist() +plt.axvline(logR_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logS(meanA,meanB,covA,covB,d): + return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) +d=3 +logS_exact = get_logS(meanA,meanB,covA,covB,d) +print(logS_exact) +samples.logS.plot.hist() +plt.axvline(logS_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logI(covA,covB,d,V): + return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) +logI_exact = get_logI(covA,covB,d,V) +print(logI_exact) +samples.logI.plot.hist() +plt.axvline(logI_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% diff --git a/tension_stats_5.py.zip b/tension_stats_5.py.zip new file mode 100644 index 0000000000000000000000000000000000000000..c70e680ecf34feb0c596ceef59b3ea18b73f85b0 GIT binary patch literal 1358 zcmWIWW@Zs#-~hsdCSKtTQ1FbGfkB8tfuSTduQ)S5FTS`Wv7|WORIi{iG=!Id-TJXg zstpi>=+X*q21b@|j0_Awa~K%bhDG-;HWR6P9vSc+nQ+2${wumY%|6_Bv&8#QQbJuc9aYoIT z=F`q>ZjoC!pYuU(JF237U8HTbHsL=3&%Db zRJA{7VD#KNDD0*Aq(D#B$xS*;LWiG7MjqMTbmGuM*SZ81rOhu(UQOxw#42(Aa)H={ z%pZ*V?bglRV)ejiz4I-TFGs8E_?BxWSp8+`FKv)~6}x^lYemwDoW0+UKbUJdd)3pK z2R^-+^HSk6L-E@g!bifw`wj&!X1ZmO;!v=x;l(VwLeHzGc1=|gf5LB}Gfgm*xBSkQ zJB7J#3$8z#_kIUMyvDby_8;nm=iUhHI3hJszQDYA@6w0AEQ3CZE>Uw{p;n&o^d5KE zAG3&!Oxo`bH2wX@*P}W`VY*C;uEH(Nmrmu-JJ?DshLu`6e_TjcF&%fn62 zfALegoX=f%a>w)bOAp) zY_fO$v_D*amxX%vDNEHlZ_qnc=eMt9XIAqDgBw-pk@K}K7~C|wbM55`uHSY`yPqZ| zOx1re<7V-Rm9yt~uQ!fu(s^tD#9vp(eU=xK_@2;DMjQqHBAoh9B6VI&wo=%m6S?m$ zUw!zN79YQy3Gzq(%1-7~d!?{eqftn1se%8re{6jx-~6pvM#M2D|CEwA{hs;Q{s3=w4)w2!w<=f|7(k_0fHxzP2s5H& iLzV-TY%s8-5yT?BoD1+~WdrGC1i}O$eFJDO0|NkJv|y+J literal 0 HcmV?d00001 diff --git a/tension_stats_6.py b/tension_stats_6.py new file mode 100644 index 00000000..13708802 --- /dev/null +++ b/tension_stats_6.py @@ -0,0 +1,122 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +import matplotlib.pyplot as plt +#%% +# Creating mock datasets A, B and AB +# Creating mock dataset A +nlive = 1000 +meanA = [0.1, 0.3, 0.5] +covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() + +# Creating mock dataset B + +# Datasets being incompatible +meanB = [0.15, 0.25, 0.45] +# Datasets being compatible +#meanB = [0.1, 0.3, 0.5] + +covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +# Calculate covariance of AB using equation 19 from paper +covA_inv = linalg.inv(covA) +covB_inv = linalg.inv(covB) +covAB_inv = covA_inv+covB_inv +covAB = linalg.inv(covAB_inv) + +# Calculate mean of AB using equation 20 from paper +#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) +meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) +#meanAB = np.asarray(meanAB.transpose()) + +# Creating mock dataset AB + +# Matching the input for the func correlated_gaussian +#meanAB_=meanAB.flatten().tolist() +#covAB_=covAB.tolist() + +samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) +samplesAB.plot_2d(axes) +#%% +# Set parameters +nsamples = 1000 +beta = 1 + +def tension_stats(A,B,AB,nsamples): + # Compute Nested Sampling statistics + statsA = A.stats(nsamples,beta) + statsB = B.stats(nsamples,beta) + statsAB = AB.stats(nsamples,beta) + + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G + samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P + return samples + +samples = tension_stats(samplesA,samplesB,samplesAB,nsamples) +print(samples) +axes = samples.plot_2d(['logR','logI','logS','d_G','logL_P']) +#%% +# Another way to make corner plots +params = ['logR','logI','logS','d_G','logL_P'] +fig, axes = make_2d_axes(params, figsize=(6, 6), facecolor='w', upper=False) +samples.plot_2d(axes)#, label="model 1") +# %% +########### Using exact solution ############ +# Calculate the exact solution of logR +meandiff = np.array(meanA)-np.array(meanB) + +def get_logR(meanA,meanB,covA,covB,V): + #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) + #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + + +V=1 +#meanA_ = np.array(meanA) +#meanB_ = np.array(meanB) +logR_exact = get_logR(meanA,meanB,covA,covB,V) +print(logR_exact) +samples.logR.plot.hist() +plt.axvline(logR_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logS(meanA,meanB,covA,covB,d): + return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) +d=3 +logS_exact = get_logS(meanA,meanB,covA,covB,d) +print(logS_exact) +samples.logS.plot.hist() +plt.axvline(logS_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% +def get_logI(covA,covB,d,V): + return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) +logI_exact = get_logI(covA,covB,d,V) +print(logI_exact) +samples.logI.plot.hist() +plt.axvline(logI_exact,color='r',label='Exact solution') +plt.legend() +plt.show() +# %% diff --git a/tests/test_tension.py b/tests/test_tension.py index 769697a3..7dba3d39 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -1,5 +1,51 @@ -import anesthetic.examples.perfect_ns +#%% +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes import numpy as np +import matplotlib.pyplot as plt +#%% +nlive = 100 +meanA = [0.1, 0.3, 0.5] +covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] +bounds = [[0, 1], [0,1], [0, 1]] +samplesA = correlated_gaussian(nlive, mean, cov, bounds) # output is Nested sampling run +#samplesA.gui() +#plt.show() +nlive = 100 +meanB = [0.7, 0.2, 0.1] +covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] +#bounds = [[0, 1], [0,1], [0, 1]] +samplesB = correlated_gaussian(nlive, mean, cov, bounds) +# Make a plot +axes = samplesA.plot_2d([0,1,2]) +samplesB.plot_2d(axes) + +#%% +statsA = samplesA.stats(nsamples=1000) +statsB = samplesB.stats(nsamples=1000) params = ['logZ', 'D_KL', 'logL_P', 'd_G'] -stats = anesthetic.examples.perfect_ns.correlated_gaussian(100,0,np.array([1,1],[1,1])) \ No newline at end of file +fig, axes = make_2d_axes(params, figsize=(6, 6), facecolor='w', upper=False) +statsA.plot_2d(axes, label="Dataset A") +statsB.plot_2d(axes, label="Dataset B") +axes.iloc[-1, 0].legend(bbox_to_anchor=(len(axes), len(axes)), loc='upper right') + +# %% +def testGaussian(theta,mu,logLmax,v,cov): + """ + Inputs: + theta: parameters + mu: centre of Gaussian likelihood + logLmax: log of Gaussian peak + V: prior volume, for hypercube V=1 + cov: covariance of gaussian in parameters + """ + gaussLogL = logLmax - 1/2*(theta-mu)*np.linalg.inv(cov)*(theta-mu) + gaussLogP = -1/2*np.log(abs(2*np.pi*cov))-1/2*(theta-mu)*np.linalg.inv(cov)*(theta-mu) + gaussLogZ = logLmax+1/2*np.log(abs(2*np.pi*cov))-np.log(v) + D=np.log(v)-1/2*(len(theta)+np.log(abs(2*np.pi*cov))) + return gaussLogL,gaussLogP,gaussLogZ,D + +testGaussian(theta=np.array([0.111955,0.312646 ,0.542911]),mu=meanA,logLmax=samplesA['logL'].max(),v=1,cov=np.array(covA)) + +# %% From 38d31c2c05cefcc2b888fe30813f4702a027f0de Mon Sep 17 00:00:00 2001 From: dilyong Date: Fri, 13 Oct 2023 17:07:45 +0100 Subject: [PATCH 06/49] Added logLmax to the function anesthetic.examples.perfect_ns.correlated_gaussian. Within the correlated_gaussian function, changed logLike function. Changed the function's description to match the fact that evidence is not unity. --- anesthetic/examples/perfect_ns.py | 9 ++++----- tension_stats_6.py | 12 ++++++------ 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/anesthetic/examples/perfect_ns.py b/anesthetic/examples/perfect_ns.py index 69252a0e..12873f67 100644 --- a/anesthetic/examples/perfect_ns.py +++ b/anesthetic/examples/perfect_ns.py @@ -57,12 +57,11 @@ def random_sphere(n): return samples.loc[samples.logL_birth < logLend].recompute() -def correlated_gaussian(nlive, mean, cov, bounds=None): +def correlated_gaussian(nlive, mean, cov, logLmax=0, bounds=None): """Perfect nested sampling run for a correlated gaussian likelihood. This produces a perfect nested sampling run with a uniform prior over the - unit hypercube, with a likelihood gaussian in the parameters normalised so - that the evidence is unity. The algorithm proceeds by simultaneously + unit hypercube. The algorithm proceeds by simultaneously rejection sampling from the prior and sampling exactly and uniformly from the known ellipsoidal contours. @@ -95,7 +94,7 @@ def correlated_gaussian(nlive, mean, cov, bounds=None): invcov = np.linalg.inv(cov) def logLike(x): - return -0.5 * ((x-mean) @ invcov * (x-mean)).sum(axis=-1) + return logLmax -0.5 * ((x-mean) @ invcov * (x-mean)).sum(axis=-1) ndims = len(mean) @@ -104,7 +103,7 @@ def logLike(x): bounds = np.array(bounds, dtype=float) - logLmax = logLike(mean) + #logLmax = logLike(mean) # remove this line? Because logLmax is defined in the function's argument. points = np.random.uniform(*bounds.T, (2*nlive, ndims)) samples = NestedSamples(points, logL=logLike(points), logL_birth=-np.inf) diff --git a/tension_stats_6.py b/tension_stats_6.py index 13708802..9c3cfda9 100644 --- a/tension_stats_6.py +++ b/tension_stats_6.py @@ -68,27 +68,27 @@ def tension_stats(A,B,AB,nsamples): samples['logI']=logI samples['logS']=logR-logI samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G - samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P + #samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P return samples samples = tension_stats(samplesA,samplesB,samplesAB,nsamples) print(samples) -axes = samples.plot_2d(['logR','logI','logS','d_G','logL_P']) +axes = samples.plot_2d(['logR','logI','logS','d_G']) #%% # Another way to make corner plots -params = ['logR','logI','logS','d_G','logL_P'] +params = ['logR','logI','logS','d_G'] fig, axes = make_2d_axes(params, figsize=(6, 6), facecolor='w', upper=False) samples.plot_2d(axes)#, label="model 1") # %% ########### Using exact solution ############ # Calculate the exact solution of logR -meandiff = np.array(meanA)-np.array(meanB) +#meandiff = np.array(meanA)-np.array(meanB) def get_logR(meanA,meanB,covA,covB,V): #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + meandiff = np.array(meanA)-np.array(meanB) + return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) V=1 From 932a20129c678b55c0028afd5a6f08809006eabe Mon Sep 17 00:00:00 2001 From: dilyong Date: Fri, 13 Oct 2023 17:11:35 +0100 Subject: [PATCH 07/49] Clean up old tension statistics files. Put the correlated guassian likelihood test case with the tests folder. --- .DS_Store | Bin 6148 -> 6148 bytes tension.py | 28 ----- tension_calculator.py | 50 -------- tension_stats.py | 40 ------ tension_stats_2.py | 93 -------------- tension_stats_3.py | 93 -------------- tension_stats_4.py | 114 ------------------ tension_stats_4.py.zip | Bin 1721 -> 0 bytes tension_stats_5.py | 113 ----------------- tension_stats_5.py.zip | Bin 1358 -> 0 bytes .../test_tension_stats.py | 0 11 files changed, 531 deletions(-) delete mode 100644 tension.py delete mode 100644 tension_calculator.py delete mode 100644 tension_stats.py delete mode 100644 tension_stats_2.py delete mode 100644 tension_stats_3.py delete mode 100644 tension_stats_4.py delete mode 100644 tension_stats_4.py.zip delete mode 100644 tension_stats_5.py delete mode 100644 tension_stats_5.py.zip rename tension_stats_6.py => tests/test_tension_stats.py (100%) diff --git a/.DS_Store b/.DS_Store index 384f92258c4c2b23d09a087d6d0410bd6ec5c557..b1b393dd9a8b439674677fc4f19f4639d5cf951a 100644 GIT binary patch delta 46 zcmZoMXffEJ&dj)DvH?>ew?uWdp^1Txg0Y#&0]-2*logS[d>0], d[d>0]) \ No newline at end of file diff --git a/tension_calculator.py b/tension_calculator.py deleted file mode 100644 index a21c1b54..00000000 --- a/tension_calculator.py +++ /dev/null @@ -1,50 +0,0 @@ -import tension - -class tension_calculator(dict): - """Class for computing tension metrics - - Parameters - ---------- - samples : dict - Dictionary of NestedSamples - nsamples : int - Number of samples to use for computing statistics - """ - def __init__(self, samples, nsamples=1000): - for k, v in tqdm.tqdm(samples.items()): - self[k] = v.stats(nsamples) - - def union(self, A, B): - A_ = set(A.split('_')) - B_ = set(B.split('_')) - return '_'.join(sorted(list(A_.union(B_)))) - - def intersection(self, A, B): - A_ = set(A.split('_')) - B_ = set(B.split('_')) - return '_'.join(sorted(list(A_.intersection(B_)))) - - def stat(self, A, B, stat): - union = self.union(A, B) - intersection = self.intersection(A, B) - return self[union][stat] - self[A][stat] - self[B][stat] + self[intersection][stat] - - def logR(self, A, B): - return self.stat(A, B, 'logZ') - - def logS(self, A, B): - return self.stat(A, B, 'logL_P') - - def d(self, A, B): - return self.stat(A, B, 'd_G') - - def D_KL(self, A, B): - return self.stat(A, B, 'D_KL') - - def p(self, A, B, d=None): - logS = self.logS(A, B) - if d is None: - d = self.d(A, B) - else: - d = np.ones_like(logS)*d - return scipy.stats.chi2.sf(d[d>0]-2*logS[d>0], d[d>0]) \ No newline at end of file diff --git a/tension_stats.py b/tension_stats.py deleted file mode 100644 index 31c20890..00000000 --- a/tension_stats.py +++ /dev/null @@ -1,40 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -#%% -# Creating mock datasets A, B and AB -nlive = 100 -meanA = [0.1, 0.3, 0.5] -covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, mean, cov, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -nlive = 100 -meanB = [0.7, 0.2, 0.1] -covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, mean, cov, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - - -nsamples = 1000 -Beta = 1 -def tension_stats(A,B,AB,nsamples): - # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian - A.stats(nsamples) - B.stats(nsamples) - AB.stats(nsamples) - # Create a new sample - samples = Samples(index=A.index) - samples['logR']=AB.logZ-A.logZ-B.logZ - # do the same for logS, logI, d_G, p, return these values in a table - return samples -samples = tension_stats(samplesA,samplesB) -# %% diff --git a/tension_stats_2.py b/tension_stats_2.py deleted file mode 100644 index 6f44e7c2..00000000 --- a/tension_stats_2.py +++ /dev/null @@ -1,93 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -from scipy import linalg -#%% -# Creating mock datasets A, B and AB -# Creating mock dataset A -nlive = 100 -meanA = [0.1, 0.3, 0.5] -covA = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -# Creating mock dataset B -nlive = 100 -meanB = [0.7, 0.2, 0.1] -covB = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, meanB, covB, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -# Calculate covariance of AB using equation 19 from paper -covA_inv = linalg.inv(covA) -covB_inv = linalg.inv(covB) -covAB_inv = covA_inv+covB_inv -covAB = linalg.inv(covAB_inv) - -# Calculate mean of AB using equation 20 from paper -meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose())) -meanAB = np.asarray(meanAB.transpose()) - -# Creating mock dataset AB -nlive = 100 -# Matching the input for the func correlated_gaussian -meanAB_=meanAB.flatten().tolist() -covAB_=covAB.tolist() - -samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds) -samplesAB.plot_2d(axes) -#%% -# Set parameters -nsamples = 1000 -beta = 1 - -def tension_stats(A,B,AB,nsamples): - # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian - statsA= A.stats(nsamples,beta) - statsB=B.stats(nsamples,beta) - statsAB=AB.stats(nsamples,beta) - # Create a new sample - samples = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsAB.d_G - samples['logL_P']=statsAB.logL_P - # do the same for logS, logI, d_G, p, return these values in a table - return samples,statsA - -samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) -print(samples) -# %% -# Calculate the exact solution of logR -def get_logR(meanA,meanB,covA,covB,V): - #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) - return -1/2*np.asmatrix(meanA_-meanB_)*linalg.inv((covA+covB))*(np.asmatrix((meanA_-meanB_)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - -V=1 -meanA_ = np.array(meanA) -meanB_ = np.array(meanB) -logR_exact = get_logR(meanA_,meanB_,covA,covB,V) -print(logR_exact) -# %% -def get_logS(meanA,meanB,covA,covB,d): - return d/2 - 1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(np.asmatrix(meanA-meanB).transpose()) -logS_exact = get_logS(meanA_,meanB_,covA,covB,3) -print(logS_exact) -# %% -def get_logI(covA,covB,d,V): - return -d/2 -1/2* - 1/2*np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) -logI_exact = get_logI(covA,covB,3,1) -print(logI_exact) -# %% diff --git a/tension_stats_3.py b/tension_stats_3.py deleted file mode 100644 index 6f44e7c2..00000000 --- a/tension_stats_3.py +++ /dev/null @@ -1,93 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -from scipy import linalg -#%% -# Creating mock datasets A, B and AB -# Creating mock dataset A -nlive = 100 -meanA = [0.1, 0.3, 0.5] -covA = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -# Creating mock dataset B -nlive = 100 -meanB = [0.7, 0.2, 0.1] -covB = np.asmatrix([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, meanB, covB, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -# Calculate covariance of AB using equation 19 from paper -covA_inv = linalg.inv(covA) -covB_inv = linalg.inv(covB) -covAB_inv = covA_inv+covB_inv -covAB = linalg.inv(covAB_inv) - -# Calculate mean of AB using equation 20 from paper -meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose())) -meanAB = np.asarray(meanAB.transpose()) - -# Creating mock dataset AB -nlive = 100 -# Matching the input for the func correlated_gaussian -meanAB_=meanAB.flatten().tolist() -covAB_=covAB.tolist() - -samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds) -samplesAB.plot_2d(axes) -#%% -# Set parameters -nsamples = 1000 -beta = 1 - -def tension_stats(A,B,AB,nsamples): - # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian - statsA= A.stats(nsamples,beta) - statsB=B.stats(nsamples,beta) - statsAB=AB.stats(nsamples,beta) - # Create a new sample - samples = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsAB.d_G - samples['logL_P']=statsAB.logL_P - # do the same for logS, logI, d_G, p, return these values in a table - return samples,statsA - -samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) -print(samples) -# %% -# Calculate the exact solution of logR -def get_logR(meanA,meanB,covA,covB,V): - #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) - return -1/2*np.asmatrix(meanA_-meanB_)*linalg.inv((covA+covB))*(np.asmatrix((meanA_-meanB_)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - -V=1 -meanA_ = np.array(meanA) -meanB_ = np.array(meanB) -logR_exact = get_logR(meanA_,meanB_,covA,covB,V) -print(logR_exact) -# %% -def get_logS(meanA,meanB,covA,covB,d): - return d/2 - 1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(np.asmatrix(meanA-meanB).transpose()) -logS_exact = get_logS(meanA_,meanB_,covA,covB,3) -print(logS_exact) -# %% -def get_logI(covA,covB,d,V): - return -d/2 -1/2* - 1/2*np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) -logI_exact = get_logI(covA,covB,3,1) -print(logI_exact) -# %% diff --git a/tension_stats_4.py b/tension_stats_4.py deleted file mode 100644 index 51218f87..00000000 --- a/tension_stats_4.py +++ /dev/null @@ -1,114 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -from scipy import linalg -import matplotlib.pyplot as plt -#%% -# Creating mock datasets A, B and AB -# Creating mock dataset A -nlive = 1000 -meanA = [0.1, 0.3, 0.5] -covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]) -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -# Creating mock dataset B - -meanB = [0.7, 0.2, 0.1] -meanB = [0.1, 0.3, 0.5] -covB = np.array([[.01, -0.009, 0], [-0.009, .01, 0], [0, 0, 0.1]]) -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, meanB, covB, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -# Calculate covariance of AB using equation 19 from paper -covA_inv = linalg.inv(covA) -covB_inv = linalg.inv(covB) -covAB_inv = covA_inv+covB_inv -covAB = linalg.inv(covAB_inv) - -# Calculate mean of AB using equation 20 from paper -#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) -meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) -#meanAB = np.asarray(meanAB.transpose()) - -# Creating mock dataset AB - -# Matching the input for the func correlated_gaussian -#meanAB_=meanAB.flatten().tolist() -#covAB_=covAB.tolist() - -samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) -samplesAB.plot_2d(axes) -#%% -# Set parameters -nsamples = 1000 -beta = 1 - -def tension_stats(A,B,AB,nsamples): - # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian - statsA = A.stats(nsamples,beta) - statsB = B.stats(nsamples,beta) - statsAB = AB.stats(nsamples,beta) - # Create a new sample - samples = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G - samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P - # do the same for logS, logI, d_G, p, return these values in a table - return samples,statsA - -samples,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples) -print(samples) -# %% -########### Using exact solution ############ -# Calculate the exact solution of logR -meandiff = np.array(meanA)-np.array(meanB) - -def get_logR(meanA,meanB,covA,covB,V): - #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) - #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - -V=1 -#meanA_ = np.array(meanA) -#meanB_ = np.array(meanB) -logR_exact = get_logR(meanA,meanB,covA,covB,V) -print(logR_exact) -samples.logR.plot.hist() -plt.axvline(logR_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logS(meanA,meanB,covA,covB,d): - return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) -d=2 -logS_exact = get_logS(meanA,meanB,covA,covB,2) -print(logS_exact) -samples.logS.plot.hist() -plt.axvline(logS_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logI(covA,covB,d,V): - return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) -logI_exact = get_logI(covA,covB,d,V) -print(logI_exact) -samples.logI.plot.hist() -plt.axvline(logI_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% diff --git a/tension_stats_4.py.zip b/tension_stats_4.py.zip deleted file mode 100644 index 88df2608706b21718b03ed9542fa3aebb9cd3f44..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1721 zcmbu9X*AS(7{~u(W{lm`2t&#mQyNRC8LOt}*=OZ0);sA`Luj=)T-%t1*79k3NAZs81;QIi; z4JY#DDFgWCf`^i}1&`33%eoqp)Yd~rm2vIS6l038d2M!Ap-OX3;o#<%p?BTXSB*0( zN^8ESi$^M$^bN_~En$QOAq1Yi-#Jpws(~Ydwz|jZbE7A18y;A1*Cd=0! z+!kW0&qJEN{ac&DCc`KBw>7OAHD$806u$H^ta56=6RzM99{XU2>b7k67dnnRD)+89 z;#w!=*&Gw381wA}(e^UFh7`&jfyu?JAXFfkOVvWHRK$0Q}1=&U(7x2wh-)!+r|l4lWu7-Qz2{1#U}P2${-t#A(U9_~_=T#853pPKatd^l!wAdV4 zquFSn|lR;x^g%Yt0Q z@1WFY|A^V>=J7t5HM5vcm+iq^=6eRrd7d8HQGa3a)5g#&8#K@<|yo6dnCw zljL*#miZ>S0dzJq(-9R3f2D!!7hyN?v0V!nC@^U_BzG$Dy-7ZBM_tBvq zZ~DWIb_W}M-nmT9`jzxO6l!Om6Np+rajT&qJ-(mODs&O=`Bhs#SY>~n?D4yw5*clP zx#A|K&S|{abxQvyxHmDQRg7Ibd-CL+O^wPeJTT0Q@X;O&m`g&i??4WW0fz(mgc*a z7EOB&rwSU|Kz1@n`=U)oyA;^%8?kKHzITt zzJ}nMz*8kypSZ#2?={n{DZwewf7=IY5Rd6zs*^N5DRaD1#OUvZB zj*+~V2boM5#^A-xFz9vRV@Dnsii*>y&i=BSS92U%uB3f}>b`A!kQXnny9vcw!-NKM zTNP>`0I)?p>`!?(#wVKspNAeEw#Q6QIk;${J^llY2?qZ{<5}X4vpz%;amm)kX-U#4 z1$#jtQx>camj^BHRTNxa)P_TMnwlh*+GJiq9pxodUD~EJR8m;N$#ubIGT6BVd4*sp zPp_KP&pW-AUQEuFr@Y^TZ!Q`__-Gy8$_*1@Qewsl{G?lHvDP2~De&K9|8d7HvVRvV sVe9oD%lw4%|MdUy@2yLH7b^h{1^(aNu+~t)Ejs~z_4DU*z99ho30mgWqyPW_ diff --git a/tension_stats_5.py b/tension_stats_5.py deleted file mode 100644 index 6ffc9c70..00000000 --- a/tension_stats_5.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -from scipy import linalg -import matplotlib.pyplot as plt -#%% -# Creating mock datasets A, B and AB -# Creating mock dataset A -nlive = 1000 -meanA = [0.1, 0.3, 0.5] -covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -# Creating mock dataset B - -meanB = [0.7, 0.2, 0.1] -meanB = [0.1, 0.3, 0.5] -covB = np.array([[.01, -0.009, 0], [-0.009, .01, 0], [0, 0, 0.1]])*0.01 -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, meanB, covB, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -# Calculate covariance of AB using equation 19 from paper -covA_inv = linalg.inv(covA) -covB_inv = linalg.inv(covB) -covAB_inv = covA_inv+covB_inv -covAB = linalg.inv(covAB_inv) - -# Calculate mean of AB using equation 20 from paper -#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) -meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) -#meanAB = np.asarray(meanAB.transpose()) - -# Creating mock dataset AB - -# Matching the input for the func correlated_gaussian -#meanAB_=meanAB.flatten().tolist() -#covAB_=covAB.tolist() - -samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) -samplesAB.plot_2d(axes) -#%% -# Set parameters -nsamples = 1000 -beta = 1 - -def tension_stats(A,B,AB,nsamples): - # Compute Nested Sampling statistics - statsA = A.stats(nsamples,beta) - statsB = B.stats(nsamples,beta) - statsAB = AB.stats(nsamples,beta) - - samples = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G - samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P - return samples - -samples = tension_stats(samplesA,samplesB,samplesAB,nsamples) -print(samples) -# %% -########### Using exact solution ############ -# Calculate the exact solution of logR -meandiff = np.array(meanA)-np.array(meanB) - -def get_logR(meanA,meanB,covA,covB,V): - #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) - #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) - - -V=1 -#meanA_ = np.array(meanA) -#meanB_ = np.array(meanB) -logR_exact = get_logR(meanA,meanB,covA,covB,V) -print(logR_exact) -samples.logR.plot.hist() -plt.axvline(logR_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logS(meanA,meanB,covA,covB,d): - return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) -d=3 -logS_exact = get_logS(meanA,meanB,covA,covB,d) -print(logS_exact) -samples.logS.plot.hist() -plt.axvline(logS_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logI(covA,covB,d,V): - return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) -logI_exact = get_logI(covA,covB,d,V) -print(logI_exact) -samples.logI.plot.hist() -plt.axvline(logI_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% diff --git a/tension_stats_5.py.zip b/tension_stats_5.py.zip deleted file mode 100644 index c70e680ecf34feb0c596ceef59b3ea18b73f85b0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1358 zcmWIWW@Zs#-~hsdCSKtTQ1FbGfkB8tfuSTduQ)S5FTS`Wv7|WORIi{iG=!Id-TJXg zstpi>=+X*q21b@|j0_Awa~K%bhDG-;HWR6P9vSc+nQ+2${wumY%|6_Bv&8#QQbJuc9aYoIT z=F`q>ZjoC!pYuU(JF237U8HTbHsL=3&%Db zRJA{7VD#KNDD0*Aq(D#B$xS*;LWiG7MjqMTbmGuM*SZ81rOhu(UQOxw#42(Aa)H={ z%pZ*V?bglRV)ejiz4I-TFGs8E_?BxWSp8+`FKv)~6}x^lYemwDoW0+UKbUJdd)3pK z2R^-+^HSk6L-E@g!bifw`wj&!X1ZmO;!v=x;l(VwLeHzGc1=|gf5LB}Gfgm*xBSkQ zJB7J#3$8z#_kIUMyvDby_8;nm=iUhHI3hJszQDYA@6w0AEQ3CZE>Uw{p;n&o^d5KE zAG3&!Oxo`bH2wX@*P}W`VY*C;uEH(Nmrmu-JJ?DshLu`6e_TjcF&%fn62 zfALegoX=f%a>w)bOAp) zY_fO$v_D*amxX%vDNEHlZ_qnc=eMt9XIAqDgBw-pk@K}K7~C|wbM55`uHSY`yPqZ| zOx1re<7V-Rm9yt~uQ!fu(s^tD#9vp(eU=xK_@2;DMjQqHBAoh9B6VI&wo=%m6S?m$ zUw!zN79YQy3Gzq(%1-7~d!?{eqftn1se%8re{6jx-~6pvM#M2D|CEwA{hs;Q{s3=w4)w2!w<=f|7(k_0fHxzP2s5H& iLzV-TY%s8-5yT?BoD1+~WdrGC1i}O$eFJDO0|NkJv|y+J diff --git a/tension_stats_6.py b/tests/test_tension_stats.py similarity index 100% rename from tension_stats_6.py rename to tests/test_tension_stats.py From de17f049f5f2ad266b023e5f0e0e362115e91569 Mon Sep 17 00:00:00 2001 From: dilyong Date: Fri, 13 Oct 2023 18:08:33 +0100 Subject: [PATCH 08/49] Updated logLmax --- anesthetic/examples/perfect_ns.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/examples/perfect_ns.py b/anesthetic/examples/perfect_ns.py index 12873f67..4f145ddf 100644 --- a/anesthetic/examples/perfect_ns.py +++ b/anesthetic/examples/perfect_ns.py @@ -57,7 +57,7 @@ def random_sphere(n): return samples.loc[samples.logL_birth < logLend].recompute() -def correlated_gaussian(nlive, mean, cov, logLmax=0, bounds=None): +def correlated_gaussian(nlive, mean, cov, bounds=None, logLmax=0): """Perfect nested sampling run for a correlated gaussian likelihood. This produces a perfect nested sampling run with a uniform prior over the From 6ab8e4ff27f5282165067d07fd13853c9feb0b9a Mon Sep 17 00:00:00 2001 From: AdamOrmondroyd Date: Sat, 14 Oct 2023 11:26:41 +0100 Subject: [PATCH 09/49] remove DS_Store --- .DS_Store | Bin 6148 -> 0 bytes tests/.DS_Store | Bin 8196 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .DS_Store delete mode 100644 tests/.DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index b1b393dd9a8b439674677fc4f19f4639d5cf951a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHK%}T>S5T0$TCKjOwh2kmTwPI>ZQM`m&U%-eSRBB?224l7~sXc^3&i=fQ_#i%y zGrOx;+j=ZwcVPD0pP7X3+pwDf0M;CIssJSbFwhBeCN@)y*2yOOgtljTj)Xp z0bEZ+>xsXp0PWo>co5;f#kg}{`{xhio*!}_*WdhJ7{rNfzq4Gvu(Z5l7)H^!bZ`04 zO}u0fH@*HjjZQcZ{m;JVp9bAwyR?4Dqr?lMZeJt>oi2u4oCQ&b51V`tbz+h0$_2wT z&30)sO}DFd)vj1|dv8>+(*0fP*BYadX>4rm92~dr!uyCnOGz1ieZtlhe!>fOrm}l* z`%%cF8(gQ{C1fu7$KQCr&YgETO{;ZeT5HsQVf`rS&1C&F&gchMnXFr_fL36!6;P+9 zQCw^pG<&UpR$z((bUs+AP?&f-KHn1Iz#NIX)e2|@#udoRVTtblquKTUc#)~#TZLhaT#40&Rf($bQES1aRyEQ N2nZQ;qZOE|0w2uRizfg8 diff --git a/tests/.DS_Store b/tests/.DS_Store deleted file mode 100644 index 6bf44c15db677ba3c20a14fd99049dffacff0aaa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHMU2GIp6u#fIzzm(S)0Rs4DP3sPMq6ns0>yyKw)`}Jt?c#>&}DXKq!XtzWoNcU zo5uPVjf&yTAN0Y*7&Vb-6u~#+iyB^tRwF!M`YEGukdHE+=j2NFMy}ts#aEq z6&%%NJm7nUpffZav}t{zr5Al`zeS7NV^$Y!;pu$fR_1-PpI(O~uoz|X|_0s<5vTB%8DleS3rOS{Dfmr5x#RPr#AcN5NgL{JJvM}%}@o)p@- zYv=Cnn>mFpRPv-*R(tF6y0tu$HgDa2opOSqB~t#C>>~GRiq6 zw5@2-)abTji>m77lzU=k+Zr0OXpripMR+F3|CZC|*fhJyF0)_R6)-HqQmnu_G~sSy za1tr(z)tKU7Vk#}eIb(#;;{(}E=GyVKCyWcPvA*Bg{Scnj^ky#LX19%H}EFj!Mk`5 z@8e^f#u=Q&XZQl=a2^+C@pjKl-s0kocsrIZxQ^!@A)ONMXPPg7QJL_uj@SP?=KuYF z0YoBpF^<5(jR4BK(p@R?f4-BD*V+lX4%5XO*P9X;not*(`lc4S&ey5G!|D^!_fACLUI$RV0 From aa0c1771dfc9b566d87d712b751fecb722863660 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 26 Oct 2023 04:44:17 +0100 Subject: [PATCH 10/49] Added a file tension.py to anesthetic/anesthetic and it contains a function tension_stats() for calculating tension statistics. Rewrote the test_tension_stats.py in tests to match the format of other files. It tests mock datasets with guassian likelihood. Both compatiable and incompatiable datasets have passed the test. --- .gitignore | 2 + anesthetic/__init__.py | 2 +- anesthetic/tension.py | 17 ++++ tests/test.ipynb | 0 tests/test_tension.py | 51 ---------- tests/test_tension_stats.py | 23 +++-- tests/test_tension_stats_2.py | 184 ++++++++++++++++++++++++++++++++++ 7 files changed, 220 insertions(+), 59 deletions(-) create mode 100644 anesthetic/tension.py create mode 100644 tests/test.ipynb delete mode 100644 tests/test_tension.py create mode 100644 tests/test_tension_stats_2.py diff --git a/.gitignore b/.gitignore index 52d12e31..34c623d3 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,5 @@ plikHM_TTTEEE_lowl_lowE_lensing_NS/ *~ .pytest_cache/* .coverage + +.DS_Store \ No newline at end of file diff --git a/anesthetic/__init__.py b/anesthetic/__init__.py index 2c5b855b..a707354e 100644 --- a/anesthetic/__init__.py +++ b/anesthetic/__init__.py @@ -9,7 +9,7 @@ import pandas.plotting._misc from anesthetic._format import _DataFrameFormatter from anesthetic._version import __version__ # noqa: F401 - +print('test tension branch') # TODO: remove this when conda pandas version catches up from packaging.version import parse assert parse(pandas.__version__) >= parse('2.0.0') diff --git a/anesthetic/tension.py b/anesthetic/tension.py new file mode 100644 index 00000000..1e9f7153 --- /dev/null +++ b/anesthetic/tension.py @@ -0,0 +1,17 @@ +from anesthetic.samples import Samples + + +def tension_stats(A,B,AB,nsamples,beta): + # Compute Nested Sampling statistics + statsA = A.stats(nsamples,beta) + statsB = B.stats(nsamples,beta) + statsAB = AB.stats(nsamples,beta) + + samples = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR']=logR + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI']=logI + samples['logS']=logR-logI + samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G + return samples \ No newline at end of file diff --git a/tests/test.ipynb b/tests/test.ipynb new file mode 100644 index 00000000..e69de29b diff --git a/tests/test_tension.py b/tests/test_tension.py deleted file mode 100644 index 7dba3d39..00000000 --- a/tests/test_tension.py +++ /dev/null @@ -1,51 +0,0 @@ -#%% -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -#%% -nlive = 100 -meanA = [0.1, 0.3, 0.5] -covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] -bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, mean, cov, bounds) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -nlive = 100 -meanB = [0.7, 0.2, 0.1] -covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]] -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, mean, cov, bounds) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -#%% -statsA = samplesA.stats(nsamples=1000) -statsB = samplesB.stats(nsamples=1000) -params = ['logZ', 'D_KL', 'logL_P', 'd_G'] -fig, axes = make_2d_axes(params, figsize=(6, 6), facecolor='w', upper=False) -statsA.plot_2d(axes, label="Dataset A") -statsB.plot_2d(axes, label="Dataset B") -axes.iloc[-1, 0].legend(bbox_to_anchor=(len(axes), len(axes)), loc='upper right') - -# %% -def testGaussian(theta,mu,logLmax,v,cov): - """ - Inputs: - theta: parameters - mu: centre of Gaussian likelihood - logLmax: log of Gaussian peak - V: prior volume, for hypercube V=1 - cov: covariance of gaussian in parameters - """ - gaussLogL = logLmax - 1/2*(theta-mu)*np.linalg.inv(cov)*(theta-mu) - gaussLogP = -1/2*np.log(abs(2*np.pi*cov))-1/2*(theta-mu)*np.linalg.inv(cov)*(theta-mu) - gaussLogZ = logLmax+1/2*np.log(abs(2*np.pi*cov))-np.log(v) - D=np.log(v)-1/2*(len(theta)+np.log(abs(2*np.pi*cov))) - return gaussLogL,gaussLogP,gaussLogZ,D - -testGaussian(theta=np.array([0.111955,0.312646 ,0.542911]),mu=meanA,logLmax=samplesA['logL'].max(),v=1,cov=np.array(covA)) - -# %% diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py index 9c3cfda9..cee15f95 100644 --- a/tests/test_tension_stats.py +++ b/tests/test_tension_stats.py @@ -1,3 +1,4 @@ + #%% from anesthetic.samples import Samples from anesthetic.examples.perfect_ns import correlated_gaussian @@ -5,7 +6,7 @@ import numpy as np import matplotlib.pyplot as plt from scipy import linalg -import matplotlib.pyplot as plt + #%% # Creating mock datasets A, B and AB # Creating mock dataset A @@ -13,7 +14,8 @@ meanA = [0.1, 0.3, 0.5] covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 bounds = [[0, 1], [0,1], [0, 1]] -samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run +logLmaxA = 0 +samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) # output is Nested sampling run #samplesA.gui() #plt.show() @@ -22,11 +24,11 @@ # Datasets being incompatible meanB = [0.15, 0.25, 0.45] # Datasets being compatible -#meanB = [0.1, 0.3, 0.5] +meanB = [0.1, 0.3, 0.5] covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 -#bounds = [[0, 1], [0,1], [0, 1]] -samplesB = correlated_gaussian(nlive, meanB, covB, bounds) +logLmaxB = 0 +samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) # Make a plot axes = samplesA.plot_2d([0,1,2]) samplesB.plot_2d(axes) @@ -43,12 +45,18 @@ #meanAB = np.asarray(meanAB.transpose()) # Creating mock dataset AB - # Matching the input for the func correlated_gaussian #meanAB_=meanAB.flatten().tolist() #covAB_=covAB.tolist() -samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds) +# Calculate logLmaxAB using eqn 18 from paper +def find_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0): + meandiff = np.array(meanA)-np.array(meanB) + return -1/2 * meandiff@linalg.solve(covA+covB,meandiff)+logLmaxA+logLmaxB + +logLmaxAB = find_logLmaxAB(meanA,meanB,covA,covB,logLmaxA, logLmaxB) + +samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds, logLmaxAB) samplesAB.plot_2d(axes) #%% # Set parameters @@ -102,6 +110,7 @@ def get_logR(meanA,meanB,covA,covB,V): plt.show() # %% def get_logS(meanA,meanB,covA,covB,d): + meandiff = np.array(meanA)-np.array(meanB) return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) d=3 logS_exact = get_logS(meanA,meanB,covA,covB,d) diff --git a/tests/test_tension_stats_2.py b/tests/test_tension_stats_2.py new file mode 100644 index 00000000..d55a1cc1 --- /dev/null +++ b/tests/test_tension_stats_2.py @@ -0,0 +1,184 @@ +#%% +from anesthetic.samples import Samples +from anesthetic.examples.perfect_ns import correlated_gaussian +from anesthetic import read_chains, make_2d_axes +import numpy as np +import matplotlib.pyplot as plt +from scipy import linalg +from anesthetic.tension import tension_stats + + +def get_meanAB(meanA, meanB,covA,covB,covAB): + meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) + return meanAB + +def get_covAB(covA,covB): + covAB_inv = linalg.inv(covA) + linalg.inv(covB) + covAB = linalg.inv(covAB_inv) + return covAB + +def get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0): + meandiff = np.array(meanA)-np.array(meanB) + logLmaxAB = -1/2 * meandiff@linalg.solve(covA+covB,meandiff)+logLmaxA+logLmaxB + return logLmaxAB + +def get_logR(meanA,meanB,covA,covB,V): + meandiff = np.array(meanA)-np.array(meanB) + logR = -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) + return logR + +def get_logS(meanA,meanB,covA,covB,d): + meandiff = np.array(meanA)-np.array(meanB) + logS = d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) + return logS + +def get_logI(covA,covB,d,V): + logI = -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) + return logI + +def test_tension_stats_compatiable_gaussian(samples_plot=True,stats_table=True, stats_plot=True, hist_plot=True): + nlive = 1000 + bounds = [[0, 1], [0,1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.1, 0.3, 0.5] + covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) + + covAB = get_covAB(covA,covB) + meanAB = get_meanAB(meanA, meanB,covA,covB,covAB) + logLmaxAB = get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0) + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA,samplesB,samplesAB,nsamples,beta) + + logR_min = samples.logR.min() + logR_max = samples.logR.max() + + logS_min = samples.logS.min() + logS_max = samples.logS.max() + + logI_min = samples.logI.min() + logI_max = samples.logI.max() + + logR_exact = get_logR(meanA,meanB,covA,covB,V=1) + logS_exact = get_logS(meanA,meanB,covA,covB,d=len(bounds)) + logI_exact = get_logI(covA,covB,d=len(bounds),V=1) + + if samples_plot: + axes = samplesA.plot_2d([0,1,2]) + samplesB.plot_2d(axes) + samplesAB.plot_2d(axes) + + if stats_table: + print(samples) + + if stats_plot: + axes = samples.plot_2d(['logR','logI','logS','d_G']) + + if hist_plot: + plt.figure() + samples.logR.plot.hist() + plt.axvline(logR_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logS.plot.hist() + plt.axvline(logS_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logI.plot.hist() + plt.axvline(logI_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + assert logR_min < logR_exact < logR_max + assert logS_min < logS_exact < logS_max + assert logI_min < logI_exact < logI_max + + + +def test_tension_stats_incompatiable_gaussian(samples_plot=True,stats_table=True, stats_plot=True, hist_plot=True): + nlive = 1000 + bounds = [[0, 1], [0,1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.15, 0.25, 0.45] + covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) + + covAB = get_covAB(covA,covB) + meanAB = get_meanAB(meanA, meanB,covA,covB,covAB) + logLmaxAB = get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0) + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA,samplesB,samplesAB,nsamples,beta) + + logR_min = samples.logR.min() + logR_max = samples.logR.max() + + logS_min = samples.logS.min() + logS_max = samples.logS.max() + + logI_min = samples.logI.min() + logI_max = samples.logI.max() + + logR_exact = get_logR(meanA,meanB,covA,covB,V=1) + logS_exact = get_logS(meanA,meanB,covA,covB,d=len(bounds)) + logI_exact = get_logI(covA,covB,d=len(bounds),V=1) + + if samples_plot: + axes = samplesA.plot_2d([0,1,2]) + samplesB.plot_2d(axes) + samplesAB.plot_2d(axes) + + if stats_table: + print(samples) + + if stats_plot: + axes = samples.plot_2d(['logR','logI','logS','d_G']) + + if hist_plot: + plt.figure() + samples.logR.plot.hist() + plt.axvline(logR_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logS.plot.hist() + plt.axvline(logS_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logI.plot.hist() + plt.axvline(logI_exact,color='r',label='Exact solution') + plt.legend() + plt.show() + + assert logR_min < logR_exact < logR_max + assert logS_min < logS_exact < logS_max + assert logI_min < logI_exact < logI_max + + +test_tension_stats_compatiable_gaussian() +#test_tension_stats_incompatiable_gaussian() +# %% From 2f472b51d51d5b0c762271d82da706a4c6824f90 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 26 Oct 2023 18:29:07 +0100 Subject: [PATCH 11/49] Updated the tests/test_tension_stats.py file for flake8 compliance. Add a file for datasets pairwise_comparison, but not completed --- pairwise_comparison.py | 58 +++++++ tests/test_tension_stats.py | 301 +++++++++++++++++++++--------------- 2 files changed, 236 insertions(+), 123 deletions(-) create mode 100644 pairwise_comparison.py diff --git a/pairwise_comparison.py b/pairwise_comparison.py new file mode 100644 index 00000000..841c0adf --- /dev/null +++ b/pairwise_comparison.py @@ -0,0 +1,58 @@ +from anesthetic import read_chains, make_2d_axes +from anesthetic.tension import tension_stats + + +# Change dir1, dir2 and dir3 to change datasets for comparison +dir1 = 'bao.sdss_dr16' +dir2 = 'planck_2018_plik' #'planck_2018_CamSpec'#'planck_2018_plik_nolens' #'planck_2018_CamSpec_nolens' +dir3 = "+".join(sorted([dir1,dir2])) # Put dir1 and dir2 in alphabetical order + +dir_list = ['bao.sdss_dr16','bicep_keck_2018','des_y1.joint','planck_2018_CamSpec','planck_2018_CamSpec_nolens','planck_2018_plik','planck_2018_plik_nolens','sn.pantheon','bicep_keck_2018'] + + +# Read the chains for the 3 datasets to be compared +samples1 = read_chains(f"../ns/klcdm/{dir1}/{dir1}_polychord_raw/{dir1}") +samples2 = read_chains(f"../ns/klcdm/{dir2}/{dir2}_polychord_raw/{dir2}") +samples3 = read_chains(f"../ns/klcdm/{dir3}/{dir3}_polychord_raw/{dir3}") + +#%% +# Make a fig and axes, set the parameters to plot +fig, axes = make_2d_axes(['omk', 'H0', 'omegam']) # must match the column index +# Plot datasets on the same ax +samples1.plot_2d(axes, label='BAO') +samples2.plot_2d(axes, label='Planck') +samples3.plot_2d(axes, label='BAO+Planck') +# Set location of legend +axes.iloc[-1, 0].legend(loc='lower center', bbox_to_anchor=(len(axes)/2, len(axes))) + + +#%% +nsamples = 1000 +beta = 1 +samples = tension_stats(samples1,samples2,samples3,nsamples,beta) +#%% +fig, ax = plt.subplots(2,2) + +#%% +plt.figure() +plt.title('logR') +samples.logR.plot.hist() +plt.show() + +plt.figure() +plt.title('logI') +samples.logI.plot.hist() +plt.show() + +plt.figure() +plt.title('logS') +samples.logS.plot.hist() +plt.show() + +plt.figure() +plt.title('d_G') +samples.d_G.plot.hist() +plt.show() + + +# %% diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py index cee15f95..1da99a8f 100644 --- a/tests/test_tension_stats.py +++ b/tests/test_tension_stats.py @@ -1,131 +1,186 @@ - -#%% -from anesthetic.samples import Samples from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes import numpy as np import matplotlib.pyplot as plt from scipy import linalg +from anesthetic.tension import tension_stats + + +def get_meanAB(meanA, meanB, covA, covB, covAB): + meanAB = covAB@(np.linalg.solve(covA, meanA)+np.linalg.solve(covB, meanB)) + return meanAB + + +def get_covAB(covA, covB): + covAB_inv = linalg.inv(covA) + linalg.inv(covB) + covAB = linalg.inv(covAB_inv) + return covAB + -#%% -# Creating mock datasets A, B and AB -# Creating mock dataset A -nlive = 1000 -meanA = [0.1, 0.3, 0.5] -covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 -bounds = [[0, 1], [0,1], [0, 1]] -logLmaxA = 0 -samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) # output is Nested sampling run -#samplesA.gui() -#plt.show() - -# Creating mock dataset B - -# Datasets being incompatible -meanB = [0.15, 0.25, 0.45] -# Datasets being compatible -meanB = [0.1, 0.3, 0.5] - -covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 -logLmaxB = 0 -samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) -# Make a plot -axes = samplesA.plot_2d([0,1,2]) -samplesB.plot_2d(axes) - -# Calculate covariance of AB using equation 19 from paper -covA_inv = linalg.inv(covA) -covB_inv = linalg.inv(covB) -covAB_inv = covA_inv+covB_inv -covAB = linalg.inv(covAB_inv) - -# Calculate mean of AB using equation 20 from paper -#meanAB1 = covAB@(covA_inv@meanA+covB_inv@meanB) -meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) -#meanAB = np.asarray(meanAB.transpose()) - -# Creating mock dataset AB -# Matching the input for the func correlated_gaussian -#meanAB_=meanAB.flatten().tolist() -#covAB_=covAB.tolist() - -# Calculate logLmaxAB using eqn 18 from paper -def find_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0): +def get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0): meandiff = np.array(meanA)-np.array(meanB) - return -1/2 * meandiff@linalg.solve(covA+covB,meandiff)+logLmaxA+logLmaxB - -logLmaxAB = find_logLmaxAB(meanA,meanB,covA,covB,logLmaxA, logLmaxB) - -samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds, logLmaxAB) -samplesAB.plot_2d(axes) -#%% -# Set parameters -nsamples = 1000 -beta = 1 - -def tension_stats(A,B,AB,nsamples): - # Compute Nested Sampling statistics - statsA = A.stats(nsamples,beta) - statsB = B.stats(nsamples,beta) - statsAB = AB.stats(nsamples,beta) - - samples = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G - #samples['logL_P']=statsAB.logL_P-statsA.logL_P-statsB.logL_P - return samples - -samples = tension_stats(samplesA,samplesB,samplesAB,nsamples) -print(samples) -axes = samples.plot_2d(['logR','logI','logS','d_G']) -#%% -# Another way to make corner plots -params = ['logR','logI','logS','d_G'] -fig, axes = make_2d_axes(params, figsize=(6, 6), facecolor='w', upper=False) -samples.plot_2d(axes)#, label="model 1") -# %% -########### Using exact solution ############ -# Calculate the exact solution of logR -#meandiff = np.array(meanA)-np.array(meanB) - -def get_logR(meanA,meanB,covA,covB,V): - #return -1/2*np.asmatrix(meanA-meanB)*linalg.inv((covA+covB))*(meanA-meanB)-1/2*np.log(abs(2*np.pi*(covA+covB)))+np.log(V) - #return -1/2*np.asmatrix(meanA-meanB)@linalg.inv((covA+covB))@(np.asmatrix((meanA-meanB)).transpose())-1/2*np.log(linalg.det(2*np.pi*(covA+covB)))+np.log(V) + logLmaxAB = -1/2 * meandiff@linalg.solve(covA+covB, meandiff)+logLmaxA + +logLmaxB + return logLmaxAB + + +def get_logR(meanA, meanB, covA, covB, V): meandiff = np.array(meanA)-np.array(meanB) - return -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) - - -V=1 -#meanA_ = np.array(meanA) -#meanB_ = np.array(meanB) -logR_exact = get_logR(meanA,meanB,covA,covB,V) -print(logR_exact) -samples.logR.plot.hist() -plt.axvline(logR_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logS(meanA,meanB,covA,covB,d): + logR = -1/2*meandiff@linalg.solve(covA+covB, meandiff) + -1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) + return logR + + +def get_logS(meanA, meanB, covA, covB, d): meandiff = np.array(meanA)-np.array(meanB) - return d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) -d=3 -logS_exact = get_logS(meanA,meanB,covA,covB,d) -print(logS_exact) -samples.logS.plot.hist() -plt.axvline(logS_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% -def get_logI(covA,covB,d,V): - return -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) -logI_exact = get_logI(covA,covB,d,V) -print(logI_exact) -samples.logI.plot.hist() -plt.axvline(logI_exact,color='r',label='Exact solution') -plt.legend() -plt.show() -# %% + logS = d/2 - 1/2*meandiff@linalg.solve(covA+covB, meandiff) + return logS + + +def get_logI(covA, covB, d, V): + logI = - d/2 - 1/2 * np.log(linalg.det(2*np.pi*(covA + covB))) + np.log(V) + return logI + + +def test_tension_stats_compatiable_gaussian(samples_plot=False, + stats_table=False, + stats_plot=False, hist_plot=False): + nlive = 1000 + bounds = [[0, 1], [0, 1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.1, 0.3, 0.5] + covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + + covAB = get_covAB(covA, covB) + meanAB = get_meanAB(meanA, meanB, covA, covB, covAB) + logLmaxAB = get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0) + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + + logR_min = samples.logR.min() + logR_max = samples.logR.max() + + logS_min = samples.logS.min() + logS_max = samples.logS.max() + + logI_min = samples.logI.min() + logI_max = samples.logI.max() + + logR_exact = get_logR(meanA, meanB, covA, covB, V=1) + logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) + logI_exact = get_logI(covA, covB, d=len(bounds), V=1) + + if samples_plot: + axes = samplesA.plot_2d([0, 1, 2]) + samplesB.plot_2d(axes) + samplesAB.plot_2d(axes) + + if stats_table: + print(samples) + + if stats_plot: + axes = samples.plot_2d(['logR', 'logI', 'logS', 'd_G']) + + if hist_plot: + plt.figure() + samples.logR.plot.hist() + plt.axvline(logR_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logS.plot.hist() + plt.axvline(logS_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logI.plot.hist() + plt.axvline(logI_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + assert logR_min < logR_exact < logR_max + assert logS_min < logS_exact < logS_max + assert logI_min < logI_exact < logI_max + + +def test_tension_stats_incompatiable_gaussian(samples_plot=False, + stats_table=False, stats_plot=False, hist_plot=False): + nlive = 1000 + bounds = [[0, 1], [0, 1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.15, 0.25, 0.45] + covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + + covAB = get_covAB(covA, covB) + meanAB = get_meanAB(meanA, meanB, covA, covB, covAB) + logLmaxAB = get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0) + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + + logR_min = samples.logR.min() + logR_max = samples.logR.max() + + logS_min = samples.logS.min() + logS_max = samples.logS.max() + + logI_min = samples.logI.min() + logI_max = samples.logI.max() + + logR_exact = get_logR(meanA, meanB, covA, covB, V=1) + logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) + logI_exact = get_logI(covA, covB, d=len(bounds), V=1) + + if samples_plot: + axes = samplesA.plot_2d([0, 1, 2]) + samplesB.plot_2d(axes) + samplesAB.plot_2d(axes) + + if stats_table: + print(samples) + + if stats_plot: + axes = samples.plot_2d(['logR', 'logI', 'logS', 'd_G']) + + if hist_plot: + plt.figure() + samples.logR.plot.hist() + plt.axvline(logR_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logS.plot.hist() + plt.axvline(logS_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + plt.figure() + samples.logI.plot.hist() + plt.axvline(logI_exact, color='r', label='Exact solution') + plt.legend() + plt.show() + + assert logR_min < logR_exact < logR_max + assert logS_min < logS_exact < logS_max + assert logI_min < logI_exact < logI_max From 5209ad2dbe6ec4d4b96b520a4044ec27f107e041 Mon Sep 17 00:00:00 2001 From: dilyong Date: Tue, 5 Dec 2023 00:25:28 +0000 Subject: [PATCH 12/49] Updated tests/test_tension_stats.py --- tests/test_tension_stats.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py index 1da99a8f..4607d2d5 100644 --- a/tests/test_tension_stats.py +++ b/tests/test_tension_stats.py @@ -183,4 +183,4 @@ def test_tension_stats_incompatiable_gaussian(samples_plot=False, assert logR_min < logR_exact < logR_max assert logS_min < logS_exact < logS_max - assert logI_min < logI_exact < logI_max + assert logI_min < logI_exact < logI_max \ No newline at end of file From 6fb5fe0a63bb20dcf1c8aabdf2c525bfe1676546 Mon Sep 17 00:00:00 2001 From: dilyong Date: Mon, 4 Mar 2024 18:42:22 +0000 Subject: [PATCH 13/49] Updated anesthetic/tests/test_tension_stats.py. Now it tests whether the theoretical logR, logS and logI values sit within 3 std of the numerical solution's distribution from anesthetic, instead of testing between minimum and maximum values of the distribution. --- Interactive - tension_stats.py.ipynb | 99 - Interactive - tension_stats_2.py.ipynb | 4978 ------------------------ README.rst | 2 +- anesthetic/__init__.py | 1 - anesthetic/_version.py | 2 +- anesthetic/tension_pvalue.py | 27 + pairwise_comparison.py | 58 - tests/test_tension_stats.py | 124 +- tests/test_tension_stats_2.py | 184 - 9 files changed, 59 insertions(+), 5416 deletions(-) delete mode 100644 Interactive - tension_stats.py.ipynb delete mode 100644 Interactive - tension_stats_2.py.ipynb create mode 100644 anesthetic/tension_pvalue.py delete mode 100644 pairwise_comparison.py delete mode 100644 tests/test_tension_stats_2.py diff --git a/Interactive - tension_stats.py.ipynb b/Interactive - tension_stats.py.ipynb deleted file mode 100644 index f64fed7b..00000000 --- a/Interactive - tension_stats.py.ipynb +++ /dev/null @@ -1,99 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "isInteractiveWindowMessageCell": true - }, - "source": [ - "Connected to myenv (Python 3.8.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from anesthetic.samples import Samples" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "nsamplees = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " #samples.['logR']" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "nsamplees = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " return samples\n", - " #samples.['logR']" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'samples' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samples\n", - "\u001b[0;31mNameError\u001b[0m: name 'samples' is not defined" - ] - } - ], - "source": [ - "samples" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "myenv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Interactive - tension_stats_2.py.ipynb b/Interactive - tension_stats_2.py.ipynb deleted file mode 100644 index 352aa741..00000000 --- a/Interactive - tension_stats_2.py.ipynb +++ /dev/null @@ -1,4978 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "isInteractiveWindowMessageCell": true - }, - "source": [ - "Connected to myenv (Python 3.8.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'correlated_gaussian' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 7\n\u001b[1;32m 11\u001b[0m covA \u001b[39m=\u001b[39m [[\u001b[39m.01\u001b[39m, \u001b[39m0.009\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0.009\u001b[39m, \u001b[39m.01\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m0.1\u001b[39m]]\n\u001b[1;32m 12\u001b[0m bounds \u001b[39m=\u001b[39m [[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]\n\u001b[0;32m----> 13\u001b[0m samplesA \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanA, cov, bounds) \u001b[39m# output is Nested sampling run\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[39m#samplesA.gui()\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[39m#plt.show()\u001b[39;00m\n\u001b[1;32m 17\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n", - "\u001b[0;31mNameError\u001b[0m: name 'correlated_gaussian' is not defined" - ] - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, cov, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, cov, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "\n", - "nsamples = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples\n", - "samples = tension_stats(samplesA,samplesB)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from anesthetic.samples import Samples\n", - "from anesthetic.examples.perfect_ns import correlated_gaussian\n", - "from anesthetic import read_chains, make_2d_axes\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'cov' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 7\n\u001b[1;32m 11\u001b[0m covA \u001b[39m=\u001b[39m [[\u001b[39m.01\u001b[39m, \u001b[39m0.009\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0.009\u001b[39m, \u001b[39m.01\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m0.1\u001b[39m]]\n\u001b[1;32m 12\u001b[0m bounds \u001b[39m=\u001b[39m [[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]\n\u001b[0;32m----> 13\u001b[0m samplesA \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanA, cov, bounds) \u001b[39m# output is Nested sampling run\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[39m#samplesA.gui()\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[39m#plt.show()\u001b[39;00m\n\u001b[1;32m 17\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n", - "\u001b[0;31mNameError\u001b[0m: name 'cov' is not defined" - ] - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, cov, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, cov, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "\n", - "nsamples = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples\n", - "samples = tension_stats(samplesA,samplesB)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from anesthetic.samples import Samples\n", - "from anesthetic.examples.perfect_ns import correlated_gaussian\n", - "from anesthetic import read_chains, make_2d_axes\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "tension_stats() missing 2 required positional arguments: 'AB' and 'nsamples'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 37\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n\u001b[0;32m---> 39\u001b[0m samples \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB)\n", - "\u001b[0;31mTypeError\u001b[0m: tension_stats() missing 2 required positional arguments: 'AB' and 'nsamples'" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG5CAYAAAByehWbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADqMElEQVR4nOydeXhTVf6H3yRN9xVaoEAp+y77JioquKMobowOLiOOjjqjw6ijzOi4i9tPZlTGcRTHhRHcV3RQQEBUFtn3ndJCWUr3Lc32++PkJjfpTZq0N03anvd5eBKam3NOkpucz/2uBqfT6UQikUgkEomklWCM9AIkEolEIpFI9ESKG4lEIpFIJK0KKW4kEolEIpG0KqS4kUgkEolE0qqQ4kYikUgkEkmrQoobiUQikUgkrQopbiQSiUQikbQqpLiRSCQSiUTSqoiJ9AIigc1mY+PGjXTs2BGjUeo7SeSx2Wxs27aN008/HbPZHOnlSCTY7Xb27dtH7969MZlMkV6ORAKA0+mkoqKCzp07B9y/26S42bhxI2PGjIn0MiQSiUQikTSC/Px8unbt6vfxNiluOnbsCMDatWvJzs6O8GokEtizZw+TJk0iPz+f1NTUSC9HIqGgoIBBgwbJc1ISVZSXl5OTk0NKSkrA49qkuFFMWdnZ2QGVn0TSXFRUVACQmpoqNxJJVKCch/KclEQjBoMh4OMy4EQikUgkEkmrQoobiUQikUgkrQopbiQSiUQikbQqpLiRSCStm3XzYM5gcSsJL/K9lkQJUtxIJJKWT6BNddUcKMsXt5LwEsx7LQWQpBmQ4kYikbR8Am2qZ86EtBxxKwkvwbzXUmxKmoE2mQoukUhaGWfOFJul1qY6eob4Jwk/wbzXgT4riUQnpLgJgS82H+WpRTvonJ7Any/sz+m92kd6SW0PpxMK1sGR9VBRCNWnoOwIFB+AyhNgioXOQ+H030PfCyO9WklzoWyqisvjzJlS0EQr0SI2183ziKxoWI9EV6S4CZJvtx/j7gUbAThebuGWt9bx5R/OpHeH5AivrA1xbCt8fhcUbvZ/jK0GDq4U/864B857DBoo9iRpRahdHnLDkgRCniutGhlzEwS1VjuPfbkDgAsGdmRM93bUWO386YNNOJ3OCK+ujVDwC/znEiFszEnQbzKMuxMmPgSXz4Wbv4a7N8EdP8PYO8RzfvwH/Pj3SK5a0tz4xnzI4FWJP9TnijxPWh1S3ATBh+sLOFJaQ+e0eP7+q2G88uvhJMWa2FJQxuLtxyK9vNZPbRl8eDNYyqHbePjjFrjuPbhoNky4H4ZPh+5nQLse0HEgXPwMXPy8eO6Sx+Dw6oguX+KHUDcU3+O1nj96Bszc5nFRfX2/d/Cq3MSih0Cfxbp58Ex3eLa79+PKcz6a0fTPUX2uyCDnVocUNw3gdDp59+dDANx6Vk8SY2PokBLPLWf2AODvS/ZK6024Wfq4+OFJz4VffwBJmQ0/Z8xvYeh1gBO+mgl2a9iXKQmRUNOGlz4hjl/0J7HpKf/39/xVc8BpB4PJY8lRzymFTmQJ9PmvmgO1JVBTIj5n3+ds/zQ0MdKQKAqU5SXPk4aJwvdIipsGWHuwmD3HK0mMNXHVSE+TzVvP7ElSrIldxypYvvtkBFfYyik9DOvfFvcvfwXiAneCdWMwwIVPQ2J7OLEjqr50Ehehpg2rQ6dqSsT/Az1fGf+S5z0xFeo55dV6ZAn0+Z85E/cHbtB4zqCpoaX3NySK1FYcf8+V54l/ovA9kgHFDfDh+gIALhvSmbQEs/vvaYlmrh/bjdd/OMirK/Zzbv8OkVpi62bV38FhhR4TxL9QSGwH5/5VXOmvfF64r+JkAHjU0Ji04WVPgNUC5jjoNQny14Q2vu/fZEpy5Aj0+St/9/18GpNptW4e1FVCfAb0dp0zoXzmMnW9YaLwPZKWmwBUWWx8vbUQgGtGda33+C1n9sBsMrD2YDFrDxY39/JaP5ZK2PK+uH/WfY0bY8SN0K4nVBfB2n/rtzZJePloBjzWDvJ+ElfUIH48e02CpPYw8WGxSTXlajHQ1bok8jTm89Fyj6yaIyx9cclw9bzQx2zKeRKKu6a5XTt6zheF3yUpbgLw9dZCquvsdG+fyMjcjHqPZ6clcPXIHABeWrq3uZfX+tn+qbjiatcrdKuNgskMZz8g7v88F+qq9VufJHxs/1TEy2z/VPxfy60gKw9LfNFyj0TyPAnFXdPcrp0odCXpiRQ3AVi4Lh+Aa0blYPBTK+XOc3phNhlYta+IZbuON+fyWj+b/ituR9zQtFo1g6+C9G7CeqOMKdEXratAf1eGwRw7aKoIBB40VfxfHWsRnyFEb95P4X1NkvAQzHkRyrmjJlQhE25rSSjraW4R1sovDgzONpjqU1BQQE5ODvn5+XTtWt/dBLD3eAXnz1mJyWjg5wcn0iE13u94s7/eyWsrD5DTLoFFd59FarzZ77GSIKk4Bv/XT9yfuQPSujRtvDX/hm/uF1ag3/8CxujS9Tt37mTgwIGUlZWRmpoa6eWEzpzB4iowLcfjRtL6G4gU39oSIVIePORJ2Xba6x8baC6DSTwnIQNikyFnrCeeIorM4y0V5XdS93PS33mh/jsEPsZg8gSKN1Rp2N98DT3WEOGocCyrJjdIeXk5aWlpDZ6X0fUL74dI6K95qw4CMKl/h4DCBuD3E3vTJT2B/OIa7lmwkVqrvTmW2LrZtUjcdhnVdGEDMOx6iE+D4v2wd3HTx5N4o1U8Twni9L0yNPjcKinbGMRzGrpazxkrNrfsIWJOJ41LD5aEHy3LiHKu5Iz1fkx9DvmzKihZVE67CC6Hht0rgYr1NcV6EQ63Tit3FTUnUS9uHnroIW688UaeffZZNm3a1Cxzniiv5ZMNRwC4bULPBo9PiTfzz1+PIDbGyPe7T3LF3B/58Jd8dh0rx2KTQqdR7PxS3A64TJ/x4pJhxE3i/trX9RlT4kGreF5NiSi86EuvSUKcZHQXG01SJkLpOMVzvr7f45p4tjssutf7B3/fUrG5FR8Sc056uHHpwZLwo7VZK+fK/qXisW8fEucBeM4h3wBVRZSoXZHKNa8/seQ73+gZQhCV5XuEke95G4qLSpk3KVMEv//7nKa7uFq5q6g5iWpxc80117BixQpGjRrFsmXL+Oijj4DQLTkWi4Xy8nL3v4qKioDHz1mylzq7g5G5GYzq3i6oOYbmpPP2b8aQlmBm17EK7v9oCxf9/QdGPP4dD3+2TYqcUKirgkOrxP3+k/Ubd9RvxO3+ZVBySL9xdaS8vByLxRLpZYSGbzVZtyUG7ytsRaxs+1j8vXCL2GiObsKzU7mes/QJT5YLTu9CfL6WH2WDakwmjEQTi8Xi/p1s0jkZaLNWPnJrjba1Ql14T6k0ve1j1xMNQtSC5/MPlD2njGV1vY6a0voipCGria/4UeYt3CLO2aMbQ7e6+BtTfQ4HI7qisIhepIlacfPzzz+ze/dulixZwj333MOf//xnPv30U4qLQ0+5nj17Nmlpae5/AwcO9HvstiNlvL/uMAAPXNQ/pHlO79We7+87h3sm9WFkbgap8TFU1dl5d3UeM976BYejzYU3NY5DP4raNundoH1v/cZt1xN6ngs4YcM7+o2rIzk5OcyePTvSy9DG3w+ouprsqjniClpdec1SKZ73zQMesYIBYuIgJlF7LrtFbIgJGcK1pS7EN9FlqZn4cBhepATEb6byOxnUOemvNQZ4x2Cpz53eLgte52H1BZC6dYaSOac+pxLS64vYQEJKES62GtxWQl8R0lCvKX/iRwl+7zw8dKtLMG4oxdqkWLi0BIx0Z9UjasVNXFwcycnJ7N0rUqz79euH3W7nzjvv5L777uObb74JeqxZs2ZRVlbm/rdjxw7N42qtdma+vwmHEy4b2pkxPYKz2qhplxTLzPP78vEd49n8yAW8efMoEmNNrNpXxOebj4Q8Xptk/zJx22ui/h29R9wobrd8AA6HvmPrQH5+PrNmzYr0MrTxNekrnDlTCJAEV3zN/qV4WWIcVvE8h6oFRkI6WKuFiFHEjhpTnLiNTRZX6OqNbPQMT9EweaUaFmbNmuX+nQzqnPTdXJX/L3tCWPV8XYsgLC2KBS9nrPfnqW6dobgbE9JxW/G0hG2gWitnzhTPwwnx6doipKFeU/7E09Xz4JFiuG156JbDYNo+KNYmtYVLqQP10YyGx2mjRK246dOnD0ajkTlz5nDnnXdy2mmncfnllzN9+nRsNhvvv/8+FRUVQbmo4uLiSE1Ndf9LSUnRPO6pRTvZe6KSzOQ4Hr3Mv3UnWAwGAxP7d+T3E4X14YXFe7DZo29DjTrU4kZv+l0MsSniRyI/+hpqpqamEhcXF+ll1GfdPGHKBy/dAogf8wcPwQOHxH3fxw3qnxkDDL5axN0ogaEms9hw4jM8xxgI3DtKXqmGlbi4OPfvpN9zUm3d8N1clf87EVY9X9eicoyS8eYbDK5unaG4G5VYrUFTtWNk/P3/I5dYUURS70kNvwFaYqEhUd0Y11AwbR/McWItg6/yrMm3DlQwRfTamOsqKsWNw+EgJSWFr7/+mptuuolOnToxZcoUnn32WS699FKuuOIKtm7dis1m81t/JlS+3lrIu6vzAHjhmiG0T9Zvg7nljB6kJ5o5UlrD2kOyknFAKk9A0W5xv/tZ+o9vToCBl4v7Wz7Qf/zWyqo5uC0sBrQ3FOW+7+ahvgAxGCF3vAgKVlSQ3So2QAOeK/SGekfJK9XIoxaYvhu/stlOethj1VO7FkHcv+R57WBwrUBfJZB8+6ee2C4ta5GyBrVbqyxfWIoais1Rr01LLDTU7FNPwa24ZZ2u++qYMt86UMGgrE8J2G/lRJ24cTqdGI1GbDYbqampTJgwgeTkZPLz893H7Nu3j9jYWN3mPFpaw4MfbwHgjnN6cU4/fftExZtNnD+gIwD/23ZM17FbHYd/FrcdBoneUOFgsOsHYffXUemaihp8r8wVy4rSqXnOYG/rinJ/31Lxo6xgjBHWGRCbk28TzM7DvX/EFauO1eK/3kdTslwk+qCk5Cdlivf/24fquy19rXpq1DVdfIPB1Z+psikb8Fh61BWqlSypnLHeTVF93Vq+ViV1dpVv13Df22BSx/UW3KNnCLdsbUl9waS4wq4O4ZxXW8ragMUzKsTNggULeP3119m6dSuVlZUAxMTEuF1OV111FRs2bODSSy/ltttu469//Stz584lIyMj0LBB4XQ6eeDjLZTX2hiak86fzu/b5DG1uOS0bECIGxlYHIA8l7jJPT18c3Q/S7imKo+LDAeJNr5X5gZwW2+sleIxa6XnB10RLLWlUFvmGcdh9YhIxTWhBAVPflHEKig/4suecJnanWCrjs6y9RKBOmamLF/EhEB9tyQEH6CrHLdMJZoV0TDxYY/FImds/SwpxTKjWJHUbi0tq5LaguPb3mPbR9q1k5SxlVgitTAC/bP19Ky4rLaUtQGLZ8TFzeWXX86zzz7LokWLmDZtGk8++SRr1ohOvwaDAavVSm5uLlu2bGHw4MH07duXFStWMGLECF3m/3jDEX7YW0RcjJEXrx2K2RSet2R87/YkmE2cqLBwoKgyLHO0Cg676lh0C6O4iYmDPueJ+7u/Dt88LR3f7BEl5iY+XbiSQNxaKsWPfUZ31xOd4PSxiBmM3q4JX7O/OkZDyYyJz/Bfu8TfOiXNh7olhhITEp+h7bbUip/S+twUkeHE85hyroAn1kTdDd5ffIxyfn00Axb9yf/8OWM9BScV8QSAQQS2K4HyyutRajgpFpVgxXVDMUJahNqQsqG1RGGDy3ARE8nJV6xYwb59+9i6dStGo5Fvv/2W999/n7lz52K32xk/fjxmszBnd+vWjaeffhqjjmXzy2psPLVoDwB/PK8vvbKSdRvbl7gYE0O6prHmYDHr80ro3UE7qLlNY6mEY1vF/XCKG4C+F4sfyr3feupltDXWzROixEn9jCTwiBAQV6nq+iLfPODJfqotEbc1Jf7ncliFdQZErRtLJThsIg24qkhsHjO31S8/r5THV6xHWqjXKWk+tN5338/LHRSb6O3CUj5frXTupU8IgaQICsXlpAgb38BkZRyljpLv+bztY8+xyvzqVh1KPaW0HGHlyR0v/mapFOd2TJx3XI9bfKd71qGcs4HwtYT6/l8PlNcTLUI/gu0kImq5SU1NpWPHjlRXV+NwOLjgggu4/fbbSUxMZOHChRQUFADw7rvvsmLFCl2FDcDclYcoqbbSr2MKt57VQ9extVA6i2/IKw37XC2Swk3iij+1iz4tFwLR8xxxe2wrVLfRIO+lT3hfgYL/ppa1pd7PjVMuBAxg9NdLzeC5VdowLHPN6bACzvqFz/xZdKLlx1oSGH9ZU6Y4bxdWIMuCAXGOLPoTLH7Iu9aNEkOjlbGkPp+XPeE5j42qa3hl/kDd5dXB0Gk5olyBEkukHDv5/0QskZYVUgutdiThOLejzTITQZdxRMVNVlYWO3bs4O2333YLlzFjxjBt2jQ2b97Mrl27ANi8eTOZmZm6z//VtpMAPDV1cNjcUWpGdBPiZv3hAFe4bZmCX8Rtl5HhnyulI2T1B5yeasitHV/hog7qrT4lrnp93Qfr5okaJe5ACqcIHO01yfN/h80zjtlVlM9gEplpIK5wJz0sxrSqK90aGi58Fm0/1hJvFGvJU9ku6x7en5fy+SkF+5R+YIq70TdgF7xjdmw13t3g41M9bRt8N0yD6o4TzzFqIa640NRBxv7OMeXvSs0lm6XxVgjFOqRuR9LYasQtiQhenERU3HTt2pXXXnuNxx9/nPfeew8QAb7nnnsuAwYM4J13RBXZp59+mkGDBoVlDdNG5QTdYqGpjHBZbvadqKSsxtrA0W2QIy5x03VU88zXY4K4PbiyeeaLNL5XUUpQb0KGKKinlX699AnqRYhaq12p3AquxwdfDRc8KcaLS4V+l4ixFGGjzngZfLW4+lVcUlK8tEyUTdtaHdgCqAQfVxV5B/OqLSjqUgJKbaS0ruL8UGJsakpE7JdvHMycwUJwK1YVxeriFbz+f56srECtOnzXroxlimu8FSJQppJWZlhrCY6P4MVJxAOKp0yZwuOPP84DDzzAG2+84a5bk5mZ6bbW6Jn2raZ9Ygx/uWRAWMbWol1SLJ3TRIfxPccrmm3eFkPBenHbpZnFTVux3PimwIL44Zn4sLgqVqwuarGhvhruPNwzVm0J3qYfRHD2ons9roFtH3vG8nVP5K/xX/FY0nI4c6brvDGIVhrqGBT1Jq2kjeeM9TwvIUPEs8RniFgYJeg3fw3uc6v8qGcsu2L1c4r4LeUcVR5XZ0upN1XfsgHPdvdkOmnhu3ZfN1WgasL+xgyUqaSeryW4YVuIdSni4sZgMDBjxgyee+457rnnHqZMmcLVV1/Nyy+/zE033RTWuR+8oBdpif7iBcJD304ikHj3MSluvKg4BhVHxRVb52HNM6fyQ3tyl3fqcmvBX1M+3yJmo2eIH26bxdMfSmHiwz79n9SCRsOi4/U3Z+ANwqk9jKQFMXoGJLYHnJDUXvxNCdiNzxBxJuvmeSw3SgE+pYaLtVq4jQq3eMY8c6Z3kTpFCFmrPcco4yrH+/aE0nJ3gcfSpFU7RsFXiKlfq7/aSsE03fTn0lKvP9j4nYYEWjhpIdaliIsbEDVtrrvuOtavX8/UqVOZOHEia9euZejQoWGd94xezeOOUtNPihttjm4St5n9IDapeeZM7gDpuYATjqxvnjmbE38/Qr7F19bNE+4npZO3euMYPcPT/+noRkJWIkk+sXLqH28lDiOYcviS6EURH0pJAMWKEpcshMTX93vOObVbRm1JjInD3Zpj9AzvInWjZ4ix3Rg8ItxXNCjnvFKnxreGjqVSWJrUgb2+KEJMnW7ui+93qyGLSyBB0Jh074YEWjhpCdYlokTcKPTv35/f/OY33HnnnfTr1y/SywkL/RVxI91S3hRuFrfZ4RW09eg6WtwqwcytCX8/QkoZ+6ObxA/uontV2VA+G8ecwSIIVLHYxCS63FM+LimFBJV7CzyiVYtgNhFJ9KOupOvEc86p40zy19R3y6gtidZqEV+TO17b8qJuumpO8IgipcWC0lLA3SCT+injq+aINVpr/J6+QHCbtz8Xr1aF5WDHbAhlzJyx4nsWSKCFkxYS5B9V4qYt0Lejx3ITTNPPNkPhJnHbXC4pBbe4Wde88zYHWtVUwfPDrmQzicp5rkDfq7xL2JfliyBQJcDTVg3Db4BHS0V1YfUuEZ/hcmOp+rLFJOCXFnIFKAkCxXqj3FdiXdSCxl/jSfV54FspWLFMKPFeJrMIWldEkWJtVCxC6jmVgpFqUaB0BldSzT/S2KADZTEpoivPVWzUX+aWv7idpggCdWzRA4c8qegSTaS4aWZ6d0jGaICyGisnKywNP6GtEGnLzZH13g0eWwtqE7bSDyqju/iRz/Kxjl7yvLhyVsgZCxig6hSkdvb8fdG9nrRfNwbxYwueSsYghE6gIMsWcAUoCYC69YBWHyR1dWHftgq+x6gDz5VUbcUyMvwGIaaTO3nmVerGDL5a2yKkzKmUN1CsR+7u84ig92CCY93uro+93V5Wi7ZA9yfcmxKM25wXAy0kaDgQBmcbNB8UFBSQk5NDfn4+Xbt2bfb5z37+e/JOVbPwtnGM69m+2eePOipPwgu9AQPMyoe4lOab21oDT3cRV34zd4S/eKAfdu7cycCBAykrKyM1NVW/gdVViA14VxFWXAYgNojc8cK877SLDaC2FE+MjYF68TYJGSL9dvunYjO6ep6nQq3BJNLBa0vED7Ky2UhaDMrvZMBz8pnu4jOOz/Ck/OeMFRYNJ55Kwcp5EZ8hYnF8K/v6a6qpVAlOyxF/L8uvf9/fuaXMmZAhhJd6no9miPM2Jk64xNTr8pcevmqOqAdlrcb9fUjIEFaUYFHWFO3fiSheZ3l5OWlpaQ3+VkrLTQTokSkCZg8WVUV4JVHCMVemRLuezStsQLhmMl3NUpXWDy2BYK6slB/kXpPED3evSd7xCMrV8eQXvYWNweQJIlZQXFhK2i+uh327Eyum/0FTA6fOSloHBtWtOoZGHfCqBPImuASQYqUJFGSrroukjuFR31eCmH2/A0o2UdUpcczEh+tbCJXz9oInxZgG6tfbUY+rvDbleMV9O/Fhz5zBWDq0Mrui0TrSClzGUtxEAClufDjuujLodFpk5s8eIm6PbQl8XDSg1TXZH77xC2qzfHyqEDRKnMOyJzzC5pLnPVVZQRzf7xLxWL9LRDE0pTifv2Jt+Wuk26ktoBTI6zXJcx4owkMJeFUCedW1aSDwBqo8phYm6pgd0HaDqRtb2qrrz+mLMiZ4r7eh71bueO9zO9j0aPV3IppTqlvBd1eKmwjQ0yVuDpyU3cEBj8UkUuKmk0vcKHE/0YxW12RfPpoBj6ZD+RHA4Cl5rxxrKfek6CoiSRlP6dvTe5L4sU/IEPeV3j7bPxVj+PuBbgVXfJIQ0KqdNHqGcNUobioljdtSWb/uklaAsXpc3821oYJ3Xo0tfbKJ/FlKlLg0pU2Dbw8of/Oracx5H8pzotnKE6VIcRMBerq6jx+QlhvBMcVyMyQy87cky43yg6iY96F+6uy2jwGnaEKq1KfJGSs2CnU9G6fdU7ywXXcxttrK8+AhsUlpZaX4rsc3mLMFX/FJGoFvavS/z/FUHFa6xteW1O9bpqRyB2u9aKjgnfL44KtUPaVcqIWJWiz4ZmspQkcrW0pJw/Z1h/muJRgxEsp3JZqtPFGKFDcRQHFLHT5Vjc3uiPBqIoy1For2iPudBkdmDR1d85YehtrywMdGGt8qqcrmoGRxLH3CuwuywraPhABSNhoFp+v8K9yiEj4G75iAnLGuDePq+leaUsy0XdQbuK8F5+hG7eeoa88oVhbfejSB8FfeQP24VhVu8I7TUTeI1crWUkSabwXi/DUed5i687gveokR3++gtIgGjRQ3EaBTajxxMUZsDidHSmsivZzIcnKn+IFLaAcp2ZFZQ2I7T4rpyd2RWUMwaJV8VzYHJeC3tlTUAgHxQz74as/zt33sM6BB1A9RAoCVjsUGo7fLSWmS6RtnIGnbaG3gijhQ9yFTM2iq5/xRjlXq0YQyr2/Asq/I8LUoKsH1Not4nt1PCrc/ceQbzJyW49153Be93LOK23j/0vB+91qh20uKmwhgNBro1k5Ucc07Vd3A0a2cY6pgYoMh8LHhpIOrgeqJHZFbQ0P4i2+55HmRxaGkp1qrPWna+Ws8FhezqqCeOVEEBt+23JPtpHY9qTNclEwSpb5NK/oBlDQBrQ1cEQe3LRdZeGk5YFT171OqUQfqtaSFrxvJN2A5UO0c8BxjdV1MWmsCzx3I3RpMI029LJpOn9tANNRXK9BzgklQaGFIcRMhctsr4qaNx90c3y5uO0bIJaXQcZC4PbEzsuvwh1ps+PvBTUj3HB+b7Ln6VLolX/CkZ1O44Mn6MQXKJpSWI9xdSobLxIc9lV0j1c9GEn00tIErj1/8bP12AaG6bdTHKwHLSoXeQGnhCupYHOVcDjR3oCrFvo1oQ4mzCYTW8xUBNenhhp/vr7pzMM8JlKDQQpHiJkJ0ayfibtq85UZJA1fERaSIdsuNkk6r9H16rF390vETHxYbiDlRZHzkjBW9oMoKPMfWlmsLlFVzRP8epUCaOhZCKWkfyX42kpaLrxiB4Cr4+gv61RpfiYNRqnD7i8W5el79Hle+82r9HxoWZE2NswnGAhXIOuNb3TmY76lvgoJeQi0KkOImQnTPdFluituwuHE6VTVuImy5iXZxo/6hKssX4mPbR/UzNh48BInthQja9rGo9YFTHKsEDGsFcGrFFKhjIbQ2KIkkFLQCkEE7cHfVnPrWmkBWIuWcDcaFqpWC7issAsUT+RMNTY2zCeb5gawzagEXrEssmJT7FooUNxFCibk53JYtN+VHxSZsMEFmhLvAK/NXnYTq4siuRYvRM7yDgxX8BTMqpnc1BvwHcPq6uPzVH5FIGovWhhmoTlKgzd6fiyhYF2pD9ZkCxRM15IZrrPgP5vmNsc40hlZQr0qKmwiR296VDl5c3Xa7gyvxNpl9wBwf2bXEJXtcMpHOmPJnEr56nidIc/DV/uMMFDeSUoRPCShWqr2CtulfTSu4cpNEGVobZjCBu1qbvXJ++rqhGnKhBpta3VShEi63TmOsM02ZpwVbaaW4iRBd0hMwGqDGam+73cHd8TYRdkkpKD2miiIsbvwJCyXDJGesJ+vE39Wp4qKa+LA4Vp0Z4s/0r6YVXLlJogytDbOxQbm+bihf94w/F6q6Xo1WNtXX9weOuwkWeXEQcaS4iRCxMUY6p4vU3MNtNe7GnSkV4WBihSyXa+rknsiuw5+w8PW3Kx2+kzLFbbBBkMGY/lvBlZukBRJI2PtzQ4Uiwv2d74orV6nArS6QGahYnz8BJC8OIo5GKVNJc9GtXSIFJTUcLq5mVPd2kV5O8xNtlhu3uNkVuTWsfwc2/Uu7BkfOWBGnlD1EVBRW6tIUutpGaAVF5owV931jB3yvniWSSOBb70aJ9fItvldX6ckU9D13Qzl//R2vtuAoa1CC79XF+gIF3jZlXf4ItR6QxI203EQQd1BxW7TcWGuhaK+4H+lMKQUlqLgogpab1XP9m7P3LRU/uMWHRFyBOREwiOBCqN8jR8v8LpFEE779nnw38uasw6LVhuGS5wMX6wu3hUa6txqNtNxEkG7t27C4KdrtaruQEbm2C74olpuyfBGo69t4rzkYd5fHcuOLQXWrvjJUTONnzvQEDIP3FbBEEo2oLTVaVhD1480p0IO1bgZjoWmK9cXXkiUJmpDFTVFREW+++SY///wzx44dA6BTp06MHz+em2++maysLN0X2Vpp0+ngx1QuqUi2XVCT2A4SM6G6CE7t9d8fJ5yMvBHO/X39v6+bJ65eEzJEnIEarU1BL7O4RKI3vpu9+jz13chbw3nsz3UVDK3h9UeIkNxS69ato2/fvrz00kukpaUxYcIEJkyYQFpaGi+99BL9+/fnl19+CddaWx1t2i11bKu47XRaZNfhiztjam9k1+GLUqE4Nrn+j52/TsYSSTTiz9XSWoPYW3twcZRWMw7JcvOHP/yBa665hn/9618YfK62nU4nv/vd7/jDH/7Azz//rOsiWyuKuDlRYaGmzk5CrCnCK2pGolXcZPWFwz9FvtaNL4HM08rV3ZzBjb9ClEiai7bmamnt1pemWKbCSEiWm82bNzNz5sx6wgbAYDAwc+ZMNm3apNfaWj3pibGkxgt9mV/Shqw3Tmf0ihu35SbC6eC+qK9qZfqppCUTSQtNlFoZWjRR+rsTkrjp1KkTa9eu9fv42rVr6dixY5MX1Zbo5u4O3obETVk+WMpEF+pIt13wxZ0xFWVuKTVtzawvkeiFzD7Snyj93QnJLXXfffdx2223sX79eiZNmuQWMsePH2fp0qW8/vrrvPDCC2FZaGslt10S246Uk3eqKtJLaT4Uq02H/hATG9m1+JLZR9ye2gd2G5iiMKGwrZn1JRK9kN+dNkNIv9x33XUXmZmZzJkzh3/+85/Y7aKImMlkYuTIkbz11ltce+21YVloa6VNpoMXbha3HaPMJQXCvBqTALYaKDkEmb0jvaL6tHYfvkQSLuR3p80Q8mXptGnTmDZtGlarlaKiIgAyMzMxm826L64t0L0tuqUUcdN5WESXoYnRKKw3x7aIWjzRKG4kEolEEpBGVyg2m81kZ2eTnZ0thU0T6NZOdAdvU26po5vEbfawSK7CP1n9xW0k2zBIJBKJpNHI9gsRJtdluSkoqcFmd0R4Nc1AxTGoPAYGY/S0XfAly5UxFckGmjKrQ9JWkOe6JAxIcRNhOqXGExtjxOZwUlhWG+nlhB/FJZXZF2KTIrsWf0SD5UZmdUiA+avzOOOZZcxfnRfppYQPea5HPS3xPJTiJsIYjQZyXcX8Dha1AdeU2yU1NKLLCIg6HdwRIWtalNaOkDQvry7fz5HSGl5dvj/SSwkf8lyPelriedgixE1FRQUgqiC3RrpnCgtGmxA3R1ztObqMjOw6AtGuh6jBY62C8oLIrCFKa0dImpc7zulFl/QE7jinV6SXEj7kuR71tMTzMAqLeHhz8803YzAYePLJJ+nSpQtOp1OzQnJLpkdbETdOJxxZL+53GRXZtQTCZIb2veHkTjixC9K7RXpFkjbK9HG5TB+XG+llSNo4LfE8jHrLzfr168nLy+OZZ54hLy8Pg8EQsgXHYrFQXl7u/qdYgqIFRdwcau0ZUyWHoPoUmGKjN5hYocMAcXtiR7NOW15ejsViadY5JdFHpGMcLBaL+3dSnpOtg0ifU81N1IobhyvWYfDgwXTp0gWTycRzzz3HoUOHQrbczJ49m7S0NPe/gQMHhmPJjaZ7+zZiuVGsNp1Og5i4yK6lITq4zpETO5t12pycHGbPnt2sc0qij0jHOMyePdv9OynPydZBpM+p5iZqxY3RKJZ2ww03cNpppzF58mRKSkr417/+xaeffsr8+fODHmvWrFmUlZW5/+3Y0bxX4w3RM0uIm4KSGupsrTgdvKAFxNsodFTETfOeK/n5+cyaNatZ55REH5GOcZg1a5b7d1Kek62DSJ9TzU3Ux9wYjUYWL17MzJkzSUlJ4dFHH+WVV17hySefBAgqBicuLo64OI+loLy8PKxrDpUOKXEkxpqorrNzuLia3h2SI72k8JC/WtzmjI3sOoJBcUud3A0OOxhNzTJtamqq17kqaZtEOsYhLi6OlJQUQJ6TrYVIn1PNTdRabhQuuugiunXrhtlsxuFwsG7dOoYNG8b27dspKChoFcHFBoOBXllC0Ow7URnh1YQJSyUUbhH3u42L7FqCIb276DFlt0DxgUivRtICaGsxDU1BvleScBN14sY3WNhms2Gz2bjuuuu4/vrrefbZZ3nwwQcxm83ExES94Slo+nRQxE10BTvrxpH14LSLehZpXSO9moYxGj3Wm+PbIrsWSYugrcU0NAX5XknCTVSImwULFvD666+zdetWKis9lgu73U5MTAw333wzK1eu5IEHHuDWW2/l0ksv5bnnnqNTp04RXLW+9O7Yyi03h1uQS0qhk6truWJxkkgC0NZiGpqCfK8k4Sbipo/LL7+cvLw8unfvzpw5c7jsssu48sorGTt2LCaTiHMYNWoUy5cvp0+fPjgcDoxGI8nJrSsupU8H4d/e21rFTd4qcdsSXFIK2UPE7TEpbiT+mb86jxcW7wbgvgv7tam4hsbiG/8xf3Uery7fzx3n9Gry+6fnWJKWS0QtNytWrGDfvn1s2LCBzz77jL///e8UFRUxd+5cfvrpJ/dxaWlp9OnTB6fT6c6iam143FKV2B2trBKztRYOrxH3e5wd2bWEQidXi4jCzaIAoaRN0lB8yKvL91NaY6W0xirdLI1ETzdVS3V5yTgkfYmoUkhNTaVjx45UV1fjcDi44IILuP3220lMTGThwoUUFIjS9++++y4rVqxoFcHD/shpl0hsjBGLzUFBSXWkl6MvBetEYG5yR8jsE+nVBE/HQaJ7edVJ0c1c0iZpaLO845xepCeYSU8wSzdLI9HTTdVSXV4tVZRFKxEVN1lZWezYsYO3337bbZEZM2YM06ZNY/PmzezaJboyb968mczMzEguNeyYjAb6uuJudhZGV6p6kzm4Utx2PwtakkCNTYT2LjGmdDOXtCnmr86jymILKFymj8tl0yMXsOmRCxp0g8irc22mj8vlxwcn6uJG0nOs5iTcoizS515zzx9RcdO1a1dee+01Hn/8cd577z1AZEude+65DBgwgHfeeQeAp59+mkGDBkVyqc3CoOw0ALYfbWXi5sBycdtjQkSX0Si6jBC3SnVlSZtCcTklxcXoslnKq3OJP8ItyiJ97jX3/BEPYJkyZQqPP/44DzzwAG+88Ybb9ZSZmem21sTGxkZyic3GwM6pQCsTNzUlnk7gvSZGdi2NoaurwWfBusiuQxIyTblSVJ47MjdD16vpluoyiWb0+JzbgiUt0udec88f8Wwpg8HAjBkzSE1N5dZbb+WLL74gNjaW7777jpUrV0Z6ec3KILe4KYvwSnTkwApwOiCzH6TnRHo1odN1tLg9sh4cDlH/RtIiUF8phno1rDwX4McH9RPlba1KbHOgx+fcmOe2NCJ97jX3/FHxSx0TE8N1113H+vXrmTp1KhMnTmTt2rUMHTo00ktrVgZkp2IwwPFyC0WVraQL7/6l4rb3pMiuo7F0GATmRLCUQ9GeSK9GEiTzV+dRXFWHARiZm6H5eKAr9pG5GZgM2s+VRBcNWQQCfdZNtSaE2/ITrZalaF2XmqgQNwr9+/fnN7/5DXfeeSf9+vWL9HKanaS4GHcbhs35pZFdjB44nbD3O3G/pYobUwx0dsXd5K+J7FokQfPq8v3UWO04gfV5JfV+jJUr9hcW72bYY98y7LFvvX6o1+eVYHeKW4n+6Lk5NhSrEijWI5Q4F601NzWOJJgyA9EYoxWt61ITVeJGAqNcV4prDxVHeCU6ULgJKgrBnCQypVoquaeL20OrIrsOSdD4pmf7/hgrV+xAvRo1wWRISZpGc26OesV6aK25qWMHU2agS3oCI3MzospSEun4nWCIeMyNxJtR3duxcF0+vxxqBVeMexaL217nQkwL7ircYwKsfF6ktDudLSudvY2i5d9XqtaqK9gC7urCyv+VDKku6QmtPg4jUiiCMxybo2+FYr1iPbTW3NSxG3oflPHPeGZZVMUGRTp+JxikuIkyRncXlpstBaXUWu3Em00RXlET2P2NuO17UWTX0VS6jgFTHFQeg6K9kNU30iuShIj6x1i9UWi5JMK58UoE4dwcwxUkHI41BzumPCdDR7qlooxu7RLpkBKH1e5s2f7+0nzhljIYW764McdDN1fDz4MrIrsWiV+CjeNoyKTemHojLSHAsq0QaZdJOM6FYM5JeQ56I8VNlGEwGDi7bxYAS3Yej/BqmsCuReI2ZxwkZ0V2LXrQ81xxq7jaJGEh1B9o9fGB4hfUx4WjWFpLCLBsK0SiQvH81XnuwPQXFu+OyLngew62dbEjxU0Uct7AjoAQN86W2rBx11fitv/kyK5DL/pdIm4PrgBLK+3cHgWEKhLUx2sFXyo/8OHecCJtLZBElhcW73YHpgMRORd8z8FgvkutWQBJcROFnNUnk9gYI/nFNexoiX2mqoog70dxf8ClkV2LXmT1g4zuYK+DA99HejWtllBFgroejXLFvnLPSXeat7oYnzJupNwGkvAQTRu0Abjvwn5NSi8P5XE1vudgMN+l1mxxlOImCkmMjeG8AR0AWLg2P8KraQS7FomqxNlDhSBoDRgMHuvNjs8ju5ZWTKgiQV2PRnENKFfP4PmBV284rfkHvS0SDZ/nfRf2o0t6Ak9cMTjoc3f+6jwe+XxbwLX7e23BiJ5gvkut2eIoxU2U8uux4oT8dOMRKi22CK8mRJTNf8CUyK5DbwZfJW53LZKuqShBbblRUrhBXEEr3HFOL3exvrsXbJQ1bFoQwWzi0bBBN8Zy9+ry/didYDLg16Lo77Wpi1D6e3/0EEDRZBULFSluopTxvdrTMyuJSouNeT8cjPRygqe62JNRNPDyyK5Fb7qMhIweYK2G3V9HejUtHuWH8+4FGzV/QO9esJFesxZx94KN9Z6jHLtyz0nsTvhuxzGqLDYSzEbSE8ykJZjdhfkU0VNaY+XLzUeD7vLdkn/YWwvBWGXUG7T6M4uWz08dbKxey8jcDAxAbIzYhrVeqz/xoS5C6e/9UcZ75PNtjX4PQrWKNeY9D9fnJMVNlGIwGJh5nqin8trK/RSW1UR4RUGyaxE4bNBxMGT2ifRq9MVggCHTxP2N70Z2La0A5Ydz0Zaj7h9Q9Q/doi1HsTvhy81H3X9TAoMf/mybu5IwQI3VQWmNlVqrA4vNgcVmd1tn1Fe9MUZD0Ff50eDuaOkEu3H5O86f5cLf8erPLJTPz58o0mPjVQcbq9eyPq8EJ+LcVQfEB/NaFdGjuMO0zuc7zumFAbA7PYUqQyXUCsmN+c6E63smxU0Uc+mQbEZ0S6e6zs59H27G4WgBmVPbPxW3g66I6DLCxvDponbPwZWioJ+k0Sg/nJOHdHb/gCoxCI98vo1BndMwGSDebHKb4Mtcbicn8PBn27D6fCfEZmGnxupwW2emj8slPcEMiP5twboPosHd0dLR2ri0LBn+Njh/lgt/x6s/M/X9UHo4BRJIjRE7FpvdfV8tEnxbhEwfl+su1qfVv0rLBRXIrTR9XC5prvPeYnM0SqQp46/PKwlKgDTmOxOu75kUN1GMwWDg+WuGkmA28eO+U7y8bF+klxSYqlMql9TUyK4lXKTnQJ8Lxf11b0R2LS2c6eNyGZmbwaItRxmZm+EODgZxtbnlSBmTh3Tm/IEdMSB6QDkR8TQGhJDxhwFPOwXlBz09wcyEvlmaLgJ/65MZUE1Dq7u62k2o7vWVnmCmymILysrjL25K/Zmp7zcUo+JPFAWTXt2Q4ImLEVXm0xPMXiJh+rhcNj1yAZseucB9jgXqXwX1XVANza1YduJijI0SacpxI3MzghIgWt8ZrbnCXXcKpLiJenplJfPEFYMB+PvSPSzbFcWF/XZ+IVxSnYZAZu9IryZ8jPmtuN3wLtS04CrSUYDielIEjskAQ7qkeT2umO8VnAj3UoLZSILZRHqC2es5JgPu74xS40aJs1mfV6LpIpDog+9GptVd3ddiAWJTTIqL8fu5qMdVPk/lecHQUIyKP1EUTHp1Q24VRWDcd2G/BkWc1viBXFANze3vucG6gpTj1ueVBCVaAo2hnqs5XL5S3LQArh7ZlenjuuF0wh8XbiK/uDrSS9Jm28fiVskqaq30mihiiqxV0nrTRCYP6YzJIG6VjfBUVR1Thnr+rt4MlSwoq8NJrdWBlv1m8pDOAG4XF+B2e4mgY5PMltIJ3w3OX/d1383a12Lh71iFphakU2/ywVqItNCyMqgFi1ZwvK9YCiTilGPXHiyuF0zvb+7GWFSCfV5TPxP1GL4uuXC7fA3OFlsCt/EUFBSQk5NDfn4+Xbt2jfRygqLO5uDa135mU34pw3LS+fB3p2M2RZE2LT8KLw4EnPDHrZDeLdIrCi9bPoBPfgsJ7eCPWyAupUnD7dy5k4EDB1JWVkZqaqpOi4wulBYJigtqZG4GK/ecBMTVLYgfzPZJsWw/KlxSL103nCkvr2LLkTKGdEmje2YSX2w+GnCe9AQzSXExHCmtwWSAxy4f7NVZuUt6Aj8+ODHsr7elo/xOBjonlfdUeZ/B031dTzeDbyd3rTmC/XyV45TzpKG1+nYZDzSmQqA1+I6n9b1QznED0NklApS5g1lPMMcEWkswn5/vuht6jlKDKj3BzKZHLgg4diDKy8tJS0tr8LcyinZHSSBiY4y8fN1wUuJj2JRfyivRFn+z9UPACd1Ob/3CBmDQldC+N9QUw5p/RXo1LQLlSu/LzSI76gtXWnZpjdVdTXhkbgZbjpRhd8IXm49y94KNbDlSBogYnDE92jU4j8Vmd8dkKMIGZIBwOLjjnF6YDCJGSokj0St+wl9chnIf8LKSBPv5Ku5Pi80RlOVBydDzzThSr095HxSOltZ4WV3U+KauKxZGJWtw0RaPeFeC6R/+bJs7Tqwhi0kwxQEVfMcKxV3kL9g4WlLwpbhpQeS0S+SpqacB8Mr3+9hSUBrZBanZ/L64VVKlWzumGDj7QXH/x5dFfR9JQBTzva+pWNkTFMGjxvf/j32x3ev/Q7qkuTOhQFht4mJMmrVsZICw/kwfl8tjlw/2EhVN3dyC6QemtYEH+/kq7s+4GGODYmj+6jx3hp4v6iDlV5fvd2f3gXCWqkWK1utThIpSyE/JGlRun7xiMH+dPACTQYynXARoiTh/YzaUKeY7llYAeKD3RivY2J9AUsceNQcxzTKLRDemDO3M4u3HWLSlkPs+3MyXfzjTHY0fMQo3w4ntYIptvSngWgy+En78BxzfCiueg4ufifSKogYt87aStaIEgw7pksapqjr3j+LDn20LmAEF1Ev9PlVVx30X9uORz7dhd0JFrdUdv+P74x8Od4kEtzVFQb25Nea9Vp6fnmAOGO+h3sAbQv35K+nW6s1YeR1a8zgR89x3Yb964zy1aKfb+nisrMad7WfAE/vluw7lXFXGCea8VH83lPdbERfKGOoGsuoxFZeZ1ufh+9lpBYD7Q5kT8HLB+b6//uZSvyeKVWxC36ygXFzBIC03LZAnLh9MZnIse45X8o8lUVBrZcM74nbAZZDQsOJvNRhNcP5j4v661+HErsiuJ0L4XhkGMosrhcUAth4p89pg4s0Ni3SzqwjflKGd3RufYj1Q3CNamR2yIF/z0VT3n7ofmFbdF/UxarejP3zPR3U9mYa6xfvO42utqbV6atgowfEg4mReum641xoUa5TdKcSPUoCyIWvT9HG5PHHF4HpWD19Bo/4+NCZ4WK9jQ7WQqksDqAt6NhUpblog7ZJiedKV6vqvFfuDUtlho64atnwo7o+4MXLriBS9J4mGmg4bfH0ftL34fE2/vfoH3DeDRHmHnODVuTsuxuiVEaWkhRsQoiY9wcyA7FSOuap1qzc+LfeIGhlv03w01f2nVZ8m2OJ+WmhZeRRRY7E5AmZP+cb3KC4YEG7UeLPJfZ6uzytxu5R8zzPldVhsDldhSmNQae+BXm8gQdPQe+XPVRUJ1+0d5/QiwWzCAAzqnKbb91SKmxbKRYOzuWJYZxxOuGfhRsprtf3CYWfL+2ApE92/u0+IzBoizUWzISYBDv0AG96O9GqaDX8+d+VHV+nvpFyNPfL5Ns0y8Oor9Ql9swBIMJt47PLBfPGHM3niisF0SI3nvgv7sf1ombsuju/GF+oPvKRpNFScTQ/0EKWBrDxxMcaAqdkKvvVeJvTNwmSA8wd2ZP/syZyqqvNbD0a9hrgYoyvex9RginVDPaGack4HE5Tc0OeolzV0+rhc2iXF4kS4mfX6nkpx04J5/IrBdM1IoKCkhvs+iEB7BqcTVr8q7o+5HYxt9HTK6A6THhb3F/8ViqIsky1M+P7gg7i6BbwKhynmeiUeIcEszhOz0YDFZncHSU4fl8sXm4+6Wyi8sHi3Vz+ppxbtJDbG6I5nkNaYyBJscbamCJ5gN/Bgatyox/AtrNfQeaQ+Rt33TLGaNzSGsgZFFE3om+X3dflmoIUDf4HDwQRzK8cVV1kwEFzwsXrsYIsXNpU2uhu1DlLjzbxy/QhiTUa+3XGcvy9t5vibPYuhaDfEpoieS22Zsb+D3DOhrhI+vAkslZFeUdA0dvMJpjQ9wJge7Xjs8sHurKa/Th7IlKGdsTqc7oaXWhYd37/XunpGKfEMvim10ZB+2pbQ2pAaU8HXH6F8pqHOEUxqubKGYY996yXAtdxc6jieQOsNFLCrvF4goIs1VLTex5V7TmJ34q4zpaAOEg40/6vL91NjdeAkuOBj9diBihfqaVmV4qaFMywnnSeuGATAS0v38t6aw80zsdMJy58W90f9BuJbZ+G5oDGa4Ko3ICkLjm+DD28GmyXSqwqKxm4+/gIXlUqk6qu/6eNysdjslNZYeeizbfVSvMtqrMxfnceUoZ3dMTcK3dolAtA5Pb7J1VIl+qG1IWlt8o29Kg/lM/W1rAQSRf4e92eJ8tcHKyXeHPD5Wg1Cg634q+dmrw6Cbkgsql3EgS4clPcgPcEcdMfw5ra0ygrFLaRCcUM8v3gXc7/fj8EAz141hGtH5YR3wm2fwEe/gdhkuGcLJLUP73wthYJf4K1LwVYDvSbBNf+B+LQGnxbJCsV6pknfvWCjW7go7qdaq4PLhnbmS5fLScFkEAGEShyNumIs4C7qp4xnMsD+2ZM11yxTvfUnmArFapTPoMpio7TG2uRK0I39TBuqVOzvca2Ku4Dbenjfhf28Cu/Znd6ViH3Xq65arLUWdQq0ukJ3uKo7K5+Lui6U8poCPVfrtarRu/J3Q5+7rFDcxrjvgn7cdHouTif8+aMtvPHDgfBNZqkQsSUAp/9eChs1XUfBdQvAnAj7l8K/z4XDayK9qoA09SpRfWWnLlxWY3W4Tddfbj5KvNnzczOkSxr7Z0/miz+cyaDOQvxV1dnqXbmqTd7quiGhBBNLmodgXRrB0tjPtCELQUMpzMF07g6mxo7auuFrUVJEg9oqFOj1huKi8z1WGVeJMwI0i1xqoU5dD/X9bCx6WWFlEb9WgsFg4NEpgzCbjLyx6iBPLtpJ3qlq/nbZQP17UH3zAFQcFYG0Z/5R37FbA73OhZu/gvdvhOL98OYFcNq1cPYDUd8t3fdqUvnxu3vBRr7cfJQYo4GkuBjNq9hHPt/GoM5p7nYJauLNRmqsDveP4AuLdzPssW/dGVAANrvTy7WgXEUD9a7i/BUKk0SOUIrj6YmWxUVZizK/b2+qQCjPVdwtvtZBf+ekbw2cO87p5dVDSV1MD3CLhjRVE1d/FknF6qIe29/76q+Iorr4X6jfnbQEs9/5/BXnayx6fbelW6qVuKUUnE4nr/9wgNnf7MLphNHdM3j5uhF0SovXZ4I1/4Zv7geDEW76Erqfqc+4rZHqYvj2Idj0X9cfDNB/MoyeAT3O8coui5bGmf5M6b1mLXJnO4GnXLySNaKgrgHi+Vs8R0prAVFhe+Wek+4qxekJZiw2u9t1pRQ+823IKC0yzU+obik1zdmkVH2uKO4TwGt+9Xp8H1Oj3vjVlZJBxIUp1Yq1zsmG3HLqsdceLGbRlqPu5rBarqOkuBi//w+lMWcw+HuOumntF3+Ijt966ZZqoxgMBm6b0It/3zCK5LgY1h0q4aJ/rBQptk3RsU4nrP6XEDYAEx+SwqYhEtvBFf+E25ZD34sBJ+z6Ct6dCi8NhWVPwfEdUVP4b/7qPKosNhLMRrcpXfl7rKvFh9lowADuWjOKeV5dMbh9UqzXuIqwgfqZFRabyIBKSzCzPq/EK/Ay3OmwkvDRnMGjylzqAnq+86v/H2xQr3IcCDeO8i1Vn5NazT0V90+gyr2+WVO+Lj2Lze4q+md3i6s7zunlTiVXp1/7c0NB/ewvf/irraNYVZXbloS03LQyy42ag0VV3L1gI1tdboKz+mQy6+IBDOwcomWgNB8W/wV2fiH+P+5OuPBpMPjmtUgCcnI3rH3dVfiw3PP39FwOJg2n523vRNRy4+9qe9hj33r1g7p2dA4vLN6NxWYHDMTFGJnQN8udVlqm2gjUmI0GHpkyiLUHi91Bwr5XxYECNCXNS1MsN3qh1zkQaBxfN404tx3ExRjdgb5Kb6cEs9Hdy+++C/u5RYEiZhpaq9q19d2OY26L5Zge7byeq3znFItNIKuTv+9tIOuZlvtLK3D47gUbvSxM0YC03EjokZnEx3eMZ+Z5fYk1GflhbxGXvPQDt7y1jm+3H/Pqi1KPmlLY8QV8+Bt4aZgQNgYTnP+EFDaNJasfTH4B7t0NV74BfS8SzUZL8zDv/CTSq9O8ovXtiqzE01TUWqmxOqhzpXd/sfmoOzhSETYG1z8la6pDarz7qhU8zQiT4mLc5n713DJIuPXjG2R7xjPLvNp16BVcGmgc3xiVpLgYaqx2r0BfpbfTXycP9KporP7OaKWC+1pOlGMWbTlKrSvYXhH66nPdX5HBYGsLBfq71vvhr33JS9cNZ//syWETNuGsTyUtN63YcuPG6STvVCUvfruLxVsLMDttxFNHe7OFzo5jTOzbjty4CjrYT5Bec5iU8j0klB/EoLr+ru16BpVnPw7ZpxFjNGA0GjAaDBgNYDQYMBjAgPi/wSBcFwbX/WjHYrEwe/ZsZs2aRVxcXDNPXgmHfuDAT5/R65Z/Rzzmxhd1DA6I+JniqjpqrA5AuKMU95QB6lls0hPM7itcrbTta4Z34qYn3uBwUn/uPLd3mxEyET3ngqQhy40er0ErFkYhWGtIMARruVHOT62geovFwkWPvc8hR3vizUb+OnlgvX5NWqngvtZIxUKS4AqyV16rVgxNuKyXwYzbHOdoY2KzgrXctElxc+jQIXr06MHatWvJzs6O9HLCSuLntxBTsLpRzz3g6MgPjiF8aR/HLmd3fRfmQi19Pr1tJB1SYv0eGy4qKioYOHAgO3bsICUlpdnnB9izZw+TJk0iPz8/KsTN++sO88YPBxmek87G/FKqLTbKam1kp8VzrKzWLWLS4mPompHIrmPlXDioEwDfbDvmfjzebCTOla1393l9mDa6m3vsW8/qwcX90t0XGtHwupuL8vLyqH/dBQUFDBo0yO8a9XgN6nMB4OlFO91xXH+ZPIBpo7s16TUEM2+wc5SXl3P686swGIVb6uFLA6/P3xy+r1l9jO9zzn9xBYVltWSnxfPdn85u0lzK+C8tEZXsle9joNcb7nO0sZ9DTk4OxcXFZGT4b/3QJsXNV199xWWXXRbpZUgkEolEImkEa9euZfTo0X4fb5Pi5tSpU2RmZrJ69eqovWpqDiorKxkzZgxr164lOTk50suJGNHwPuzatYsrr7ySb7/9tm24Sl1Ew3sfCVrC6969ezdTp05l69atpKen13s8GiyezYl8vdFBeXk5gwYNatBy0yaL+JnNIkNjwIABbVrcWCwWHnnkEYYMGRK1fv/mIJrehwEDBrQpcRNN731z0pJed7du3fzG3DzyyCP07Nkz6l+DHsjXGx2Ul4tMU5PJFPC4Nmm5CTYgSSJpLpQifm0myF0S9URLYUmJRI1MBZdIJBKJRNImkeJGIpFIJBJJq0KKG4lEIpFIJK0KKW4kEolEIpG0KqS4kUgkEolE0qqQ4kYikUgkEkmrok3WuZFIJE2kNB/W/wcKfoGYOOg6GsbdAXGNK/bldDr5eusx5q/Ow+F00jMrmXsv6EtmcvTU15BIJC0HKW4kEknwOJ2w6kVY/izYLZ6/7/0W1s2D6xdC59A6CNfU2bnjv+tZvvuk+29rDhazdOdx5v56BKO7t9Nr9RKJpI0g3VISiSQ4HA74/C5Y+rgQNt3PgstegktegIweUHkM3psmrDpBYnc4uWfhRpbvPklsjJE/TOzN36cNo0+HZE5UWJjx1jryi6vD+KIkEklrRIobiUQSHEv+Bpv+CwYTXDoHbvoSRt4EY34Lt6+EDoOg8jh8doew8ATBC9/u5tsdx4mNMTJ/xljuvaAfVwzvwue/P4Ph3dIpr7Xx+wUbqbM5wvziJBJJa0KKG4lE0jBbP4KfXhb3p/4LRt0CBoPn8fhUuO49MMXBoR9g35KGhywo47UV+wF44ZqhjOnhcT8lxsbw0q+Gkxofw+b8Ul7/4YCuL0cikbRupLiRSCSBKTsCi/4k7p91Hwy5Vvu4jO7CigOw5LGA1hub3cGDn2zB4YTLhnZmytDO9Y7JaZfIY5cPAmDu9/s4Xl7blFchkUjaEFLcSCSSwHx9H9SWQZeRcM6DgY89614wJ8LxrZC/xu9hC9fls/1oOWkJZv526UC/x10xrAvDu6VTXWfnuf/tbuwrkEgkbQwpbiQSiX92/w92fw3GGLj8n2AyBz4+sR0MvELc3/Cu5iE1dXZeWroXgJnn9SErxX+6t8Fg4JHLhPXmk40F7DpWHvJLkEgkbQ8pbiQSiTa2Ovify1Iz7k7o0D+45424Qdxu/xQsFfUefufnQ5yosNAlPYHrxnZrcLhhOelMHpKN0wn/9+2eYFcvkUjaMFLcSCQSbX55E0oOQlIHOPvPwT+v2+nQrhdYq4TlR0V1nY1/uYKIZ57fl7gYU1BDzjyvL0YDfLfjOJvyS4Nfi0QiaZNIcSORSOpTWwYrnhX3z50VWuVhgwEGThH393zj9dD76/IpqbaS2z6RqcO7BD1k7w7JTB3eFYAXv5PWG4lEEhgpbiQSSX1+ngs1xZDZF4bfGPrz+10ibvcuEe4twGp38MYPBwH47Vk9MRkN/p6tyT2T+mAyGli55yQbDpeEviaJRNJmkOJGIpF4U1UkxA3AxIfA1IguLV1GQlIWWMrg8E8ALNpSyJHSGjKTY7l6ZNeQh+zWPpGrRghrzz+W7A19TRKJpM0gxY1EIvFm1Ryoq4TsoTBgSuPGMJqg74Xi/p7FAPznR2G1uen07sSbg4u18eX35wrrzYo9J9ksY28kkmZh/uo8znhmGfNX50V6KUEjxY1EIvFQcQzWvSHuT3zYuwpxqPSaJG4PrmTj4RI2F5QRazIGlSHlj27tE7l8mCj49++VsmqxRBIsTREory7fz5HSGl5dvj8MKwsPUtxIJBIPq/4OtlroOhp6n9e0sXpMELfHt/HJD5sAuHRoNpnJ/uvaBMNtE3oC8M22QvJOVTVpLImkrdAUgXLHOb3okp7AHef0CsPKwoMUNxKJRFBxDNb/R9w/9y9Ns9oAJGVCx8Fi6J3LALh5fPemjQn075TKOf2ycDhxByhLJJLANEWgTB+Xy48PTmT6uNwwrCw8SHEjkUgEitUmZyz0PFefMXucDcAYtjKkaxpDuqbrMqxivfl4QwGVFpsuY0okrZmWKFCaQosQN5s2bcIZoAmfRCJpIpUnPFabcx5sutXGhbPHWQCcbtzBtaNydBkT4PSe7emZmUR1nZ2vNh/VbVyJRNI6iHpxc/nllzNr1ixOnjyJw+GI9HIkktbJz68Iq02XUfpZbYBtpoE4nAZ6GI8zpZd+PzcGg4Fpo4VYWrguX7dxJRJJ6yCqxc3vf/97jh8/zmeffUaHDh0wGhu3XIvFQnl5udc/iSRasFgsVFZWRm4B1cWwbp64P+F+3aw2AAu2lrPLKbKjUo+v021cgKtGdiXGaGBTfqlsqBlGysvLsVgskV6GRBISUStuampqKCoq4rXXXiMuLo53332XBx54gOeee44lS5aENNbs2bNJS0tz/8vJ0c88LpE0ldmzZzNmzJjILWDdPFHXpuNgT20aHbDaHXy9tZC1jn7iD4d/1m1sgMzkOM4b0BGATzcc0XVsiYecnBxmz54d6WVIWjjNXSsnasVNQkICTqeTkydPMnfuXB544AGSkpJYs2YN//jHP5g/f37QY82aNYuysjL3v/x8acaWRA+zZs1i7dq1kZncWgNr/iXun/FHXa02P+4rorTays5YkTFFnr7iBuCyoaLmzf+2H5NxeWEiPz+fWbNmRXoZkhZOc9fKiVpx43Q66dChAwsWLKCoqIjPP/+cv/3tb/zzn/9kwoQJLF++nNra2qB+0OLi4khNTfX6J5FEC3FxcSQnJ0dm8k3vQXURpHWDQVN1HfqrLYUAtBtwjvjD8W1QU6rrHOf0yyI2xkjeqWp2HavQdWyJIDU1lbi4ptUmkkiau1ZOI5rGNA8Gg4G//e1vjBgxgmPHjjFs2DAcDgcdO3ZkxIgRfPzxx9hsNuLj4yO9VImkZeJwwOp/ivun39m4HlJ+qLM5WLz9GADnjBwMhT2h+AAUrIM+5+s2T1JcDBP6ZLFk53H+t+0YA7LlhYtEEo1MH5fbrGnoUWe5USwxVquVrKws/ve//9GhQwcWLlxIYaG4Ejx06BCJiYnSDC2RNIV938GpfRCXCsOn6zr0j/uKqKi10SEljlHd20G308UDOsfdAFw8uBOAW0xJJBJJVFhuFixYQGVlJePGjaN79+6kpKRgNpux2+0MGjSIlStXctVVVzF9+nSMRiPbt2/n66+/JiUlJdJLl0haLorVZsSNEKfvd2nJzuMAXDCoIyajAbqNg03/hcOrdZ0H4LwBYo5dxyrIL64mp12i7nNIJJKWRcTFzeWXX05eXh7du3dnzpw5XHbZZVx55ZWMHTsWk8mE1WqlV69e/Pjjj2zbto2amhp69uxJt26Nb74nkbR5Tu6GA8vBYIQxt+k6tNPp5PtdJwCY2L+D+GO38eK24BewWSBGvxiOtEQzw3PS+SWvhFX7irhujPxtkEjaOhF1S61YsYJ9+/axYcMGPvvsM/7+979TVFTE3Llz+emnnwAwm80AJCUlMXbsWM455xwpbCSSpqJ0/u57MWTo6wfffbyCo2W1xMUYOb1npvhj+16QmAl2CxzdqOt8AGf2EfP8sPek7mNL9Ke504LbAvI99Sai4iY1NZWOHTtSXV2Nw+Hgggsu4PbbbycxMZGFCxdSUFAAwLvvvsuKFSsiuVSJpPVgqYBNC8T9Mb/VffhlLqvN+F7tSYg1iT8aXK4pCEvczVkucfPjvlPYHTIWL9oJZ1pwW93kmzvVOtqJqLjJyspix44dvP322+7qw2PGjGHatGls3ryZXbt2AbB582YyMzMjudSoxWKz89aPh/jzR5v5+3d7Ir0cSUtgywdQVwHt+0DPc3Qfvp5LSiHX5ZoKQ72boV3TSYmLoazGyrYjZbqPL9EX37RgPQVJW93kmzvVOtqJqLjp2rUrr732Go8//jjvvfceIPz15557LgMGDOCdd94B4Omnn2bQoEGRXGrUUV5r5eb/rOXXb6xh9/EKhnRJZ+XeIvKLqyO9NEk043TCL64GmaNu0bVoH0BFrZUNh0sBOKefH3FzeDU47LrOG2Mycnqv9gCs2lek69gS/fHtUK2nIGmrm3xb6/rdEBEPKJ4yZQrHjh3jgQceoLq6mltvvRWAzMxMqqvFRh0bGxvJJUYd76/L552fD/Gr0d3o18mT5XLT+Fz+9MEmPrj9dAw6b1qSVkLBL3B8K8TEw9Bf6T78mgPF2B1OurdPrJ+11PE0iE0BSxkc3w7ZQ3Sd+6w+mXy74zg/7ivirnN76zq2JLzccU4vXl2+XxdB0tz1VCTRScTFjcFgYMaMGaSmpnLrrbfyxRdfEBsby3fffcfKlSsjvbyIY7U72Hu8kuW7T1BUaeFwcQ1VFhszz+tLaoLZ69jstASykuPYXFDGsJz0yCxYEt2sd1ltBk2FxHa6D//T/lMAjO+t4UY2xUC3sbBviYi70VncjO0pLDcbDpdQZ3MQGxN1ZbwkfpCCRKI3ERc3ADExMVx33XUMHz6cn3/+mZqaGp566in69esX6aVFBIfDyfzVeazaV8Tx8lp6ZCaRlRJPp9R4hnfLoGOq/6rMxyss9O0YoVL+kuimtgy2fSLuj/xNWKb4ab9wCY13uYjqkTteiJtDq2Ds7brO3TsrmYxEMyXVVrYdLWNEtwxdx5dIJC2HqBA3Cv3796d///6RXkZEcDic/HfNYX4+cIr84mr6dUrhktOy6ZyeEPQY5TVW4mKMJMZG1ccqiRa2fAC2GsjqDzn6dyEvqrS4+zud3tOPuOl+lrg9tEq0fzDqZ10xGg2M7t6Ob3ccZ93BYiluJJI2jLTbRpgqi42HP9vGlFdWsTm/lIn9snho8gCuHZUTkrABWHuwmDE99Hc1SFoJG98VtyNu0j2QGOBnl0tqQHYq7ZP9FOnrPBzMSVBTDCe2674G5fxfe7BY97ElknAS7hT2tpYiL8VNhHj7p0PcMG8N099YQ1ZKHA9dOpBrR+fQrX1So4OBNxeUctuEnjqvVNIqKNwChZvBFBuWQGKAnw+44m38uaQATGbIdfWZOviD7mtQxM26Q8U4ZL0bSRTjKzbCncLe1lLkpbhpZo6U1jD9jTWsPnCKG8blMuuSAYzr2R6jDlfSVrtTuqQk2mycL277Tw5LIDHAGpe4GefPJaWguKYO6p8wMDA7laRYE+W1NreLTCLxRyStGb5iQyuFXVnf3Qs2NnmdbS1FXu6EzYTT6eRvn29nZ2E5143ppntzP7vDqWf4gqQ1YbPA1g/EfZ27fysUVVrYf7IKgwFGd28g1qXHBHGb9yPYbSKLSidiTEZG5Gbww94i1h8uYWDnVN3GlrQ+1AKjubO1fNPftTLGlPUdK6vB7qRJ62xrGWlyO2wG7A4nv5u/HoD7L+wXlq7FJyssZPmLc5C0bXZ/AzUlkNoFep4blimUGJd+HVNIT2ygLlX2UEjIAEs5HPlF97UogcQb8kp0H1vSuoikNSOYonvK+iYP6dymrC56IC03YebDX/JZsPYw43tlMqFvVtjmOVhURU6G/qJJ0grYJKp/M/RXYDSFZQpF3IwNJqDdaBJtH7Z/CvuXeXpO6cTIXCFu1ktxI2mASFsz5q/Oc1tvtNYR6fW1ZKTlJozM/X4fH/5SwG0TeoZV2AD8uL9IqnpJfSqOi7oyAEOvD9s0a1ziZkyPBuJtFHpNFLf7l+m+lmHd0jEY4HBxNScqanUfX9J02lrmjj/aWpBvcyLFTZiY98NBVu45yR/P60O7pPC6i05VWog1GclIkm0qIo7DEekVeLP1Q3DaoetoyAxPS4Kyaiu7jpUDBF+KQBE3R9ZDtb5p26nxZvp1FG1JNuSV6jq2RB9a1Ka+bh7MGSxudaatBfk2J1LchIH/rs5j0daj/GFib2JM4X+Ll+85yTn9wmsZkgSgvBCWPQXvXAFvng9vT4Hig5FelWDLQnEbpvRvEGnXTif0zEwiKyVIIZ/WVRQTdDrgwPe6r2mEyzW14bB0TUUSfxaaFrWpr5oDZfni1oemWqBks8vwIcWNzry0dC8fbyjg7kl9iI0JT3yDmhPltew4Ws4tZ/QI+1wSF3XVsPZ1+OQ2eON8+OqPEJsIE+6DyS/C2Nvgiz/AF/eAtSZy6zy+A45tBaMZBl0ZtmnWHXLF2/QMMcW8z/nids+3Oq8IRrqCin85JIv5RRJ/Fprp43L5cdJBpv88WXeLiO4urzNnQlqOuPVBTwuU1rrD5b5rC25BGVCsE06nkwc+3kpZTR33XdDPr8XG6XRyosLCq8v3U11nw2p3YrU7MBkNvHDNUMwhWHrKa6z8a8V+XrtxFEaj7AIeViqOw7o3IH8NOGzQeRj0uxgyetSv9puWAxc8CXmr4D8Xiz5OI29q/jVveV/c9r0wbLVtwBNvM7p7qOLmQvjpZdj3HTjsugY7K5abbUfLsdjsxDXDhYakPgG7fastIqNn6DLf/NV5PPL5tianTXsxeobf9enZzdxXKL26fD9VFhulNdZGvZa7F2xk0ZajTB7SmZeuG+53rtZqNZKWGx2otdq56c21JMfFMOPMnprC5oXFu7l7wUbu+O8GnvlmF06cZKXEkds+kQHZqXRIieNPH2wKuqpqnc3BK9/v4+YzetAlxDYNkiBxOmH92/DO5fD5ncI6c/YDcNFsGDIN2vX038bAYBDF6i58Gg6uEBaej27RPb7ELw4HbP1I3B9ybdimqbLY2HakDAgh3kah2ziIS4PqU3Bkg67r6t4+kfREM3U2BzsLZTG/ZiOU+JQAFpHG8ury/didYDIQlOAIxYKhdez0cblugdNUK4jaVaeIDyCg+y7Q+hdtOYrdKW4DzdVakeKmieQXVzPttZ85q08WFw3uVO/x5xfv4vfvbaCgpJoemUkMy0mnX6cUstMSSIk3E282YTIaaJ8cR7ukWO77cDNOZ2CB43Q6eWPVAS4e3ImrR3YN10truzid8NMrMO8CKFgH4++GSX8TQbBxIXZcj02CM+6BS56HnLHwvwfDs2ZfDv8M5QVCPPS5MGzTbDxcis3hpHNaPF1DLUVgMkMvV92dPf/TdV0Gg4HhOekAbJJxN82HT3xKQLfN6Bkwc5tuVhvwbNqPXT44KIuEsr7CJXMbFGX+Xoteril1/I3yOu67sF/AmJxAc08e0hmTQdz6mwtolHuqJbi1pLhpJPnF1dwxfz1/+mATvz2rJ0NdP6QKVruD+z7cTH5JDb2ykumfnUpCbGDTeHZaAhabg+KquoDHfbrxCN3aJXL72a1XdUeMsgJ49wo4tQ8ueALG/BaSMps+rsEgLBXlR4WLK9woLqmBl4E5PmzTrD0oWi40umFrv0vE7e5vdFqRh+GuuJuN+aW6jy3xg481JhwWgvmr83j+yT9T+Ux/WDfPa6MNNUDXvb6YL/wGDdc71ue1qP+u16Yf7OsI9P6+dN1w9s+eXM8lpaaxwqwlZLvpHnOTn5/PI488wptvvqn30FHBkdIaHv5sG3U2B5cOyaZnVv0r+RcW72bviQq6ZiQGnz2CqGTscDr9d1QGVu09KXywvx7RqPVL/FBTCov/CiUHYOwdkBEmP3T2EPhlHpz7l/CMD6Ldwo7Pxf3TrgnfPKjibRorbvqcDwaT6BBecggyuuu2tuHd0gFhXZI0Ez7xKU0tQqdV5O7V5ft53/oxybYiWDWHF8pzKK2x8sLi3ZpzBSqU517fuvuFsAngIvP3WtTrakqMjD+CWn8jaWzMkJ6xRuFCd8tNcXExb7/9tt7DRpySqjrunL+eez/YxEWDO3H3pD6awubhz7dx8FQVgzqnhSRsAE5U1AZ8zsbDJaw7VMLc60c0unO4xAeHA5Y/A/OvhK4j4cLZ4RM2x7eL7twT/hye8RX2LYXaUkju5GlSGQZqrXa3VWRssMX7fElsB7njxX2drTdDczzF/E5VWnQdW6Iv/iweWhaCO87pxQLzVVTGZwcVr+PXyqCOD1K5yAJZXxpaJwSOkQlmrKDXrwONTUVvCSnsIVtuvvjii4CPHzhwoNGLiVY+2VDAvFUHmTYqh/7Z2o34nE4nf/54CzhhcOfURomPE+UW5kwbpvnY9qNlLNl5nPm3jsUkM6P0YdvHsOY1UeDukufBGMbkwYpCkW11w2e6NorUZOuH4nbwVWFrtwCwOb+UOpuDzOQ4emUlNX6gfhfDoR9g1yIYd4du60uNN9MrK5l9JyrZlF/KpAEddRtb4qGhFgLB4C97R8tCMH1cLox7DngOgPvseQGtCH6tDKr4oPn289zHBMok8n1Mee3tk2I5VlbDhL5ZjOnRzi1ElOf7s0DVm2fdPI8FyWUB01p/qO+5Hp9RU1GvAQj7ekK23FxxxRVMnTqVK664QvPfn/70p3CsMyJY7Q4e+mwb81cf5p5JffwKm1qrnbsXbiQuxkivDsmNEjbFVXUkxpqIN9ffjIqr6vhkwxHeuWWsTGnVg7oqUYNmw7si+2nIteEVNrXlsPxZuPo/EB/mLtWWCo8FZEjzuKTG9mzXNEuiEneT95Pu2WRKULF0TYWPkC0LGhlVWrEjwW7I0wse50fL1Zyx6QFNS4hfK4MqPkj9GgLFsfg+pjxv+9Eyd2bSC4t313s//Fmg1GPNX51H4aLZ9WJ/tIJ/Q33P/R3fnIHB6jU0R8xOyOImOzubTz75BIfDoflvwwZ9UzojxckKC1e/+hNpCWYeuKif307HxVUW7lm4kc5pCaFni7iw2R0cOlXFU1NP03z8nZ8PcdPpuQ0GJEsawOmElc/DW5dCVj8471F9goUDYa2GpY/D6XeGz92lZtcisNVAu16QPSysU60+IIKJxzU23kahXQ/oOFi0idirb0G/Ya64m00yqDgszF+dR5XFRnqCOfj4C5fFpHDRbPemqiVANDdArVTz7Z+C007OscVBbZjuDd1+ntsVpRYaWmtRngN4PaY8b1DnNADsrkRXX3GkJZh808hfXb6fV6yXUUhWgwUDgw3UvnvBRnrNWkT7pFjN4xsSGcrrvnvBxiaLIPWamyMVPWRxM3LkSNavX+/3cYPB0GAqc7RTUFLNzf9Zy03ju3N23yy/V6XPL97Fg59spV+nlCb1dTpQVEWP9kmaVpt1h4rplBrP1aNyGj2+BKg8Ce9Mgaoi4YLqfob/GjV6YbfCsidhxA1hD+x1s+UDcTvk2rC+vjqbw93aYGzPRsbbqFGsN7u+avpYKoa5LDebC0qDriElCZ5Xl++ntMZKUlxM8O6FM2dSSJbYyAOkYGtugFqtEAZNBYOJ/E4Xam+YPoLIa0N3PTbdtKRRKdeKEDrlynA1GdBM3/aXeu0rWJanXMbSi5Zqpsc3JMDUKKLky82i1s32o2Wax2tZj7TWt2jL0SZbWtRrbo6YnZDFzf3338/48eP9Pt67d2++/17/XjHNxScbCvjdu+u585zeAS0xTy3awYGTVQzunEZibONdGmU1VuwOJ7MuGVDvsZo6O99sLeTpK7UtOpIg+fkVWDBNVAoedr2or9Jc8/a5EEbc2DzzVZ6EA8vF/TCLqS0FpdRaHbRLiqVPhxBr/2jRf7K43bdU15YV/TqmEG82UlFr40BRlW7jSgSNuQJfc7AYJ04SzKaAKdiaG+CZMyE+A+oqPYLo6nnwSDE9frdQe8NUC6J181jMndyVvEKsOUDfKIW7F2zkaGkNCWZjwLgepb4O+K8d4yuS7jinF+kJZqosNsBjFVKLDH9Wo0Ao88SbTX5r3UD999h3fSNzMzAZYFDnNE23YTTXuglZ3Jx11llcdNFFfh9PSkri7LPPbtKiIsW7P+fx1k+HuHtSH79ZS06nk798upXj5RYGd0kjNqbxCWd2h5MDJyt58orBmo//d00eV47oqmnRkQRBdTG8OxVO7oGLnoH2Qf4AO+zwv1nw5R9Fj6jP7oLFIaZu7/gc4tPhjLtDXXXj2faxcO10HhH8a20kiktqbI8mxtsoZA+F1K7CjacINB2IMRk5rYtwGUjXlP74bo7BbHjddrxGZ4r4AwtINtQKsRJsleLRM0QhzZqSgILEC3XtnVVzSK4tZLrtk/qPaTB/dR5fbD6KE2GtDEVYKAJB/Z6oxYxSlycpLsadPq41hnL/kc+3BS0kFLH118kD/Ne6CSL2aX1eCXYnnKqqC+w2bGLn9HAIJVnEz8W/Vuzns01HuPd8//E1tVY79yzcBMCA7JQmZy3tP1FJt3aJpMTXtyRsPFyCyWjgljNlQ8xGseFdkd499DrxgxgTRFp+xXHRDPO9a8WPp8kM5kSIT4OTu0XDzGA4ukn8m/xiU15B6DRDB3CFn13i5vReOrikQLjQ+iuuqUX6jOliaNd0QGR3ScJLMIGihwfeTiFZxMUYxfcsLlm7SvFHM+CxduJWTahtG0bPYP7pizhjaQ/WdLnJ7RJ7dfn+Bqskq1+HP+uH0s/KXzyMb1aUr5jRsn75xqeYDLj7ZQVDUG4fDauV7/P8WebqxVoFYQELhBKE/cLi3Y16vhZS3CDe2JV7TvKn8/v6Ddqd890e7lm4key0eLq1S2zy1erJCgsY4K+TB9Z7rLLWypebj/LitcOaNEebxG6DRX+CnV+Kvk5Z/Rp+TkkevD9dPC8pE3LPEM9L7QwpnSA5S1hCFgWRCVh+FDa8A9PeBWMzfr1O7oGjG0VBvDB2AAew2Oz8ckjE24zTI95GQXFN7f5GWM90QgYVNx/+sp7UV+Vjr72f7Ef3Ed//AnG+5oz1GkM53rHtE2GJ3P6p9+P28xhW/iLDvs4J+kpfERh/OjCSpRctZXnKZYzMzWjQWqC8nievGOxl/VC/Jt9+VmqBsOaD5/mw9rfcGv+9u4KxbwC2lhBRx+i8unw/k4d09isyGm3x0BCJvgHEoO0KU2KtKmqtfseKNG1e3Dy5aAe7jlVw98Q+fjtyv7B4N7uOldM/O7VJgcMKVRYbR0prePaqIZqPz19zmOvHdpPZUaFSXSyChpM6iArAsQ3UXvn2YVjwK/j2IcjsA11HQVKWdiBuTHzDG67TIa5crn6z4bn1RrHa9D5PiLEwsulwKRabg8xkneJtFHLPEFay6iLRfV0nlKDinYXl1Fr1E02S+gSd9QTiM3ba633WyvFLjGe4xPrUeo+X1ljruXIC8WLP9fwcfw8v9lzvXuP6vJLAVqZ185j+82R+nHSwXuaUYql5YfFuLq79mp/i7+a94TvqiQDFBTeDz5g+LrdeAHZD4kR5L9bnlWhmcKktRiGjYbUKNoC4njWpiX3C7ruwn7uXll60aXHzt8+3cbSkht+e1QOjHxfTU1/vYN/JSgZ1TiNBh9gXm93BnuMVPD31NE0xtXz3CRJjTVw/NnorP0Yl2z4RbqhRvxFF4QJZ1sqOwILrhRm10xDoMgLiGqg/U1UESQ1YKXZ+KartNkfKtxqHHTYrLqlpYZ9OcUmN7dle30rZJrOnyaeOrqku6QlkJsdiczjZfrRct3ElPviJu/AbdOxzta9s9CNzM+iSnsCJC+bCI8UiYNhnvASzEQMi4DUYxh55m2xOMvaAJzurwWBoP64WtaUG4Gbnp3SmiLFH3vZ6HfNX57ldcIcH3u71XihWo6cW7QzojvG7xnXzmPS/SfzKuASTgYBWqFCsO8p8/ixFCtPH5fLY5YM1rXTDHvuWYY99654vmPnDkT3VpsVNQqyJm8/o4fcH+uHPt3GsrJbTmhg4rOB0Otl1rIIemUm007AArTlwim1Hy3npV/4bnUk0+PElWPtvOO8xyOzr/zhLBXz0G/j6PujQXwSxmhOCm6OmGCb+zf/jVUVw8AeY+HBoa9eDgyuh/IiwevSbHPbpft7virfR0yWloLimdi0SdYl0wGAweFLCpWsqfPgRA343Lp+rfS8rxaSDTP95smaA6vRxubRLisOJCHh1s24ePNsdnule73lKrI3F7nCvscEN9cyZVMZn83zVJV4bszqDCOAtw1SvVhBqS5Xigtvb7VovN49iNVJbEtd88DyFj/bm/VcfbbgR6Ko5ZHOS35u/5LHLBwe0QjWmYN6YHu0aFBv+rHS+VrVINdls0+Lm/ADl2P/yyVaqLTYGZqfq1u7g0KlqMhJjefDi+mnfm/NL+XH/KebdNMqvFUmiwbcPQcFauOApSEjXPsbphK9mwoc3Q0o25IyBuJTg57BZwAnE+ikN4HTAqhfh9LvC2u7AL5sXiNvBV4W1Azh495PSLZhYTe9JYIqDkoNwcpduwypBxTLuRj/qXZG7xMCTZRd5XbkHyx3n9OKu5BUs5k5Y9oSXUPKdy29135oSqK2fSbVyz0nsTif7bVmacT5AfcvT6BlcyD+ZW3m218asZBBtP1pGaY2Vb+IvIfnBXcy3n+dleVLWdveCjTz0mceNpT7msqGd3e6YbjteI5uTnHHsXW8xoGURyxkLBhPZg892FwP015k8lHT9pgoRJRtMHVPU0PzhSikPc5OblofT6eTBT7bicDrp3chWClrkF1djdzh5/MpB9R4rKKnm662FLLhtnN+4H4kPTid8fhcYzXDWff7dUEsfh+PbILG9cBkZGvH+lhVAeoAiilveFz82g64IfeymUlsGO1z93ob9OuzTbcgroc7moGNqHD0zwxBXFJcCPc+BvYtFQb8O9S8EGsNQVTE/iT4oG2Hhkrnw89dw5kwu5J8cqa0BQu+MPX1crhinrFCkh6tcVspcHb69Cxb/xPRBU5n+oGezf3X5fnZaL+PP5g9IizfXC2y9I+YLkm1FOJzFgEM7pktteXJZk0bmZnCsrMbL/aVUFR6Zm8H6vBJe7Lke5txNYdUlHKk8m2NlNTx2+WD3a1+05ajXNEqDzR8fnMj81Xlu69Phgbfj3PEv3nBe7iUOahc/SrytnNJFD/OV/Twxrk+8kro7+BnPLPPKzgqlc3hTu31rzdXQ/IF6eTWFqN9Jn3nmGR544AHeeustioqKwjqXw+Hk3g83YzBAryz9hM2Rkhpq6uw8f/WQemMWltUwb9VBXrthpKxnEyx2K7z/a0juCKNv8S9svpophE2nocJd1RhhA1B5HC58Svux0nw4viMy7igQtW1sNZDVH7qMDPt0P7lcUuN7ZYavM73aNaUTiuUm71Q1Ja5qspKm4b4iVxXia0w8jJdlQonDmfQwzNzmZQ25K3kF5zt+0MygUqr7fnnRT/DgoXrdvZMn3Q9pORgHX+k/q0cj40ex0qjdX4qlJGf/AhZzJ2MPzoWyfO6I+UIzZXvykM6YDDDEVW9JLVx8XVjXxL/OW3WTvCo+W2wOQFzPuWNzAmQnNaW1QSS6fYerFUNUi5upU6fy1Vdf0aFDB2bOnMmiReLHLtT2DhaLhfLycq9/vljtDu55fyOp8Wa6t9fvivRoaQ2VFhsvXDu03mZQUFLN6ysP8ObNo+mQGl53QqvBWgv/vSawpcRSAQt/LRpk5ozz704KhtpyUevG5CdLbv1/YMxtTWp1YLFYqKysbNyTN84Xt8Onh7+dBKr6NuGIt1HodzFgEKntZQW6DJmWaHZbmqT1JjTKy8uxWCz1/q5shIpw4MyZ7niY601LmLX7Go8rJVCRN1+LycxtANQ+mcPkb07nnIovWZ9Xwv3mD3Cf4T4ZVA1mabnGnd/1b5xheUn0lfJFI+PHt+ieeuzrrB+TXFsoXNZpOSRPul8zyPal64azf/ZkTlXV1WtV4buxa230uwb+kQJnJi/YRLLA/NV5nLG0B/NPX6SZnRSMQAnWFdQcVYjDJaiiVtz85S9/4eTJk6xatYp7772XMWPG8MEHH3DixAmKi0PrHDx79mzS0tLc/3JyvF0MNXV27lm4kY6p8XRK009k5BdXU1Fr4/+uHYrRZ+PJO1XFf348xFu3jKGjFDbBUVclMqL6TxauCy0W/xU+vEk0Y+wwoOkbfslBMZYWx7aKIN4BlzZpitmzZzNmzJjQn3h8BxxZLzqaDwl/llSVxeYOyA1LvI1CcgfoNk7c19N643JNybib0MjJyWH27Nn+D/ARBXec04vfm78km5Oe2JdARd60rBCr5hBvKyfDUMUdMV8I10+Ny3oSkwhXz3NvvGs+eF4Ip49meAUUK0JBuI2EsCpcMpf3a34rXGlBUK/onkukvdhzPQvMV4lAYpeVidEzAm7U/ppnqo/Xev7Ya+9n+cXLWJ5yGfdd2E+XAN1gi+bpGQysNPG8e8FGr7+HS0BFpbix2Wz079+fjz76CIDHH3+cpUuXcu655/LKK6/wyCOPsHjx4qDHmzVrFmVlZe5/+fn57sfKa6zM/GAT3dolkpkcRBXbIHA6new7UYnV7uBFDWFz4GQl767O4+1bxug2Z6unplS0UhgyTQQE+6LE4JQcFNaaRB02X7tNCKrzHtWeb8M7cPHzTZ5m1qxZrF27NvQnbnxX3Pa9SAiCMLPuUDE2h5OuGQnktGuCNSwY+rsE484vdRtymBQ3jSI/P59Zs2YFffz0cblkT57lLVgCFXlTWWvU7qnamFTKSMaaPZqxO1RuYYM4rnDJXI6U1tBtx2tCOG3/1CugWBEKw/a+DGX5lC76GzP4jK6GIv5ke53nn/xzUBvqyNwMDEBxlYXKpc9DWT5jj7zN/Q89R/KDu9yiTtm8p7y8SnOzDtaiok6l9u0rBYTehV0DxdWl3PojkMsoVFGyaIto4ukbg6QWUHoKnagUNzExMUyfPp0OHTpQWFhIUVERe/bs4b777uNXv/oVdXV1fPXVVzgcgT8Yhbi4OFJTU73+Afxj6V7u+2gzvbOS/bZcCBWHK907wWziuavru6IOnKxkwdrDvHvLWM10cIkGFcdh/lUw6hboPKz+47Xlwg3ldEKXUfo1xizeD+l+foj2fitiXBqqfRMEcXFxJCeHWAzPZvFkSY24qclrCAbFJTU+nFYbBcUalveTSLPXAbW4CdW13ZZJTU0lLq6JF2HBFHnzse7EJ6WRNvlxetRsQ/h+AAwim84V49IlPUHUkEnLgewh4vGYRC8RpaRbO51O5nEFDoyYcHCd9eOgNtT1eSU4gRqrg1dtU/yKNGXz3nKkLKC1I9B8vqnUvv2bJv1vEpPrvqnfhT2I3k7qeeNcpU3iGihxosQXKe+T71qPlNbw1KKdmhYZX5TYI982FmoBpaelKCrFDYDRaMRoNJKdnc3zzz9Pz549sVgsDBw4kOHDh7N69Wrq6poWGJh/qprTuqSRHK9P0pjV7mDbkTLaJ8XyhEYzTEXYvDNjLGmJzdSZuqVTmi86ep9xj3bmzLcPw0c3Q2ZvUWVYr7iTuipR2+YSDctMTanI5jn/CX3magy7Fomr1JTOIn26GVit1LdpDnGT0V3UIXLadXNNDchOJS7GSGm1lYOyQ7h+aG2sjek15NPg0v38M2dCQobIoJr8f8IN5Ipx+fHBiYy99n4hnKqKAKfngsO1pl0D/8hRMplruJ7s8+5iifEMbE4j6x19/W+oqtekTm/OPu8uvyJNqXvTJT3eq1CfP1GgtYH7plJ7WU5UtW3qWVKCeL/VLrlQKgL7W6+ytlqrXdMi44sSe+TbxFNt0dIzuDjqxI3WFVVsbKzXbVlZGT179mxytsaAzim6pV5XWmxsPVJGj8wk/nZZ/XTv9XklvP9LvhA2CVLYBMWur+CDG+DsB+pX/VXcUKf2CTdUQpCZGcFyfAd0PE1bLK17XQQRmyJYSUFxSQ27vllq65TXWtl6pAyA03tmhn0+AAZeLm53fK7LcLExng7hGw+X6jJmm0YRAEufqL+xqoWKP6uCRl0Zt3BQP3/0DHjgkDsLyq8VyI84Gnvt/XR+dD8PPfoC08flMj52HzEGBxOMm7lkyfncnbbSXeVXsW4o7ifFvbXpkQvY9MgFTDct8WshOeXOwjMEbO8QaANX5prQN4tHPt/G2oPFHleW6/VlT55V37Wleu3+LEN3xHxBV0MRd8R8EXQQr1YvLPVaf3xwIpcN1bbINAY9g4ujQtwsWLCA119/na1bt2pmjSgiprCwkLlz5/L888/z17/+tcmmUr1SWU9WWNh/opLnrx7K/Rf2r/f4oi2FrD14ioW3jZPCJli2fgQr/0+kWKf6fGmUbCinE7qO1s8NpVBdLITLJI307rIjYK1plgBev5Qehv3fi/vDpzfLlOsOFuNwQo/MJF2D7gMywCVuDq4Qn4kODHc10dyYXxL4QEnDKALCQH1XjVqA+LMqBLI2aAkY3wrEwYojn+7iyZPup8ApBHo723EmHJ/vTvdWrBQ/1fXWLvbnWnPhotn1xUMQmU9Ko03lb/7cU5rxKYFce6rHfC0titjZ3nOG2+IVLL69sLTwZ5FpLHrF3URc3Fx++eU8++yzLFq0iGnTpvHkk0+yZo2nwJJiybFarcydO5dXXnmFJUuWMGSIdtPJ5sTpdLL/ZCUlVXW8fN1wTeHy1ZajlNdaefPm0cTFyDo2QbHxv7DmVTj/MdGlW82SR0U2VPte+rqhFBx2OLEDpryi/fiGt2DEjfrOGSqb3gOc0P0s/5lcOqO0XNC1C3hDZPYW1jOHDXZ+ocuQw7sJC5+03OiAIiAmPlw/INj3uPgMqKsUAkM5xlVlV7NasIJawKya4wkYXvpE8OJo+6fCvbntI3g0HfJ+4rn+H/F/tmkUx3Tk8MDb3SJEESTjY/eJ5+xf6pl/3TyqKkopcSbxivWyehaZYDKfFOHxwuLd7qaXj3y+rd5GrsSnDOqc1uBG31BFYnVHdH/iSKsnlNZYzYFecTcRrVC8YsUK9u3bx9atWzEajXz77be8//77zJ07F7vdzvjx493WFbPZzIMPPsjvf/97srOzI7lsAOpsDnYdKycrJY7HptSPr3E6nXy4vgCL1c5L1w0PX8Gz1sa6N2Hr+yKexbez9qI/QWkBdB0DMWHKMjuxUwineI1Gmqf2ix9jxV0SCRwO2PRfcb8ZRZYSTDyuZ7tmmxOA066C41uFJW/kzU0eTrHc7DpWQXWdjcRYWaS90SguIhCb/9f3C0GgqvDrFiV2C1irhcAAjyBRqux+NAPHtk9YYjyDExfMFe6fVXPAUukRM4AwEznFTc5YKD9aTxzNX53nTnG+78J+TB801TMvTtj+KS89Mg8YDsxhLPCj6vnTTUtgaa1wdTvxElBJjgriMXBfzPtM6dkZmOh54kcuITVoar1mnwpKjE9xVR2/Mi7hjpgveNU2hVeXJ3iJoDE92pGzfwG/PvUxc61TeHX5ZX4tJ74VfpV/6kakytzK+6NYj5QxFQuNcl+3mjPK56+4F4OgqVWSFSJquUlNTaVjx45UV1fjcDi44IILuP3220lMTGThwoUUFIgCXu+++y7Lli0jJSUlKoRNWbWVbUdFfI2WsKmz2Xnl+32kJ5h5+foRUtgEy5p/w/ZP4LzHvYWN0wEf3SICebuNDZ+wqTwJ9jq4+Ln6jznsojnnRc+EZ+5gOfSDcEvFpcGAy5plytLqOnYUisKXYS3ep8Xgq8TtoVViI2si2WkJdEqNx+5wsjm/rMnjtWl8rSpOOzaMrOmiyt5TrCvWas/fDCax2akaUzq2fYIRBxPtP4ordl+Xl90iRE5MgsdatH+px7qiWk/hkrnezRtzxwuhYjQDhnoFAH2pXPo81JZQ6Yx3By8r67VjxGRwkmGocncBd7vLtn3kVT1Zy72iWHPiYozuGBitAGGlSGBntB9X48+64tWIVLEguTKuzqn40ssyotUTSj2Gv2DrBmlEYLlecTcRFTdZWVns2LGDt99+G6NRLGXMmDFMmzaNzZs3s2uXaJy3efNmOnb03+SyuXA6nRwqquJIaQ1/v3aYZnxNWY2V5xfvZkKfLB66dGAEVtlCWf0v2PUlnPeId/NHex28fwPEpUKn0xrfQqEh6iqhaA9c+W/tx9f+G3pNrB/Y3NwoVpvBVwbf0byJrD5QjNMJvbKSmr+Sdno3ETCOU1hvdGBkd3El+8shfeJ42iw+GU2FZPGI9Wbh/lBQXE9GxWVvEBmILquP0phyl6EnTmCPsafYXJXn9ZokhIVV9GPCHOdxrSi5JzWlHoHlShH32qgVd5bTIbKt/FhVFF61TaHAmSnSvtXurdEzME1+QbjYEjI8MUbK+Aou8RTIvXLfhf14yzCVo2RyeODt7o1cbW1RigRqBhCr8CcGNEWPn4wrr6Bp1Tj+xqAsn8qlzzccGxOovlGYiai46dq1K6+99hqPP/447733HiAExLnnnsuAAQN45513AHj66acZNKh+BlJzYrHa2VJQRlyMkX/8ahiJcfXN2aXVdfxjyR5uOL07v53QMwKrbKH89DLs+R9M+pt3mwNLJSycDmldwysqHDY4ugkun6stGPJ+Fsec/efwrSEY1E0ymymQGGC10nKhOVLAtRj6K3G76b8iiLyJjO0hXGtrpbhpGj4bV0p8DGfH7RVdvZWreqXBY1yyOHby/9Vrb9AlPYFucVUYgIGpFq/GkJX7fqRs0d8QSsYgLDaK5aD3JCGAcHpcH66AWa+N+syZ4jjFZdYAE/pmYTIYmNA3S/xBbakYPUNkbT1wyPM6XKnqtTGpPB9zO/O7/s3rtflaVBS30EeGC5hrnSKKELreL7W1xbdIYKho1qhxvUeHB96uWbtGa4x6wsk1xqu2KQ3HxgRT3yhMRDygeMqUKTz++OM88MADvPHGG24XTmZmJpmZIphUSQGPFCcrLOwoLKd3h2Qeu3ywppuppKqOl5bu5ZYze3D1yK4RWGUL5aeX4cAK8aOlFjY1pSJwOKsfpHQK3/xOJxRuFo01UzSsg9WnYMtCmPJy+NYQLNs/E00yM/s1S5NMhZ9VzTIjwuArhTvi5C7RbqKJjHGJm/V5JVjtwRUClWjgkxGVXFvIBY4fRL+lVXPEhm2pFFYOJejYZ5ObPi6XHycdJNlQKywiyhW+y3LzU11vHIqgTUj3zr7KXyOsQOqUcSUN3NdlEpfqtrY0lI0z6MA8sjnJoAOuMTRcK15juFLVJ8W8zdzKs92bfT1hoHKbKZ3B3W0qvr7fq2WEWxCphVUo7iAX9axHrs/sTwdGNj5o1zVG9nl3NXuwcShEXNwYDAZmzJjBc889xz333MOUKVO4+uqrefnll7nppuapvOoPu8PJ7mMVlNbU8cr1I7j3Au2CR8VVdby0bC+3ntWTK0dIYRM0G/8Lu7+Bc2Z514yxVMLHtwo3VGKYA1hP7BA/qhdp9M6pKRWBjGf+qdlcQAFRXFLDf90sTTIBTlVa2H28AmjmTCk18WmeIO4Nbzd5uL4dUkhLMFNdZ2f70fpNdCUhoGy4ihsJPDE1q+aIOJlYV/Vt341Zee6yJ4RbJy5ZbJzr5olu9047E4ybecM8XfRwmugqzaDOsvK1DGjFeLjWUVgTw3z7eQ1m43i5pUDTtaLVoypgZpEScK2qrHzfhf1EmwqXValwkfgN8hJE6tcTIH7Fb20bnzWp3V5NFSaR6CAeChEXNyDaLVx33XWsX7+eqVOnMnHiRNauXcvQoUMjtqYqi40tBaVkpsTyf9cM81vsb9excl5etpfbJvTkiuFdmnmVLZhN74mNauJD3sLGZoGPfiOqEcenhXcNxQfE7eUaVpnaclj6OJxxNwycEt51BEPRPnGlajA1a42d1QeE66Z/p5TItgsZ6brQ2fJhk2veGI0GRnd3uaYOnmrqyto2WlYUpaq3YrXxrTjs+1wnXgXoxCYvrDXxZlN994zi6tr+qXbauW+Mhyse6BXrZRQumcti7uSu5BXa1hE03FIqAaWIgzsd79HVUMQfWOCeJuBmv/QJsWYM7srK08flirEved69vnqCS/16lPs5Y+sJRX+CzXdNmkHGAQh3V/Bwjh9VeZD9+/enf//6QbrNzbGyWo6X1/LsVUMC9pz65VAx3+8+wfu3n06yRgyOxA+bF8L6t0RDSnVWlMPuqmHTO/wWm7ICYZm59p36j1mrxdXkuDsazKxoNjbNF7e9zwuvm86Hnw+Ivk4Rs9oodDtd1Lw5vhU2zheiswmM69mOJTuPs/ZgMbdNiE6zeosgZ6z4LlW7RKK63k1tidiM1VYVH9HhlSbsyuRZa+/DOaYaUTdMsdYoKK4uDPXTzsE7PV31t6X281i+fD+LuZPk2kLuT/gAfv4aTPWF19idswE72UfeBjwF7+avzuORz7dhd4It3iO+gkIxtCquNT/rq2dJ8X09o111gpT1qjqxB5M+HWqatW+aud6Ec/yosNxEC4obqqrOxivXjwgobH7Ye5Kf9p/iv7eOk8ImFCqOwZp/waRH6tex+ewOSO4U/g7XFcegohCu+U99905NqehXNfwGOO3q8K4jWOw22OS6QmzGQGKAn5qzn1QgDAYYe5u4v/Z1sFubNJwSd7PmYLGMu2kK+WsAp7gg0Gq/oFgZlL9pxcMouDJ5xpj2UtzpLGE9zfvJ87ji2qktgfj0BtsNuC0yH81g+s+TRWzPpPvF82wWIRCWPVG/bYPTjgMjT5Zd5FXU7tXl+/mVcQmr4u5mb8oY8Zxek4KLg5n4sAg6ttrd3cjV6w7JxaP02rJUuud1Pz9Aewiv43zigPwdH+4ifuEcX4obF5UuN1T75Fiev3ooJqN2TENBSTUvLd3LwaIq3r5lDLENdFWVqLBUirTuM/8k/Otqvvkz2GrDn2pddRJKDsE1b4HRR5RWHBcVkMfdCSNuCO86QmH/Mqg8Bontoe9FzTZtYVkNB05WYTREgeUG4LRrICkLyg43OS18UOc02iXFUlFrY31eScNPkGijVB9W3E+uzXLNwWLOsLxE5b4fhYhY9Cf49iGPxeGjGeJvaleV0jtp8Nn0OPaNV80YwC08MJhE/RmXq0gr/kUd48L2T70tHTO3ic7iILxfGm0b/i/mt7xRe66nVg5iI1Zq03Qq38L80xe5X1/lUo0Gu2pGz4DYZOJt5cy0vk7hkrmNr8TrGovaktBaWmjRwPHhjqsJ5/htfmd2Op0cKanhwMlKnrlyCA9N1q5NU1Fr5Z/f7+PzTUd58orBvHL9CL8CSKKBtQb+e7UQDb4CZunjUHwQOoW5pUb1KSjaC9e87Z2ZBeILvvxpke49+MrwriNUlCDaIdMgpvniXn7cJ6w2p3VNj46eaOYEOP0ucX/Vi8KN2UhMRgNnu2Iqvt91Qo/VtU18U6Ndm2W3Ha+Jjdumilez1ngsJGrRoriqXCKjcp+oF+wEb7ewYrGI864erm4I6UYRQgDZQ+rH4SjF+ZT+cYoFwzXPHTFfcGv8915F7aaPy+XIoN+5g40Ll8zFXltBiTPJ+3X648yZODASY3BwR8wX2laLYDOi/NWPCbWuTATr0ISbNi1urDYn24+WY3M4eOX6EWT4CZjcd6KSF7/bw0WDO/H2LWPonpmkeZzED04nfHizqDab7RMk7nTAsa3QeXh4u1tXFcHJ3ULYmH0K0Z3cJZp0/uo96Hdx+NbQGMoLRUYZwIjmzR78cZ+Itzkj0i4pNaNmCJdE0Z4mW2/O7S/cn8ukuGk8vpuxqo5Kl/QEss+7CwZfLawtg6/yWEgGTXX97ep6MShKttILMbfXL7hXW17PYqG4mrwaQiq1bUB899UZVVotAZTO5q6eVcm1hTyU9r96Re3GXns/yy9exvKUy7gj5gvSqKTWkCheZ0OMnoFx8gvutU43LeHHuLuFK0khWMuLv8aiQbQ6qJfGHqE6NOGmTYubnYVl5LZPZPaVQzBqpNY6nU7+t+0YX2w+ynu3juNXY7pFYJWtgG8fgnY9IWdM/ce++pOIsQlnqnXlCTi1VwQPxyZ6P3Z4DfzyH7jh0/rdx6OBjfPFFWi306FD8wXbO51Ot7g5s3eE6ttoEZ/qCSZe9iRYaxs91Nl9sjAaYO+JSvKLqxt+gqQ+vpuxa7Mce60qI+jqefBIsbdQ0fqbi+zz7mJawuv1BYPaLaXOGHLNOd9+nvemra6BE2jN4An4NeDfmuESctNNS/jxwYluUdVQBWEvGuqW3hRLSpDCSK/GlNFOmxY3z1+j3UIBRLzBP5bupc5mZ8Fvx5KWGAVm+ZbI2teFK0grfdlSIb6M7cJYzbnyuEj5vvbd+gJqz2LYuxhu+ExkMUQbdius/4+4r0PTyFDYd6KSExUW4mKMjHA13osaxt4BKZ1F7M2afzV6mLREs7upoLTeNJJgNuMQi8/5jcNQ6tsMmioCmX02cn8F6+pZJbTWPPFhT88q3+etm0flM/1FpWRlzkY0hKyH1jr8rVmJZfogQMuDIIVRJDp9R4I2LW7MpvrWmiqLjX+t2M9H6wu4emRXnpx6mmx82Vi2fCCKcU24T7vo3Od3iXo24eoXVXoYSvKExca32ebWD+H4Nrj+g/puqmhh55dQfgQSM2HgFc069Q97hdVmVPeM4NNdm4vYRFEfCWDFc01qqHnBQJFW/+nGI3qsrO3hzz2iFjOBLAqhCB91o0z1Ru4a48We6+mSnsCLPdf7Lxio/K2uUriglP8Hcs+43FQOp5NCsvzX7QmVYFxC6kKH6lgmLatLkC6maC++pxdtWtz4kl9czYvf7WFS/w68O2OsrDbcFErzYfWrYhPS6uL9v78IUZMYhngOp1PE0dSUwrT53vM7nbDmNeG7v+bt8Mb5NBXFKjHqlmYXYN/vFpYMJeg26hh6HXQdA9YqWPyXRg9zxfAuxBgNbMovZY+rErOkEfh2CNfIgtK0KAQrEtbNE99nqJ/h5Bpj7M7Z/DjpoOjW7a9goFLpt6akXuyO35RyV/fyN8zTWXrRUq+sKr9Wkka0StDEp9ChEsvU2q0ueiDFDVBns7Nw7WE+3lDAv28cya9buaINO7Vl8MGNIvMoLqX+49ZaKNoFHcLQNd3pgMJNIs37mv94ixeHDVY+L9KJp7zUbC0MGkXez8L0bjQ3e7BfdZ2NNQdFFeBz+4W55lBjMRpFE0aDSWTe7Pq6UcNkpcQx0RVY/P66fD1X2Lbw6RDuVYdFLUT8BCA3GGOy7AnczTOVDCcF38aY6vYM6mOUujt1lWBO9PSy8un5VM8qMnoGyQ/u4v6Hngve2qGkvX/7UHDH+0NZtyv13SuWKZzoJc4iSNsWN05RZfiZb3bRq0My7/12HNlpUdBDqCXjcMAHN8HoW/0H6H71R2jXC0w6xzFZa+HwahGgfPlc78dsFmGG7joKzn9M33nDwcrnxO3wXzdrRWIQjTLrbA66pCfQu0Nyw0+IFNlDYPwfxP2vZoqr8UYwbXQOIFxTtdbGp5e3adQiJZQ6LA25UpRN1moR/49P16zw6xU8rNWeQZknf404TxLbixR2leXnjpgvuCt5hXdXc380ZHGy1njfNpZIZTPp4XaLMG1a3Dy3eDeHi6tZePvp3HVu70gvp3Xw2e9EVlSnwdqPW2tEIb2UbH3nrSqCI7+IeS95wfsxSwV89zAMuKxl1HM4vEYU7lMaEDYzy3efBODc/lnRH292zoPQvo8ocrjovkYNcXbfLDqnxVNcVRe2HjptDrWl5Jnu8EQmPJoOSZmhuXOUTdYc57FgaFkVfAvxqS05agJYdZIn3c/9SV97upoHWl/O2MCvY/BVnvT3lkgrqH9jcDqVfvJth/LyctLS0ig8eYpOmWHuYdSW+PYhYYoe9Rv/x3x2l8haStOpyajTCaf2CVfYVa8Lc7OaqiL4/ikYcxsM/ZU+c4aBnTt3MnDgQPIP59H1m5vg6AYYcSNMeblZ1+F0Ojnrue8pKKnhjRtHcd7Ajs06f6MoWA/zzheb2ZVvwJBrQh7ig3X5/PnjLaQlmFl5/7kyOxLPOVlWVkZqamrgg5V+R2k5nv5S6r8rGEwiBbyhceIzRBXznLHC2qLOSvI3l5qPZgjLzaCpnnTzdfNg0b2AE2IS4aHC+s9TYoaSMqFwi/fzG5pbjwwqSYMo+3dD52WbttwkxsqeULqx9nU4tT9wyrKlQlxh61VPxmaBgnUiMHna/PrCRukdc8Yfo1rYqDHv+lQIm9gUOLeJ/vpGsLOwgoKSGuJijIzvHUXF+wLRdaSI7wLhnio+GPIQV43sSt+OyZTVWJmzZI/OC2wDBKqYG5/hckEbGm5Eq4xjwNNt3NctE4xVQXFN5a/x/G3VHJRu49hc7iJfK5BiASrcUr/9g9K0U2k14Us4XDmtIPYlUrRpcSPRicoTsHmByxwcwI3x2Z2u1G8dXB1VRVCwFjL7wOWv1B/z5C744UX41QIYGERp9Cgh/odnxJ2z/wwpzW81+XqruJo9p19WyxL/Z90HOeOgrgI+ugVsdSE93WQ08JdLBgDw1k+H+Hb7sXCssvXiLzZk9AzhSkruJALANYr2aY6j1J3REhHBxKH4cz+ZEwGDx13kT5AoFZQVMaZu2hmbrF2Hpq7SE6SsF60g9iVSSHEjaRp11fD+dBh/t3bKt8L/HgRTTNNTv5U075JDcO18OP/x+sfkr4Vf3oTpn0CqzrE9YcZgrRKb9OlBlHPXGafT6RY3l5zWst43TDHCLRmfLixf3z3c4FN8OadfB35zRncA7v1gs0wN1wt/G/S6efBsdxGTs07lOlJ6PDUmkPajGfBYO9j9dX3LzegZ8NdCeLQUcsd7x86oKx5D/QrKS59w9aoy+Lfa1JQIV5qeLqnGxL5Iaw8gxY2kKTid8MENwuXTrof/4xw2UaW4qanfNov4sYqJF24o31YKAHu+FT9sN3wenVWHG8AZmwpXvhaR+ju7j1dwoKiK2BijOz26RZHeDaa6agOt+Rds+yTkIf5yyQBG5WZQYbFx/eur2SsFTtPRsqKAd70ZJWW6qZaK7Z8KEWKtBgz151TPrXZ7aVQ89kIxDCeka4uXcAXgNiZbSlp7ACluJE3h+6egfS/oMjLwcd88KLKjjE1wc1SfEm6oDgPgsn/Ud0M5nbDpPTixHX79UfRWHW6A6sv+BRndIzL311uE1WZCnyxS4ltoQG2/iz0bzBd/gBO7Qnq62WTkjZtGMTA7laLKOn7179VsO1IWhoW2AgJZCNRWGcWKsn+p9zFqIaCkTPsTQsHiFdPj9Lbc+M6tFiMNiRN1ewYtoqkBZSvIdNIDKW4kjWPH55D3k6gU2xCleeKqujE4nXByj6c/1HmPahzjgJ9eBocdrv5PdFcdbgB7p2GRmdfh5KP1BQBcNrSFuaR8Ofch6DFBxEAsvN5T2TZI0hNj+e+tYxncJZVTVXVMe+1ndxNRiYpAFgK1VUYRLr55uaNneHcMB+1AYAje1XL1PJj8ogj69Rf/opXV1JA4iSbx0hCNWWtTXFlR6gaT4kYSOrY6+PElOOvehvtCFe0RAXiNKdhnrxPxMyYzTPsvxCZpHGOD75+G9r1h8gvRXXU4ilm55yRHy2pJTzRz4aDmLRqoO6YYIXLTcqB4P3w8QwjfEMhIimXBb8dxes/2VNXZufk/a/lyc+N7WLVKAlkIlCrF8RlCuCg1anzxjW3xN2YorpbRM+CBQ54ifb4EM1aUbthhoymurCh1g0lxIwmdr/4IAy8XtSAaYuULjatpU1surt6y+vpvlWCvE6nePc6Gc2eFPofEzXtrDwNw1Yiu0dcoszEkZbr6iiXAviXwbegBxinxZt66ZTSXnNYJq93J3Qs3Mm9V6GnmrZZAFoLRM4QLJy5ZBO8Ga0kIpZN3YwlmLL2afTbm+EjQlPc3St1gUtxIQmPjfGFu7nl2cMfXFENCCIUSlaJ8J3bAla9rZ0OBaLWw5FERYzH+98GPL6lHYVkNy3aJRpnXjcmJ8Gp0pPMwmPqquL96rsigC5G4GBMvXzeCm07PxemEJ77awWNfbsdmd+i71tZCoAaa4ZonVILpZB5ss89g1hGllg0vmuJ2i1KXnRQ3kuCx1sC6N+D0IMVE5Qlx5Rysq0jJhjIY4bqF/tPGFWEz+CoYe3twY0v88s/v92N3OBnXsx29O6REejn6Mmiqpxjionth9zchD2EyGnh0yiAevLg/AP/58RC3vP0LJVWh1dJpE/g20FSnWX80o/GCxFcg6C0YAvW8CiR8gllHlFo2WjtS3EiCZ8Vz0G+yMDUHgylWBPs2hNMJZUc82VBTXvYviBw2WD4bTrsGRt0S/NolmhSUVLNwnXBJ3TOpb4RXEyYm3AfDpotz8cOb4dCPIQ9hMBj43dm9mHv9COLNRlbuOcnF//iBn/bLQGMvfBtoqtOst3/aeEESanaTP/xZWrTGU45d+oR/4RPMOvS0bDSXi6sluNIaQIobSXDYbXDge+g1MfjnJKSLuJhA1JbB4Z9FZst1C7WzoRScThHI3OMsGC2FjR68vHQfVruT8b3ac3qvFtJuIVQMBlE+oO9FYKuF964V3eMbweQh2Xx8x3h6ZiZxrLyW619fw70fbOZEea3Oi26haG3kSguGmDj/rQu0UG+wyrjQtCJ/iqVl6RP12y4olhjfpp0GmlYtuSn4ayS67Inwio+W4EprACluJMHx00vQ/UyRiRIKBpOwtqix14n+P4fXiPiaK14VxddMsYHH2viO6Et11r2hrUGiyaq9Rbz/Sz4A917QSq02CqYYuOYtT4r4u1NFoHEjGNQ5jS//cCbXj+2GwQAfbyjgrOe+59EvtpN3qkrfdbcGRs8Q1l5rtcicBO2N2d9Grt5gm7rp+vauCjS2cuzEh5snpkTLWuJvTU6N9etJK3ClSXEjCQ6DsWErjBYZ3UQ6d97PwkJzeDUc2SDSu6+eJzJagsm62rdU1Cu5aHboa5DUo6zayn0fbgZg+rhujMwNIei7pWJOgOveh16TxEb732th9avCIhgiSXExPD31ND65YzwjczOw2By89dMhznlhOTe9KdLGa62hpZ+3aoKJU/G3kas32KZuuoF6V/mO3dyBslrvi781TQrQe0sPojRIOBQMTmcjvtktnGBbpktUOJ3wn4thwv3BiRHNMRwiaNicENrzivaKTJcbvwjdctRC2LlzJwMHDiQ/P5+uXbuGda6KWis3vrmWjYdL6ZGZxKK7z2xZTTKbiq0OvrxbNHsF6HOhqJHUyEKTTqeTVfuKeOOHg6zYc9L996RYExcM6sTk07I5q28mcTEtK8VeOSd1/53UKqIX6O9thbb++oMk2P1bihspboJn28ew5QM49y/NN2dtGXz3N9EEM7H1WheaS9wcKqrinoUb2VxQRlqCmQW/HcfAzm3wO+B0wtp/i/o3dovoVzb6Vhh3Z+PqMrk4VFTFxxsK+GTDEY6U1rj/nhIXw8QBHbh4cCcm9G0ZHdfDJm58kZu6JASkuAmAFDdNYN4FcMnzzTOX3SYa6o2eAadd3TxzRohwi5tDRVUsWHuYt38+RK3VQVqC2dViIE33uVoUJ3bCovsgb5X4v8EIPc+BfpdAz3NF77RGVL12Op1sOFzCV1sK+XprIcfLLe7HYmOMnNGrPWf1yWJ87/b07ZCC0Rh9lbWbTdzMGSzcMWk5nqBhhYaEjxRGbY5g9+/ov3yQhA2LxcLs2bOZNWsWcXFxDT/BbmtcG4XG8vPL0O+isAubkN+HKMNmd1BttVNZa6O81kpxZR3HK2o5UlLDvhOVbMwvJe9Utfv4M3tnMvvK08hpp9FVvZmJ+HvfYQDc/JUILv7xH3DoB9i/TPwDUYCy02mQ1V90vk/rCsmdIKk9xKdDXKqmq9RgMDAytx0jc9vx8OSBbDhcwuLtx/jf9mPkF9fw/e6TfL9buLBS4mMYkJ1Kv44pdGuXSHZ6PJnJcWQkxpKaEENSXAwJZhNmU3SFSOr22SlxOA0VzGuolUKYxU3Ez9VmpqW/3jZpuSkpKaFdu3bk5+e3actNeXk5OTk5wb8Pp/bDqr/D2NvCvjZ2fwPVRXDxc2GfKuT3IQzs3LmTcePGsXbtWrKzPY0rb31vKxarHYdTNLe0O51Y7U5sdgd1dgcWm/h/Q5gMMCo3nauGdeSMnhkYoqQHV0VFBQMHDmTHjh2kpES+gKChNA/z/u+IyVuJ6fhmDA5rg89xGmMhJh6nKVY0bTWZcRqMIlPQ4IqzUfVgszigstbGidIKTHGJOJxOnrFex0Zn4Iy1GKOBGJOBWJOBGKMBk9GA0WDAaDRgMghBZTSIRCCDwYBBfR+PASqYz95ggKpTx/jp+Rl+vxfN8r1Z/46oLj3uLhh5Y+iP60g0/E40J9H6epV1FRUV0b69//IVbVLcrFu3jjFjxkR6GRKJRCKRSBrBl19+yaWXXur38TbplurduzcAb3yxkqTkyF8t+uPNHw/y+o2jMIXJHx9tV82RIhreh7y8PM4880x++ukn0tPTI7KGhvj9fzcw46yeuo5ZXVXFb686n8kP/QdzvMdNll9czTWjc8jJ0Md15nA6eX3lAV6dPiKg5eL3721gxpnBvcZf8ooxGQzccmaPkNdTWVnJmDFjWLt2LcnJQVb8bmZ27drFlVdeybfffqsZB9YSXoOeyNcbHRQWFjJp0iQGDx4c8Lg2KW5MJmEqzurUOarFTUJ6JbndwtfI0GKx8Mgjj9CzZ88W6VPVi2h6HwYNGhRVJmA1qdnFdO+tb7G/qpoass+9gXY5fTCZPUUc8+ylnDFqKEYd3WeDi+PZUJ7E9HG5fo8J5TWuLcnnlrN6MKARQdnKOTdkyJCIn3MNMWDAAE1x05Jegx7I1xsdKBegMTGB5Ut0RahJfAhvXERcXByPPvpoVJ24kUC+Dw1Ta7VjjtH/58JuiKHbeTd5CRuL1U5sjFFXYQNwVu9MVu0L3AvKgAFHkJ76wrIaemYlNWotreGcaw2vIRTk621ZSHET1bS5cChJlHK4uJqsFP1/5F5cvJukOO/idtVWOwlm/QvedWufxJGSGqx2/81c0xLMlNc0HEQMUGtztIh6NRJJW0SKm6gmOjJaJJKvtx6jc1qIlaUb4MmvdlBhsdWLq0lLMFNaU0c4ch2GdUvnn8v3+328Q2ocJyosfh9XqK6zkWCWP58SSbQiv50SiaRBCstqyE6P12282V/v5FSlhX4dU+oF+BoNBlITzLyweLdu8ymc0TuTHwO4pjqkxHE8iA7fB4uq6JkVPUGWEonEGyluJBJJgxSW1uhmuTlSWkNhWQ39s1P9Zi51TkugsKxhkREqqfFmYowGjvkZ+/yBHYMSN/tPVHL50M56L08ikeiEFDdRjYy5kUQH5bU2UuL1iS+Zu2wfXTMSAwYMx5tNOHEy++udusypZsqwLvzmrbV8uL6g3mPdM5M4WtqwuDlQVCVbV0gkUYwUN1GNjLmRRB6Hw+mudNtU6mwOymrqSE9ouI1H/06pHCurpaC4usFjQ6Fbu0T+MLEP/1l1kOKqOq/HUuPN1Fjt2B3+LyzqbA5sdidJcTKYWCKJVuS3UyKRBKSgpEa3TKmnv95Jp9T4oISS0WAgt30iLy3by3NXD9VlfoX0xFhuHN+d37y1jg9uH0dcjCc7q0+HZPaeqKB/J+16QzsLyxmQHb31sVo0divkr4GCdVBxHGJiIT0Xep8HGf7rE0Uzu49VsPbgKfafrAKgfVIso7q3Y1T3jKjrF9aakOImynE6nVHTB0jSNvls0xFdmmw6HE5OVNQytGt60M9JiTez/2QVVrtD942gW7tELhzUkd++/Qtv3zLG/T276fTuvL7qQD1x43A6WbW3iB/2nuT1G0fpupY2T+UJWPMv+OU/UFOsfUz3s+C8x6DryOZdWyNwOJws2lrI3O/3setYheYxndPi+d05vfj12NywVaFvy0hxE8XEmAzU2R1eV5USSXNzuLhal/iSpxbtJDMpLuTifB1S4nj8yx08cUXgcuuNYVhOBkdLa3n66138dfIAAAZ1TmXPsQqOldXSKU1kiO0sLOezjUcY1i2dz+46Q15x64WtDn5+GX54Eeoqxd8S20OPCZDeTTx+bCsc/kl0bH9jIoy7U4icmNjAY0eIw6eqmfnBJtbnlQAQazJyeq/29O+UQozJwOHiGn7cV8TRslr+9vl2vth0lDnThulyASHxIMVNFBNvNlFlsUtxI4koh4urueS07IYPDEBZdR3HymsYEoLVRiE7LZ69Jyp59IvtPDplUJPWocW5/Trw2kpP7Ruj0cCbN4/m9nfXM7ZnO7YUlJGVHMe7M8aQnhidG2qL5OhG+OxOOLFD/L/zcDjrXuh3ieiurqY0H75/Gja/B6v/KdxW170PSf67QkeCb7cfY+b7m6iqs5MUa+K2Cb24eXx30hK9Y8xqrXY++CWf5/63m1/ySpj6z5+Yf+sYv65QSejIy48oJsFsorLWFullSNo4FpuD+CZUDHY6nTzyxXZ6ZyU3qqWCwWCgT4dkqiw2Hvtie6PX4Y+EWBMWmwOHKoi4c3oCH91xOnU2B/93zVDm/nqEFDZ64bDDyhfgjfOEsEnMhKn/hluXwYDL6gsbgPQcmPoqXLcQ4tOFuHnzQig70uzL98e7q/P43fz1VNXZGdO9HYtnTuCe8/rUEzYgLlxvPL0739xzFgOyUymqtDDttdXsOlYegZW3TqS4iWISzCYqLMGVgpdIwkFxVR0pTcwKemrRThJjY0iObzhDyh+KwKmoDY/A6ZaRUC82Ii7GxOOXD5buAj2pOAbvXgHLngCHDQZeAXethaHTwBjEdtTvYpjxLaR2gVN74Z0pIl4nwsxfncfDn23D4YTrxuTw3m/H0jWIjvY57RJZ+NtxDO+WTlmNlRlv/cKJCv3rO7VFpLiJYhJiTVS0RcvNhnfhv9fAmxfB//4iTNKBqDguTNz7lsL3s2H9282zzjbAh7/k0z2zcc0hQYijwrIacts3XSAYDAb6dkymotbKk1/taPJ4avpnp7Jw3WFdx5T4cGAF/OtMOLgSzElw+T/hmrdCdy1l9YNbFkNaDpzaB+9OhdqysCw5GL7cfJSHPtsGwO/O7sXTU08jJoSYrLREM/+5eTQ9MpM4UlrDnfM3YAvQ/0wSHDLmJopJijXxw54ixvWMLr9y2Fj1d9j1FaR1haG/goT2cHQDfH0fVJ2EhHbQrgdk9ACnHY6sh9LDkNgOkjpCfCrEpcCe/8Hur+GylyClY6RfVYtmZ2EFI3IzGv38J7/aQZ8OKbp1+DYYDPTpmMK2I2XM+W4PM8/vq8u4vTsks2LPSV3GkviguKGWzwac0GGQEDVZTfjs0nPgpi/EBdDxbfD+DfDrj5o9yHhTfin3frgZgJtOz+WBi/o1Krs1PTGWN28ezZSXV/FLXgkvL9un27ndVpHiJopJjouhrK1Ybta/DfuXwbl/BbOqzH/uePEPoKYUSg5ByQFRvLnvxSKjwvfHpNdEKNoDC6+HzsPg4ue0/fiSBtl/spKrR3Vt1HOr62zYHA7di90ZDQb6d0ple2EZ1XU2XTpzp8SbiTUZyS+ulm4oPak8AZ/8Fg4sF/8ffgNc8rz3d7yxtOsJv/4Q/nMJHFwBX82Ey1+p/3sQJooqLdz2zi/U2RxM6t+Bv102qEllO3pkJvHk1MHcs3ATLy/by4S+WYxswoVFW0eKmwZwOp38Y+lejpfXYnMFHMYYDcSbTdx7QT+Sw1ilNCk+hqNh6K8Tddjq4Jc34dy/BP7RS0iHhGFCsDREZl+44EnY+y28fRn86r+QIH8oAlJVBN8/BZZKwAFO+DIbONiZTekXUp3eB4zBn+/P/283HVL0a7apJjbGSM/MZP7yyVZenDZMF8vQBYM68sw3u5j76xE6rFDC/u/h09uh8jiYE2HyizDsOn3nyB4K17wN710Dm+ZDZh8484/6zqGBw+Hk3g82c6LCQu8OyfzjuuG61Kq5fFgXlu8+yacbj/CXT7by5R/OJDZGRo80hjYtbl5auof7Lx2u6R89Xl7Layv3U1ZtJTXBTG77JNHvxunE7nBSYbHx6BfbSUsw89dLBmAMQxGm5LgYKmrbQEDxoj+J9M94nXv1GAzQ90LI6A7vXA6n/x6GXKvvHK2BypOweBaU5cOAKZDcQfzdYASnE8ryGZb/Dmw5JP7ecTC/dLuFuqTA6eEnKy0M7hy+/ktpCWYqa808/Nk2npp6WpPH690hhY/XF1BrtTcpO6zNY7cKkbzq74ATsgYIN1SH/uGZr895cNEz8M2fYcmjIian38XhmcvFmz8eZMWek8TFGJl7/QhdL3L/dulAVuw5ye7jFbz+wwHuOre3bmO3Jdq0uLHanTzwyRZMRgNxJhOxMUYcTicVtVbizSbaJ8eRk5HoZWo0GAzEmAxkJMaSnmDmeHktD3yyhb9dOpCUJmSDaJGWYKa8tYubDe+KgOFhvw7fHFn94OwH4aeXRTDjJS+AOTwWhRbHmn/B5oXi/R/zW+1j0nM8rkGHHY5uZNSWR0QQZ/ZQ1ne9EUuyt+sqv7iaBLMp7JVXO6cnsPdEJU98uZ2HL2t6DZzumUnsP1nJoDCKslZN0T7hhjq6Qfx/5M1w4WyIDbOrb8xtcHKXsAB/fCvcugQ6DAjLVPtPVvL84t0APHzpQPp10rcVR0ZSLA9fOoCZ72/m5WV7uXJEF7LTdHDjtTFahL3L6QxPd+xOafGc1iWd/h1T6ZKRQFqCmYzEWAZ1TqN3hxQyEmMD+lANBgOd0hLo3j6JR77Yztzv9+m6vgSziZo6u65jRhWWClj3Ooy/K/x+8sR2MOlvoj/NmxeITb2ts3khbPsEzn8MsocE9xyjCbqOgrP/DOc9Cu17M3LzI4xfdzex1cfch728bC/ZaeEXkEqK+KmqOp75pukdxDunJ/C/bccaPlDijcMBa18X2VBHNwgr7DVvw2X/CL+wAfH7cdGzkHumqHS84FdQ7aeNQxOwO5zc/+FmLDYHZ/XJ5Ndju+k+B8AVw7owunsGtVYHz36zKyxztHaiXtw89NBD3HjjjTz77LNs2rQpLHMYXTE0qQlmUhPMIQeFJcXF0L9TKgeLqnjxu926ravV95T6/Pcw9HqIa6aqnAaD6E8z6RHI+0mkm9e20aJZDrvYjM74I8Q0UoSYzNBlBJw7C/pdzKj1f2b8xj/jrCqiymLX3ZLpD4MrwDi/uLrJRS87pydwtLQNxLnpSUmeqF3z9X1gq4EeZ8MdP8GgK5p3HTGxcO07otFmySH44EbhItOR99b+f3v3HeZUlT5w/HtTpyXTC23o0qtIEcXGWlYE0XVdWBFRFEUXV1cX0V37iuhvbSt2FzvFAiogRcqwKgKiIEWqdJiBYYZpmUm9vz8OIBaYJHOTe5Ocz/PM4wjJzZtLynvPec97dvPt7iOk2S1MurJrxD6jFUXh/kGdUBSYtWY/3+0uj8jjxDNDJzdXXXUVRUVF9OrVi8WLF/PBBx8AoY/kuN1uKisrf/ajNZvFRMdGTkqrPTw6ZyOBCI02xY2108BdGVxxsNZsqWJ/mtMuFsXG6z6IfgwncLvdVFWJBnKVlZW43e7IP+iC+6BFf+3a1+e0FSNjzfvR/+ub+e7cNdocN0hmk0KL7FQe+rRhDf4apSdxoKJWo6hil9vtprq6+tQ3CvhhxcvwQj+xWsmSLEZPRswS7Rz0kJotuhjb0sReVHPvFnVjGjhYVccT88Qoyt0XtaNxRmSniro0TefKnuI8Pv7ZpojNYMQrwyY3y5cvZ/PmzXz++efcfvvt/P3vf2fmzJmUlYU+1Dhx4kTS09OP/zRr1iwCEYsRoLZ5osX8PR9+zxGXp8HHtFvMVLvjbDl4wA+rXofTR+kbR34nMb3y9QuwfLJuYUycOJGOHTsC0KxZMyZOnBjZB6yrgD0rI1N0WdAFLnoUDm9jSvLTWNSGvweClZFiw+cPNCg5SbFZqPXG8VRwkCZOnEjv3r1PfoPi9fD670QRr7cGCs+EW76EvjcH12k4kvI7wpWvAQqsniISMA1MnLuJqjofXZumc03f5pocsz53/u40bBYTK3aUyT5MITJscmO320lLS2Pr1q0AtGvXDr/fz9ixY7nrrrv47LPPgj7WhAkTqKioOP6zZ089HW8bQFEUGmck0zw7lUdmb2zwNFWOw86eMpdG0RnE3LugxVk/rcrRU0q2mKba9jkseliXECZMmMDGjaLj7p49e5gwYUJkH3DZk2IVmRKht7/JAr2uh8J+vOr7B1P6RG//n+bZqTw5T7up4UQ1YcIEVq5cefIbFH8vmmjanXDpv+G6OZDdOnoB1qfdJfC7o+/n+RNg68IGHe6bnWXM/G4figKPXt454oXyxzTOSGZkP5FIPTFv88/2P5NOzbDJTdu2bTGZTDz99NOMHTuWLl26MGTIEK655hp8Ph/Tp0+nqqoqqKE6u92O0+n82U+kpdotdGqcTnFFXYMKjXPS7Mz5/oCGkens27fh8HZoe6HekfzEYocBd4ur0WX/F/WHt9vtOBxixYXT6cRut0fuwVRV1BsdW/0USc16i54jXzzLlA6rIv94iPedosDTC7eEfQyb2URdgo/eHLu4PKluw0TDzVtXwhmj9R+t+S1n/gW6XwNqAN4fBSXhbdkRCKg8eHS68+pezcLa2b4hxp7bhjS7hY0HKpm3QRa7B8uAr0gIBAI4HA7mzp3LyJEjKSgoYPDgwUyaNIlBgwZx+eWXs27dOnw+n6GLbk0mhTZ5Dn48VB32h2Wuw87BqijUYESDxwWrXoN+UVgdFSrFBP3HiS7JGg1jG9J374gtLMxRalPvKBCrsbYtYkqjDzWrfziV5lmp7DpcE/b9cxx29pbLuptTUhQxpes8da8jXSkKDHr66AqqKph6tejpFKIPv93L+n2VOOwW7rqoXQQCPbXMVBs3nNUSEEm7X47eBMVwyY2qqphMJnw+H06nkwEDBpCWlvazqaRt27Zhs0V3D5Fw2Swmmmenct+sdVTUhl653zwrhZ2l4X9QG8rMm0QTPa2b9WnFZBEf2GunQcVevaOJjM1zxLYV0XRsZMznZkrKs5jUyI6KJNvMmBSFQ2HurpznsDNfXiHHB4sNrn5bbNVwZLfYksUb/OvC5fEd72nzlwvakJMWwVHVU7jh7JakJ1vZerCa2d/v1yWGWGOI5Gbq1Km8+uqrrFu37niFvsViOT7ldOWVV/Ltt98yaNAgbrrpJu677z4mT55MZmZstNN3JltpnZvGQ59uoCbE4uBUuyhwjPm51i+fA8UMTU7XO5JTsyRB31tg1li9I9Fe5X7RWygjMgX1p6QoYjPURl153fQISYHI1pE1Sk/iqTCnpgqcSRQnwrYniSIlC4bPEBdVe1fCp+OCHkF8uehHDla5KcxKYeSZLSIb5yk4k6zcNKAVAM9+vlXuGh4E3ZObIUOGMGnSJObMmcPVV1/No48+yooVKwBRnOv1emnevDnff/89nTt35rTTTqOoqIiePWNr/5cUm4XCrBSemB96Q6YmmclsKq6KQFRRUlMK6z8URaaxIKMQnI1h2b/1jkQ7PjfMGCE6xuqp1bnQ6Qpe9P2TKV3WRexh0pOtVNZ6wxrCL0hPorhSJjdxJaet6IGjmOH76fDlM/XepaSyjleW/QjAPZe0x27Rd0uOkWe2IDPFyo+lNXyyVo7e1EfX5KaoqIht27bx7bffMmvWLJ555hlKS0uZPHkyX331FQBWq2gEVlhYyGOPPcZdd91Fhw6RaasdaRkpNmo9fkqrQ6uh6VDg5I2vdkYmqEhTVfhglGjtb9FnSDcs3YfDD5+IxCzWHfs36HCZSNz0VtBZrFDbPJcpmf/FrGrf6kBRFLJS7cf7koQiO9XO4eroLWGXoqTVuXDJJPH75w/B5nmnvPlTC7ZQ6/VzevNMLulcEPn46pFmt3Dj0dGb5xbJ0Zv66JrcOJ1O8vPzcblcBAIBLrzwQsaMGUNKSgrTpk1j715R9/D2229TVFSEyYgV+SFqkZPKE/M2hdTkr21+GltKYnTkZulEyGoN2TG2+ZvZJvarifXpKU8NfHA9pOZCYT+9o/mJPU3U4WS25DXfvUzpsVXzhyhwJlESxgiMyaTIJpzxqveNR0eQVbEHVulvr2TdVFzJ+6tFnee9v+9gmIUrI/u1ICvVxs7DLmZ+F70WC7FI12whNzeXjRs38uabbx5PXHr37s3VV1/N2rVr2bRJXHWtXbuWnJwcPUPVTIrNQnqKjYkh7Bdit4gNCGNuE01vHWyZB52v1DuS8GS3FvvURGCPmohRVajYJ5oSzr0bplwitkjoPlzvyH5bq3NEkrNpNlNMj2ia5NgsJvwBFW8YV7ipdosmTTglA7p4kkj03ZWiwNj9607Mj83dRECF33cp4PTmxqntTLVbGHN09OY/i7eF9dpOFLomN02bNuXll1/m4Ycf5r333gPEaqnzzjuPDh068NZbbwHw2GOP0alTw3f8NYrG6UlUuDy8sDT4/jddmqTz/GJtN+aMuIX3i5U55ujsMRQRrc8TTe+MpGIvLH1cjMi8c6VIYP57Ebx+ofjvZ3dDxR6xQuTCR0S/GSNLzYb+t8MZN/yU5PTU5rWekWLjqQWhN/UrzEph44EE3Xcs3llsYlNPRyMo3Qyz//qzAuOiLYdYtuUQVrPC+Ivb6xfnSYzo15ycNBu7y1x8uDpOV3VqwKJ3AIMHD6a4uJjx48fjcrkYPXo0ADk5ObhcYkVFrCz7DpaiKLTMSWNPefArRro2zWDGN7sjGJXG6ipg7yq46F96R9IwzfqKJE1v370N62eCuwJScqGgk+jCmpwB1lSxW3escxSIJKeqGNZMZYrVy3jXCA5am4R9yOxUG/uPhN6zpnl2Cp+tK+bM1vExYiz9giMf/jAF3rgU1r0vmlr2uh6fP8C/5ohmf9f2a0Hz7FSdA/21FJuFm89pzaNzfuC5RVu5vEcTkqxx8P7XmO7JjaIo3HDDDTidTkaPHs0nn3yCzWZj4cKFLFu2TO/wIibZZsbrD+Dy+Eix1f/PkJ5spdrtx+cPYDHHQO3R/Pug8xWRa/EfLWYrZLaAA99Do67Rf3xXGcy6WazyOOMGSE2AL1tHAZx9BxzZzaTv3oCkdG6pup46U0rIh0qxmXF5Qu+r0yI7lS+2xkExuXRyzfvBwAdh4T9h3gQo7MfUH1PYUlJNRoqVcee31TvCk7qmb3Ne+98O9lfU8d6K3Vx/tMmf9BNDfPNYLBaGDRvG6tWrGTp0KOeffz4rV66kW7dueocWUfmOJJ7+PPgagza5abyybEcEI9KIqkLJemjSS+9ItNHyHFj+fHQfU1Wh6Al45wpoP0hsY5AIic2JMgrhvAnQvJ9YOh7GHlWKomC3mkJeoehMtlIVbxvWSr/W7zZofQH46vDPGMXkBesBuGPgaaSnGHc6PclqZtwFIvmavGRb/G2urAFDJDfHtG/fnlGjRjF27FjatYt+m+toy0qzUVbtDnor+65N01m370hkg9LC6jch5zTjbbEQrtx2ULoFAlEs3pt1C5T9CBc+Kh4/kTXuIYqO//cUU3qHXmOQmWLjhTD2d0uzWyivkUXFcc1kgqEvQWou5tIfGOV5lzZ5aQzvY4CWCfW4qldTWuakcrjGw6tH+/FIPzFUcpNoTIqCI9nKc4uDG70pzEph12FX0MmQbn5cAq3O0zsK7SgK5HeGVa9G5/Hm/O3oztqjYrsYW0tpeWJrjC+eZsoZe+q//QkyU2yUh7HyqU1eGu+tjKE6Nyk8aXnsPftxAG40z+WpPi6sMTD1bzWbuPvoXlev/u9HDoa53Ui8Mv6/YJwLpdW7oig0y0rhhwMG7nkT8Is9XLLibA64zUDYtijyj/O/f4vGgT2uifxjxZrUXDjnHvjyGdJ9h4O+m81iwutXQ74oaJuXxtaSXy8TluJLIKBy55omzPCdg0lR6br6PvDGxsapl3QuoHuzDFweP08tCG+7kXglkxudJVnN+AJq0LuGd26SzpQvDVx3c2AN5Bpv+WSDOQrAdRj8Ee41tG0x9BkTP1N6WkvNhtOv45ms90O6W7LVHPKWCoXZKewui+weWJL+Znyzh5U7y/i3aST+1Hwo2w5Fk/QOKyiKovCPS0XH/unf7GH9vgqdIzIOmdwYQHaqnWcXBTc11TYvja0HDXw1ufpN0TQuHjXqBisjPDXVbVh8LOuOpPxOUL6LpEBN0HfJSLHySlFodQkWkwmLWeFwiMXIUuw4WFV3vKHqjb/rgXnQU+IvvnwOitfrGFnwerXIYnC3xqgqPPzpRuOXLUSJTG4MICfNFvQH6LG54GBHeqLu0A+QF5t7f9WreX/Y9UVkHyMvDke9IqHNBbxYuDjom2ck2zhSG/qo2/nt80LqJi7FDlVVuW/meipqvXRq7OS6M1tAh0FiDzbVL2rformIoAHuuaQ9yVYzK3eW8eG3clsGkMmNIVjMJlQIupV269w0vt9rwOFHd7XYk8mke/ukyEhvIhrMxcgHXlxrfhbs+irom4u6m9D/3bo0SeeHA5UEwthdXDK2md/tY+HGEqxmhX//sdtP/cMuflw0xtzzNaydqm+QQWqckcztA8XS8Mfm/iBX+SGTG8NwJFnYWRrcMHtOmo0FG4ojHFEYitdBtnEbX2kiuw2UrNM7CsliA5MZRQ0+YbGaFSpDHL1RFIXT8h28/fWuUCOUDGzX4Rru/3gDALdf0Jb2Bc6f/jK9qViZB7DoIXAbeAHHCW44qyXt8h2U1Xh4ZPZGvcPRnUxuDMKZZGXaquCWuGal2igz4qZ+P3wq9jOKZ417iroiSX/JmTj95UHf3JlkDavfTa8WWXyzM4Y2T5VOyeMLMG7qd1S7ffRukcXN57T+9Y36jhWfZdUl8L+noh9kGKxmExOv7IJJgY+OjkolMpncGIQjyUpVkLt+Z6XaKDPisGP5jvhbAv5LeR3h4Aa9o5AAUvPI9h8M+uaOJCuVdaF3cm2RncLOWOgvJQXl4dkbWLu3gvRkK0//qftvb2djsYkGmgDLJ4v2FjGgZ2EmNx7dNXzCR+tC7swdT2RyYxBmk0Kw0/rpyTaOuCK8JDkcrlJIifMtAiw2QImZPhhxLS2ff3YIfno2zW6hJow29YqiUJCeJJeFx4Hpq3bzzte7URR4+upuNMlIPvmN2/0eWpwNfjcseSx6QTbQHQNP47T8NEqr3dz1/tqErReTyY2BWEwKtUFs8mc2KRjuIvJYQInQnyWvI3wrp6Z0Z3eAJ/h6CHEBEd4bp2lmMj8GWRMnGdMXW0u5b6ZY3n3nwNM4v33+qe+gKPC7h8Tva6fFzNLwJKuZ/wzrid1iYunmQ7z2RWJuzSCTGwNJspo5FKvDiLXlYHfWf7t40Kir2CVc0pfFBr7QpmcVBfxhXMnmOZIo2nwo5PtJxrB+XwW3vLMaX0BlSPfG3HZ+m+Du2OR06Hg5oMLiRyIZoqbaFTj456COADz+2Sa+2pZ4O9zL5MZAkqxmZgRZVGw4ZTvA2VjvKKIjuy0cDn43dylCzHbwhXYxkGQxh1WHkOewc7AqRi88EtzWkiqu/e9Kqtw++rTM4ok/dEUJZYT5/H+CYoIt82Df6sgFqrE/9ynkip5NCKhw29Tv2H04saZVZXJjIElWE3W+YJvzGWxeaut8cCRIcmMyg2KWdTd6s9hFPUQIkm3moPdyO1GOw57QxZmxalNxJcNe/ZqyGg9dm6bz2she2C0hdgDPaQNd/yR+XzJR+yAjRFEUHhvahc5NnJTVeLj+zVVUhNHIMlbJ5MZAzCYlqCFzjy/w2xX+eqo6AI5GekcRPdltoET2ktCV3SEaR4bAZjbxyZr9EQpIMpK1e44w7JWvKa320KmxkzdH9caRZA3vYOfcLS5oti2Evd9oG2gEJVnNvHbtGeQ77Ww7WM2Yt7/BHfQFdGwz2DdkYjMpwRU81nh8pNkN1gW46gA4Eyi5yWwOm2brHUViS86E2tD6z1jMJnxhdJj2+gPYjHZBIZ1U0ZZDDHv1a8pdXro1y+C90X3JTLWFf8CsVtDt6OjNsv/TJsgoKUhP4vWRZ5Bmt/D1j2XcMX1NWHVnsUa+Ww1EJDf1387l9pNiM9jminWViVNQDJDZAsp36h1FYjNbIRDa0m6rWQlrGwavL3B8XzfJ2Kau3M31b6zC5fFzdtsc3h3dh/SUMEdsTnTWnYACWz4T3dhjSOcm6bwy4nSsZoW564q596N1cb9EXL5bDcSkEFSjsBqPj1SjjdxAYiwDP8bRGCrl9EassZhMeP2hf6i7fQGs5gR6fccgnz/AI7M3MuGjdfgDKkN7NDk+YqGJnDbQaaj4/X//1uaYUXRmmxye+1MPTApM/2YPD8+O7x3EZXJjIH5VxWyq/wO0vMZDZkoDhli15q0TV9F6qTkkNrSsLRdFviHsNxQ2kzk6j2MkAR98dg98+lfYvwbclXpHBGY7SYHg+8+IC4jQH6akso58Z1Lod5Si4ojLw6g3VvH6FzsA0cjuqT92w2bR+Cvu7DvFfzd+DGWx1z/mki6NeOIP3QB446udPDb3h7hNcAx4+Z+4vH4Vi6n+N2NpjZvhvQujEFGQjuyCtILoPZ6qwuFt8OXTUFsB1iRR7Kf6IeAXK2gymsNFEyM7mmSxg6cGbKmRewwjqDkMC+8XyaOjQBTyfjNFJDd+rzgPF0+EtLzox5bbjhezNzFq4+kRfZjdZbX8vksUX+NS0Dbsr+Dmd1azp6yWZKuZf/+xG7/vEqH6v4Iu0GYgbPscvnoeBsXGvlMn+sPpTfH4Atw7cx2v/m8HJpPCPRe3D215fAwIObmpra1l9erVZGVl0bFjx5/9XV1dHTNmzODaa6/VLMBE4vMHN/R9uNpDk8xTtA2Pts2fRa+Y2F0Nn9wmvlAdBaLnzC/flAG/2Odqxgixqmngg5GJxdlYXL0VdNHumO5KcBgkWQr4YdZY0UsmoxByTvvpXKfm/nQ7dyXM+ZtIen7/f2BLiV6MeR3EKBKRTW72lrs4Ld8R0ceQQvfB6r3cN3Mdbl+AZlnJvDKiFx0aRbj2r//tIrlZ8y6cOwHScuu/j8EM71OIX1X556z1vFz0IwoK4y9uF1cJTkhjdlu2bKFDhw4MGDCALl26cM4553DgwIHjf19RUcGoUaM0DzJReP3BLfGuqPWS5zDQEHlVcXSWgS96GGbeKFYq5XUQq2V+681oMoukpqCLKPqdNz4y8aQ3hc3ztD2mUQoVfR744AZIzoAmPSE15+SjYHYnND0DkrPgw9Ew567w5n7CEVZDxdBjq6j1kuuwh3w/KTLqvH7u+fB77np/LW5fgPPa5fLpbWdFPrEBsd9U4x7gq4NvXo/840XIiL7NeXhIJwBeKtrOE/M3x9UUVUjJzfjx4+ncuTMHDx5k8+bNOBwO+vfvz+7dsbFjqtHV+QJcdXrTem8XCLI2J2qqiyM/LTX3LjEV1biHSGqCYbGLrRIqD8DnD2gfU0ah9iumynZoe7xwLJkI718HGc3A2ST4+6XlQbPeYqpqxkioiULLd4sNAn4sanDbMPhVFVOI751qt48kqyxPNIqdpTVc8cJXTFu1B0UR9TWvjzyDjGjVISoK9LtN/L7y1Zhu5nltvxY8NFgkOC8u3c6/F2yJmwQnpHfsV199xcSJE8nJyaFNmzZ8+umnXHTRRZx99tn8+GPsFVcZTa3HT0E9RYtun994S1KrD0a23mLBfeAqE4mNOcQPMMUkEpzSrbDkX9rGldlKTH9pKcSlzZqbdy+UrBfnLDWM4XbFBNmtIbcdfHo7zP175EdxGnfn1XbBtcX3BYKrazvRur1H6No0I4zAJK3NXXeAQf/5go0HKslOtfHW9b25fWDbkBPWBut4OaQ3A1cpfD8juo+tsZFntuCBy0SJyfNLtvHsovjYWiakd3ltbS0Wy09lOoqi8OKLL3LZZZdxzjnnsGXLFs0DTCT+gIrdeur+NcUVdTRKN9CUFIgv5EitllryLyjbCfmdwi8ONlnEFFXJBtGPRysWmxil0PLLW6/kRg3ArFvFyrMmvcDawLoZu0NMVfnqxCiQO/jdu0PW/CzY9UVQN/X7VSwhfhGu3XOEG85qGU5kkkbcPj8PfrKBse9+S7XbR6/mmcwZdzZnt9Wp3sVsgT43i9+/fiF607ARMqp/S/5xaQcAnvl8Ky8s3aZzRA0XUnLTvn17vvnm162nn3/+eYYMGcLgwYM1CyzRqKoa1Hf3gYo6GqUbqJg4km9qb61ISAo6izqahrAmQ257UYys5RLu1Bxt+90EdGiN7qmB90eJc1TQpeHn+hjFJGqfslrDRzeJ2qxIcORDzWFMav3nzhdQsYTQryagqhyp9cpl4DraU+bijy8t542vdgIwZkArpt7UlwK9L/J6Xgs2BxzaBNsX6xuLBkaf3Yq/X9wOgCfmbT6+rD5WhZTcDB06lKlTp/7m3z3//PMMGzYsbubros3lCa7r8N5yF1eeHkIdRKRVHwy+BiYUagBm3SKmOKwaJXNJTkjJFn1atJLfCVZP0e54lij3L1r4gCgCzmwpaogiITkDCrrB7Dtg8aOReYwmPXn9tOX13szjD63T8ObiKrlKSkeLfihh0H++YO3eCtKTrbw+shcTft/BGFPzSU7ocY34/esX9I1FI2PPbcPtF7QF4JHZG5m2MnbraUN6hUyYMIG5c+ee9O9feOEFAmHs2yJBZZ03qE3dDlTU0SonLQoRBalib3i1GfX5dBykZIlkREsZheCpgoX/1OZ4hf1g60KxXFoLOe20OU59fHXw0Rio3CemoVKyIvt4thRo3FNsNvr5Q9of/7SLYdOcem/m9vkZFkKPqK+2l3LreW0aEpkUBp8/wBPzNnHDm99QUeule7MM5ow7iws65Osd2s/1GQMoYmn4wU16R6OJvw5sy00DWgEwYeY6Pl0bm53YDZD+SgBVdT5u6F//vL4/oGrfdbMhflysfTHxwgfEVEl6M22PC6JuJ78THN4OrsMNP54tFToOgZljGn4sEEvcI+3zh8Q0VGouFHSNXndpix2anA6lW2Dhg9oe254GmS2Y0vn7U97M7Q2QFcIGiqXVHlrmGKTvUIIorXZz7X9X8sLS7QBcd2YLZozpR9PMKPZPClZWS2h/qfh9xYv6xqIRRVGYcEl7hvcpRFXhjulrWLLpoN5hhcxA35KJzePz17trba3XT3I9BcdRV31I25EbdxUc3gJ5HSPXXdhkEcf/9HZtalyanymm0b54puHHisQU3zF+r2jKV75LJBl6dBQ2W6Hx0QRnscar1zpdARs+OuVNvP4AjqTgepfWef0kGelCIgF8u7ucQc99wVfbD5NiM/OfYT14cHAnY13Q/VLfseK/a6eJVZ1xQFEUHhnSmSHdG+MLqNzy7mpW7Yyt52bgV0zi8PkDmINYnlpcUat/Ed0v1RwSRbVaUFX45C9iaibSown2NNF48NNx2hyv12j44RNY89s1abrz1MAH14uGe427h76kXktmi1jWX7JexKWV1GywO5jSc/tJb6JC0F1Y9x+pNVYn8DimqirvrtjF1S8vp7iyjta5qXxyW38u69ZY79Dq1/xMMQLqq4Nv/qt3NJoxmxT+76punN8+jzpvgOvfWMWG/RV6hxW0mEhuqqrEMtJ4LVaurPPhDOJq8oARl4HXHRGdabUw5w5IShcFqNHgbAxeF3z+YMOPZbHBgL/DipeMl+C4DsOHN4qVS06DfFlY7CKJ/fg2bVfcdf3jSfuO+AMq5hBGA/eW19IkQyY3kVbn9fP3D77nvpnr8fpVLu5UwMe3nUWbvBgp5FYU6Her+H3lq6K7d5ywmk288Oee9G6ZRVWdj5H/XcmPh6r1Disohk9urrvuOsaNG8e+fftQFCUuE5zKOi9/7tO83tsdqKjj8h4GWikF4sq7oT1RQNTZ1B6BzBYNP1awFEVMT5VuFjubN1RyhthrZvUUWPJYw4+nhcWPiQSioHNkp7zCkZIFtjSYe7d2xzzaUTnPu+9Xf1Xr8ZMcxIrEY/YfqY3cBowSIJZ5X/XSct5fvReTAuMvbs+L1/QkzR5jezp3ukJ0aa8uhvUf6h2NppKsZl4b2YtOjZ2UVnsY8fpK9h8xfldmwyc3q1evZteuXTz++OPs2rUrrATH7XZTWVn5sx8jqXH7aJpV/xViSWWdMYsbG1ob4zos9gdqSKO+cJmtog/LJ7dpc7zkDLjgAbGNwoxrg7qKc7vdx0cnK6trcLs1uvL7/GEx9dO4h0gijCi7DVSXaFt/0/WPTEqb9qs/dnl8QbVbOOZAhUHfb1Hgdrupro7sFXrRlkNc9vwXrNtXQWaKlbeu78Mt57aOzc0bLTboc5P4ffnkmG/q90vOJCtvXt+bVrmp7DtSy59fW8HBKg0uCCPIsMnNsSXlnTt3pkmTJpjNZp544gl27twZ8ot/4sSJpKenH/9p1iwCq3DCpKoqqATVEt7jC5BktIJiGvhBpAZEYW9ex+it2vml1BzRuG7Bfdocz2SGM24QvV2mDa/35hMnTqRjR9H+vFmfwUyc/GbDY3BXwaEfROGwxWBTmSdSlJ+6R2vVwDCrJXhryPD9fG+rarePEf1aBH0Yr9+I77fomDhxIr17947IsX3+AE8t2Mx1U1ZyxOWla9N0Zo87m7PaalS7p5fTR4lR7JJ18ONSvaPRXE6anXdu6EOTjGR2lNZwzWsrKKsx7hScYZMb09Ev+xEjRtClSxcuvfRSysvLeemll5g5cybvvPNO0MeaMGECFRUVx3/27NkTqbBD5gpyqLzO64/Pzfvm3ClWW9l1HlnIaStGW7TsENyiv/jyrmfvmQkTJrBx40YA9qz4hAm3jmz4Y8++IzqF2VqwJIlaoDl3aXfMjkN4Onvmz/6o2u2jWRAjpHC0PsdIm9NG2YQJE1i5cqXmxz1QUcvw11bw3OJtqCr8uU8hM8b0i4/appQs0bUY4MtndA0lUhpnJPPejX3Id9rZUlLN8Fe/NmyCY/hvS5PJxPz58zn33HMZN24ca9asYcSIEZSWiquyYKao7HY7TqfzZz9GUe32BbU0VRQ3GqzPg8/TsFb9S/4lpqQi1Rk3FCYLpOXDvHu0Pe4pClyPsdvtOByieNKZlord3sCVTAsfAJTIN+bTUnozqDmo3U7i+Z3h8HbsAVEboKoqKsGNkILotZKTZtcmlhhkt9tJS9PugkNVVT5Zu5+Lnl7Gyh1lpNrMPPun7vxraJf4Gh3rdysoZjFys/87vaOJiObZqbx3Y19yHXY2FVcx7JWvOVhpvCkqwyc3F198MYWFhVitVgKBAKtWraJ79+5s2LCBvXv3xub87Amq6rxcd2aLem+3p8xFYZbBkht3pWhiF46AHw7+ENl+NqFKbwqVe7XdvDK9Gah+MSoUDT6P6CGT2z46j6cVRRENDOdqNHqjKHDaRbzU5DNA9IgKpd6muKKOArmflCZKKusY8/Zqxk39jso6H92OTkMN6W6wxRFayCiELn8Qv3/xtL6xRFDr3DSm3tiXPIedzSVV/PHl5ew+7NI7rJ8xXHLzy5EYn8+Hz+dj2LBhDB8+nEmTJnHPPfdgtVp/tkN5rKrzBoK6QtxVVsOf+xpghONE7srwV0p9drcYKdFq3ygtmMzgaAzzxmt73A6DoWiStsc8mc/+DhnNY2M66pfsTrAkwwKNtsZocRbsXg6qSkWtl/Qgtjc5pqSyjvz0xB250UKd18/LRds5//+WsmBjCRaTwu0XtOWDW86M70Lt/n8V/934ibiAi1Nt8tJ4/+Z+NM1MZudhF1e8+CVr9hzRO6zjDJHcTJ06lVdffZV169b9rELf7/djsVi47rrrWLZsGePHj2f06NEMGjSIJ554goKCAh2jbjhVVVEIrqnYEZcBdyb2ecJrBqcGxA7R6Qa8cnM2hsoD2q52iGbDvJpD4Ijh90V2Gyj7UZvzbzJDViuaeX+kvMbDX45uCBiMg1VuLuoUw+dRR26fn6krd3PBv4uY+Nkmajx+ujfL4NO/nMUdvzvNGJteRlJ+R7ElCyoUPaF3NBHVPDuVD285k46NxDLxP768nBnfGKOmVfdX2ZAhQ5g0aRJz5szh6quv5tFHH2XFihUAmM1iGLlXr14sXbqUW2655fgqKi3ng/Xi8QeCaiteVec1Zt8Hv1t0mw3VgvvECiVF95ffr5nMYjn35/drd0yvK/zpu1BUHRDFuUY8r8EyW0VTyPkarVxrcRYPF/wPr1/FmRz8yE1ptTs+ilyjaE+Zi6cWbOasSUuY8NE69h2ppcCZxBN/6MpHt5xJh0bGqXWMuHOOjv5umCk2i41j+c4kZtzcj4Ed8vD4Avz9g++5Y/oaKmq9usal6zdmUVER27ZtY926dZhMJhYsWMD06dOZPHkyfr+fM888E+D4Em5VVY+voooHLk9wdQBbS6ppm2/AZM7nAVMY0x9H9kCjbtrHo5WMQm2Hkz01YI1CcrPkcbGlRKzLagl7V4m6rIYUrIOo4/nuHVLsV4Z0N68h2y4YS53Xz7p9FXy17TCLN5Wwdu9PrfkLnEmMPrsl1/RtnpjnMb+TGL3Z+LHogP7nUy8qiHVpdguvjOjF80u28cznW5j53T6+2FbKvb9vz5BuTTDpsPJQ1+TG6XSSn5+Py+UiJSWFCy+8kIyMDP773/8ybdo0CgsLadq0KW+//TaFhYWcc845eoaruWA7pm4uqeKeS9pFIaIQ+T1ilVEojuwWdTZGrgk5NvpRXSLqghqqriI6S91dh0ViEOtMFlH79Nk9cOmTDTuWYoK0PNrVlAd9l3jsgq61eeuLGTf1Ozz+wPE/MylwZusc/tS7GRd2LDD2ZpfRcP79sGkObJ0PO5ZBywF6RxRRJpPCuAva0r9NDne9v5YdpTXcMX0tLy7dzo1nt+LSro1IsUUv5dA1ucnNzWXjxo28+eab3Hqr2Jujd+/e1NTU8OCDD7Jp0yaaNm3K2rVr6dmzp56hRkSd18/1/VvUe7viilpa5xpw5EYNhH5l/cXTkBIDzbqcTWDxozD4Pw0/1oE1MPTlhh8nGLE8JXWi9KZi9EZVG76aLq8jrzf5ka84N6ibuzx+Uow4DWwgrXJT8fjFYogzWmRyzmm5nN8hjzyHweoC9ZTTBk6/Dla9BvPvhRuXhjeNH2NOb57JvL+ezWv/28FLS7ezpaSauz/4ngc+2cCZrXPo0zKLdgUOCtKTjs9cVNX5KKmsY3eZi03FVewpc/HW9b0btBpa1zPdtGlTXn75ZW666SYyMzMZPnw4qqpy3nnnMX36dN566y0GDhzIY489hs2m4y7GEVLn85Ndz0qpw9VuslLtxlzyrgZC/+Kpq4DcGCjUTMn+qbC1Iec+4BPdgtPytIvtt9RV6rvTt9ZMZtGnZ+H9cOEjDTtWdhvYUQRB1q+LHjdxdC4joE1uGkvvOpfm2SnG/GwyinPugXXvQ/E6WPUq9L1F74iiwm4xc+t5bbimb3PeXbGL6av2sOuwi89/KOHzH0qCOsb+iroG1b3pnkYOHjyY4uJixo8fj8vlYvTo0QDk5OTgcol18/GY2IDIDepbObDzcA2tcg26bFINEPL2C36P2BHa6BRFLE1e/LDYKypcJevF/HukVe6LTtFyNGU0F18KDT5OIZTvCvrmid7ALxgmk0KLeF7OrZW0XBj4EMz+qxgJbj8IMoyz/U+kpSdbGXtuG245pzXr91WybOsh1u+rYNvBag5Vu3F5REd4h91CTpqdZlnJnJbvoH0jJ84gmtueiu7JjaIo3HDDDTidTkaPHs0nn3yCzWZj4cKFLFu2TO/wdFdS6ebqM4z6ZlAJKbnxukKv0dGTs7FIGhpi99cwQMNdr0/mmynxl9xY7KI2q3K/+LcIl9ka0rYah6s9nNMuN/zHk6QT9RwJa6fCnhXw0U0w8tOEmJ46kaIodGmaTpem6VF7TENM0FssFoYNG8bq1asZOnQo559/PitXrqRbNwOvqGkgf0ANqoL8YFUdLbIN1pn4GL83tDdpTamxN3H8JbsD3A3YGVlVoXyn6MIcaT53bIyIhcrRSJteIRY7Jl9wLeKP1HrJc8ThuZT0YTLB0JfA5oDdX0HR43pHlBAMlT62b9+e9u1jrG18mNw+P/YgVhNU1nrJNeoHrT/EpeC15bH1BawoIl5XWXj7NFWXiMLkaNQk+N1gjqFzG6yUbDgS/JTSSaXmYHMVU+dsUe9NK2q95MppKUlLWa1g0FPw0Y2w7Enx/92H6x1VXDPEyE0icnsD2IPc5duwBXslG0Jb0r3mXbDEWP1USnb4V1plP0JWa23jORmfJ/bObTCOrcbz1jbsOKm52FwHgrppVa2XrNQ4PJeSvrr+EfrfLn7/5C/w/fv6xhPnZHKjE5fXT7L11ANnvkAAk1ETGxDTUqHU0PhicHQhJUv0jwlH+Q7ocJm28ZxMwBteQ8VYkJIDix5t2DFSc+nsXhPUTQMqWOJ9iwBJHxc8CF3/JFZRfjQaljwmPkclzcl3sE5cbh+j6tkNvKzaQ5aRl6R6qsEWQv+dgM/Yzft+izVZJGXhqD4kVupEgxb9YIwqOQPcFfXe7JSS0sVGr5KkJ5MJLn8R+o4V/180CV45V2yyGULRu1Q/Q9XcJBKPL0BGyqm/6Eur3cae+6+rFF8awQr4QYnRVuzhJA/uSjGtFWl+T/w07/sttjQxCtbQY3hqtIlHkhrCZIKLJ0LjHvDZ30W7iBkjIDUXWp8v/jynrWiFkN5UXGBJIZPJjQ5UVQWl/lqaQ9UeY/fbqDsSWnKjarBXkB4sdqgtCz1RCfijs+Szcn/8LQM/kdkKfl/DjmFPbdjKN0nSWtc/imTm6xfhm9eh5hB8P138nMjRGHLbQbM+0GYgNO0Vv6O0GpLJjQ7qfIGgVkodrnYzrLdRe9wgug0nhbDTrxYbIerBlgYVe6IzChOOr1+K7+QGxIe53xv+tKYtTUyjSpKRpObABf+Ec++B3cth5xdioUbZDrFK0FMNVfvFz49LxOKGjObQ52boeW109qyLUTK50UFVnRdHUv0f0odr3DTJNPCQZMAbWsv/gD+2mvgdY7HBmqnQqHto94vWxVW8bJh5Kha7mAZNDTPBtNiDrp1SkRtnSlFmtoqNNU/cXFNVRfuMw9uheK1IfLYsEEnP/Anw5TPwu4eh69VyJOc3xOA3TeyrqvNx23lt6r1drcePM4gkKGaEs12DEZisEGQDuKhTVVFLYo3zkRuTFTxV4Sc3JqtIxiUpViiKWK2ZkgXNzoAzRoPHJaatvnxGNAidOQbWfwRDno/8/nUxJo6rEOtX5wno8ri1Hn/sd0CtLRcdN0MVi1cYJotY6WVEFXvE0HQsntdQmK0NKwgO4fwosZiAS4nBlgK9RsGtK+GC+0Vrja3z4aWzYPcKvaMzlIRObvaU17ClpAqPL3pJjj+gYgqimNgfUI3bvA/EnLCjUYh3itHh/nCTm2g83f89BakJcMVmsord1aNATktJhmexw9l/g5uWQm4H0Q39jUvF9LkEJHhy8+DgzjROT2JTcSW1nuj0GKio9eJMrn+qqaLWS3oQt9PN1gXgDDW5MXCyVh+jft/VHDJuobPmGvr6Ce7+Cgr+gFH/wSXpBPkdYfTn0GGwmHaddbPYi02Vr9+ETm4Abju/Lf+4tCNbD1ZRVRf5Oflyl4fr+9df/HnE5SEzxcAN/Bq6U3MsUQOiN4XRVOwVPTBicQVaqAK+qPX7cCZZKKvxROWxJKnB7Glw1ZvQ/6/i/5f8C+benfBNAQ34iR19Wak2HhnSmV2HXZS7Ivuh5vL4aJRe/87Y5S5PvU3+dFW1X/RfSARqmM0HLbaG74l0KksmgrNp5I5vJAEfWFOi8lAZKTYOVYXZlVqS9GAywe8egkueBBRY9arYpNOXuEm6TG6OSrVbeGxoF/aVu6jzRibjrfX6SbKYg6qlOeLycl57A9dS1FWE1sAvlqmB8DoA2x2i8DoSAn5x7OTMyBzfaAI+UUwZBekpVg5WGXR1nCSdSp+b4MrXRJ3g+g9h2vCE7cwtk5sT2CwmWuWmsbM0Mi+Gw9VusoPsOFxR6zX4iiol/lfoHOP3hNc8zpYGtUc0DweARQ+LJaKJ8m/gqxPPN1x+T9DTd1mpNr7cFuZmqZKkty5/gGHTwJIM2xbCW0PAVaZ3VFEnk5tfGHtuG6wWExW12g7nldW4qaj1Mu6C+vvbgEhuco2a3AT8hFXcGavfw9466Dky9PvZHWKLikioKgZHQWSObUQBP1jqn849KV9d0PfPTrVxuEZOS0kxrO3v4NqPISkD9q6C1waKZoAJRCY3v2H8Re3ZU+YSe0BpoLiilkNVbiYO7YIlyMLUarfPuAXFlfvEJm+hitUCfm9teA2yIjVyo6piWXQ4fYZikRpo+AiVty7oguScNDul1YlbqyDFicI+cP18SG8GZdvh1fNh+2K9o4oamdz8hrQkS1hFhbVePz8cqGT9vgq2lFRxoKKWHaXVuDx+/jW0CxZz8KdbVVXMJoMOdZTvDH0ZuBqI3ZEbvxuSw5gSsafBvtXax1O+Q+zplShTUh5XwzswhzBy40iyRGXlpCRFXF57GL0ImpwuRpHfuRKWTmr4RrQxQCY3JzH+4vaUhFBUeLjazbaDVfztd6fxf1d14+6L2mE1m0izW3l4SGdM8fRFtOsrMdyZKFQ1vOXW5qTIbNuwfHJ4yVascleIKb6G8NQEPXJj6OaZkhQqRz5cNxd6XCMuMpc+Bm/8Hg5t1juyiJLJzUmIxMQSVO3N3nIXZS4Pj1/RlTynuDrMTLFx14XtuPuidmFGYOAP2IAv9A0wFVNsTksFfOH3kYnUP6HP3bD6k1jjKoMBdzbsGJ5qsIewgz1oNi0tSbqzJsGQyTD0FTGdvWeF2LJhwT8jt+hBZzK5OYU7f9eOfeWn7lNS5/VTVeflX5d3wRrCtNOpuH1+bBYjJzcxurt3OBpa2xKJL0ifW7RfTxReF6Q1sHjaXSWmCYOUarNQWRv/Q/dSgul2NYxdDm0vEisIv3oOnu0KSx6D6kN6R6cpmdycQnqyFZvFRPUp5t/3lLlolqXtjsw1bh+pdgMnDwEfmA0cn5bcVZAUbnIToQQ1kZIbn1tsDtjQqSJ3NRtNwY+iZqXaKK6UvW6kOJTRDIZPh+HvQ2570bOsaBI83RE+vBF2LIOAPptKa0kmN/W4+ZzWHDxJYbE/oOLxB7jtvOCWdwerxu0n1Wbg5MFkCbMgLQaH+esqof8d4d3X5xZdijWnYuhpSy25SrXZO6vuCD57RtA3z0yxUSKTGyleKQqcdiHc8hVc9QY07ilGctbNgDcvg2e6wML7oXhdzO5TJZObejTJSMbl+e0v8soIbW7p8vhJsRl4v6Dm/cEVTpOzGPxC9tWFtwwcoKYEWp6jbTwgdsgOJMhqnuqDcP69DT+OqwxPSn7QN3cmW/j6R9nIT4pzJjN0Ggo3LYHRi+H060RtWuVe+PJZUZfzQl9Y9iSU79I72pDI5KYeiqJgNpnw+n89TFfu8nDdmS00f8xar59kI4/cOBuJK+p415BiYoCqEsgo1C6eYyw2MSoU79SAuJrUYouJ2nI8STlB3zw92UqFrLmREknT0+GyZ+GurfDHt6DDZWJK+NAmWPyoqM2Z8nv47h0xXW9wBv4GNY70ZCuVtd5fbZ3g8vhokqH9TsW1Hp+xR24cjcJr560o4e/TpIeG7p9VcwicTbSL5xizXSQ3DV0ebXS15doteVcDIRXBO5OtVGrcpVySYoI1CToOET91FfDDp/D9DFGLs+tL8TP372LEp8c1UNjXkD23YuRbRl/Dejej2v3zq7iAqmJSlIj0xKj1BujbysB9TJIzxYs+VCYL+GNoOqX2CJxxY3j3VVUxpWWNwJJta3Jkdxs3iuqD0P92bY4VYt2AM8lKZZ0cuZESXFK6SGBGfgJ3rIcL7oes1uCtgTXvwJSL4T+nQ9ETormrgcjkJgiOJOuvpqX8gch1EPb4/KQYeVrqWEIXaqGZ2RZbyU1dBeS0De++R3ZFZkoKxBd+pPasMhJ3JWS31uA41WAPbUVjit2My+Nv+GNLUrxIbwpn/w3+shpGzYPu14jO4WXbYcm/4Nlu8OoF8OVzhtjHysDfoMbhsFvw+n/+RR7J5MbtC5BsNfC0FEBaPlSXhLZ5o8UmaihigaqKqYxwm+Xt+goKz9Q2pmMcBfE/cuOt02YJOEDFHrG/TggsJhP+QGyuEpGkiFIUaN5P/FwyCX74BNZOg53/g33fiJ+F/4SsVtDqPGh5NjTrG/qWPQ0kk5sg2K1mAmr0khuPL0CykWtuALJaij2OQkluzDGU3Phqg27X/5tK1sOlT2kXz4kUJfbql0JVcwjSwtic9beEkdxIkhQEexp0Hy5+qkpEovPDp6Iup+xH8fPN6+K2zibQqBvkd4a8DqLHTlaryEzdI5ObsIlOI5FLbpKsBv/S6jQUVrwMhf2Cv0/nK2HdB5GLSUu1DSgmLtshRrYi2ejQ7hDTNvG6x5erFC57Rptjle3gu5Zh1k5JkhQcRz70vlH81FWKAuQdy2D3V1CyASr3iZ/Nc0+4kyIuPLJaQEbzoz/NoOUAcDZuUDgyuQmTzWzC8xvLw7XgC6jYNNrKIWIadYfDW0O7j90ZOyM37koYcHd4913zLlz+grbx/FJKtlixFq/Jjd/TsJVqJyrfRW33MGunJEkKXZITOgwSPyDq3g6sheLvxaj2oc3ix10JFbvFz4mGTZPJjV6sZuU3e99owRcIYLMYPLkxmSA1F6qKg5+asjtip6DYUxPeVEbJBpF4RKqY+Jjz7oWZY4BWkX0cPfi9olGhFuoqxPYZBlyqKkkJw54GLfqLn2NUVUw/l+0Q01dHdsGRPSLRyWr4QoKETG6O7fbrqg6+EZG/rgZPrflXf1YTwjGCVVdTTW1NNSafwf95snvApmXQ/tLgbu81g6sOXDGQ4NT6wOUBQhhpUlVY/hb84b9QWRnSw1UevX1ldU3wd3J5ocYTf1/cdeUQSIGqEM7FyexaAc4O1FSF/j4NuGs4XH5Esw1xY82x1+SBAwd0jkSKa6YmkNMEcs7+6c/cwN69v3nzY6/HQD37XymqGqMbRzTA3r17adZMFhhKkiRJUixauXIlZ5xxxkn/PiGTm0AgwP79+3E4HBFpwhcrKisradasGXv27MHpdOodjm6McB78fj/btm2jTZs2mM0GXymnISOcez3EwvP2er0sX76czp07Y7H8ehS5qqqKjh07snHjRhyOOO+WjXy+RhEIBCgpKaFHjx6/+bo8JiGTG0morKwkPT2diooKw37ARoM8D/pJ1HMfD887Hp5DKOTzjS2JOZksSZIkSVLcksmNJEmSJElxRSY3Ccxut/PAAw9gt9vrv3Eck+dBP4l67uPhecfDcwiFfL6xRdbcSJIkSZIUV+TIjSRJkiRJcUUmN5IkSZIkxRWZ3EiSJEmSFFdkciNJkiRJUlyRyY0kSZIkSXFFJjcSVUc3FUz0hXOJ/vyl6FuzZo183cWYRPu8jNXnafBtp6VIu+6661AUhUcffZQmTZqgqmpC7rf1j3/8g127dtG5c2cuuugiunfvrndICePxxx+nvLycDh06MGjQIHJycvQOKSqGDBmCx+PhzTffJCcnB5Mptq41n3zySQ4fPkyXLl3o0aMHHTt21DukiEu0z8tY/lyMrXeTpLnVq1eza9cuHn/8cXbt2oWiKDGbqYfrqquuoqioiF69erF48WI++OADIHavWGLJ0KFDmT17Nnl5edxxxx3MmTMHiP9zf9ttt1FSUsKsWbPIy8uLucTmD3/4A9OmTUNRFF555RUeeugh3njjDb3DirhE+ryM9c9FOXKToAKBACaT6fiOv2azmSeeeIK7776bFi1a6B1e1CxfvpzNmzezatUq7HY7nTt3Zty4cdx5551kZmbqHV5cu/feezl06BBffPEFAAsWLGDGjBlccsklmM1msrOzdY4wMmprayktLeXll1/Gbrfz9ttvs379erKzs+nZsycDBw7UO8RT2rJlC9u3b2fx4sVkZmaybds2PvroI9555x18Ph+jR4/WO0TNJdrnZTx8LsbW5YKkmWNXiiNGjKBLly5ceumllJeX89JLLzFz5kzeeecdnSOMDrvdTlpaGlu3bgWgXbt2+P1+xo4dy1133cVnn32mc4Txyefz0b59++NXgw8//DCLFi3ivPPO4/nnn+eBBx5g/vz5OkcZGcnJyaiqyqFDh5g8eTLjx48nNTWVFStW8Oyzzxr+vZeZmYnT6WTTpk2oqkqbNm0YOXIkgwYNYvbs2RQVFekdouYS7fMyHj4XZXKT4EwmE/Pnz+fcc89l3LhxrFmzhhEjRlBaWgrEzhBkuNq2bYvJZOLpp59m7NixdOnShSFDhnDNNdfg8/mYPn06VVVVcX8eos1isXDNNdeQl5fHgQMHKC0tZcuWLdx111386U9/wuPxMHv2bAKBgN6hak5VVfLy8pg6dSqlpaV8/PHH3H///bzwwgsMGDCApUuXUldXZ9jXnMPhwGq18vrrrx+vN8nPz2fo0KFkZGTwzTff6Bxh5CTK52U8fC7K5CbBXXzxxRQWFmK1WgkEAqxatYru3buzYcMG9u7dG9fFcoFAAIfDwdy5cxk5ciQFBQUMHjyYSZMmMWjQIC6//HLWrVuHz+eL6/OgF5PJhMlkolGjRjz55JO0atUKt9tNx44d6dGjB19//TUej0fvMDWnKAr3338/CxYs4NFHH2X//v0EAgHy8/Pp2bMn69evN+xrLhAIkJSUxJQpU/jwww/529/+dvzvmjdvTr9+/fj000/j8t8NEuPzMl4+F2Vyk2B+mWn7fD58Ph/Dhg1j+PDhTJo0iXvuuQer1YrFEr8lWaqqYjKZ8Pl8OJ1OBgwYQFpaGnv27Dl+m23btmGz2XSMMj791tXesfN87L8VFRW0atXK0B+eoTr2vL1eL7m5ucybN4+8vDymTZvGgQMHANi5cycpKSmGvCI+8T3TrFkzFixYwOuvv86YMWOOx19TU0N2dnbc/Lsl2udlPH0uyl3BE8DUqVOprq6mb9++tGjRAofDAYDf78dsNrNo0SKuvfZa/vGPf3DLLbcAUF1dTVpamp5ha+5k5+HYcs5du3bRrVs3zjrrLBo3bsysWbOYN28ePXv21Dny2Heyc/9L+/fvZ+bMmdx///0sWbKErl27RjlSbdX33tu+fTtXXnklmZmZmEwmNmzYwNy5cw3zmjtZ/McKbLdt28YVV1xBeno6JpOJjRs3Mn/+fMPEH45E+7yM189FmdzEuSFDhrBr1y5atGjBli1buOyyy7jiiivo06fP8dtUVFRw8OBB2rZte/xDK97Udx68Xi9Wq5Xdu3fzwgsvkJOTw6WXXkqHDh10jjz21Xfuj32Ier1eHnzwQT766CPee+89evTooXPkDRPsa66mpob169dTW1tLq1atKCws1DlyIdj4q6urWbt2LdXV1bRr1y6mVw8l2udlXH8uqlLcWrp0qdqxY0fV7/erqqqq8+fPV6+//np1xIgR6pdffvmr2wcCgWiHGBWhnodjt5MaLtRzX1lZqe7fvz/aYWou1OdtNLEefzgS7fMy3j8XYzfllOrldDrJz8/H5XIRCAS48MILGTNmDCkpKUybNo29e/cC8Pbbb1NUVBQ38+S/FOp5iOUrMaMJ5dwvXrwYh8NBo0aNdI664UJ9zRlNrMcfjkT7vIz3z8XYilYKSW5uLhs3buTNN988/sLs3bs3V199NWvXrmXTpk0ArF27Nq5b3svzoJ9Qzn1+fr6eoWoq1l9zsR5/OBLtOcf989V76EiKrFmzZql5eXnqu+++q6rqT0OpY8aMUUeMGKGqqqq63W7d4osWeR70k6jnPtafd6zHH45Ee87x/Hxjf+2adEqDBw+muLiY8ePH43K5jrdGz8nJweVyAcTEsr6GkudBP4l67mP9ecd6/OFItOcc189X7+xKijyv16u+9957akpKinrZZZepV155pep0OtU1a9boHVpUyfOgn0Q997H+vGM9/nAk2nOO1+crl4InkE2bNrF8+XJqa2u54IILaNeund4h6UKeB/0k6rmP9ecd6/GHI9Gec7w9X5ncSJIkSZIUV+RqKUmSJEmS4opMbiRJkiRJiisyuZEkSZIkKa7I5EaSJEmSpLgikxtJkiRJkuKKTG4kSZIkSYorMrmRJEmSJCmuyORGkiRJkqS4IpMbSZIkSZLiikxupLBNnjyZFi1akJSURJ8+fVi5cqXeIUkJbNmyZVx22WU0btwYRVGYNWuW3iFJCW7ixImcccYZOBwO8vLyuPzyy9m8ebPeYSUEmdxIYZk+fTp33nknDzzwAN9++y3dunXjoosu4uDBg3qHJiWompoaunXrxuTJk/UORZIAKCoq4tZbb+Xrr79m4cKFeL1eLrzwQmpqavQOLe7JvaWksPTp04czzjiD559/HoBAIECzZs34y1/+wj333KNzdFKiUxSFmTNncvnll+sdiiQdd+jQIfLy8igqKmLAgAF6hxPX5MiNFDKPx8Pq1asZOHDg8T8zmUwMHDiQ5cuX6xiZJEmScVVUVACQlZWlcyTxTyY3UshKS0vx+/3k5+f/7M/z8/MpLi7WKSpJkiTjCgQC/PWvf6V///507txZ73DinkXvACRJkiQp3t16662sX7+eL774Qu9QEoJMbqSQ5eTkYDabKSkp+dmfl5SUUFBQoFNUkiRJxnTbbbcxe/Zsli1bRtOmTfUOJyHIaSkpZDabjdNPP51FixYd/7NAIMCiRYvo16+fjpFJkiQZh6qq3HbbbcycOZPFixfTsmVLvUNKGHLkRgrLnXfeyciRI+nVqxe9e/fmmWeeoaamhlGjRukdmpSgqqur2bZt2/H/37FjB2vWrCErK4vCwkIdI5MS1a233sp7773Hxx9/jMPhOF6TmJ6eTnJyss7RxTe5FFwK2/PPP8+TTz5JcXEx3bt357nnnqNPnz56hyUlqKVLl3Leeef96s9HjhzJG2+8Ef2ApISnKMpv/vmUKVO47rrrohtMgpHJjSRJkiRJcUXW3EiSJEmSFFdkciNJkiRJUlyRyY0kSZIkSXFFJjeSJEmSJMUVmdxIkiRJkhRXZHIjSZIkSVJckcmNJEmSJElxRSY3kiRJkiTFFZncSJIkSZIUV2RyI0mSJElSXJHJjSRJkiRJcUUmN5IkSZIkxZX/B907w/G9/qVzAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "\n", - "nsamples = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples\n", - "samples = tension_stats(samplesA,samplesB)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from anesthetic.samples import Samples\n", - "from anesthetic.examples.perfect_ns import correlated_gaussian\n", - "from anesthetic import read_chains, make_2d_axes\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from scipy import linalg" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "covA_inv = linalg.inv(covA)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 526.31578947 -473.68421053 -0. ]\n", - " [-473.68421053 526.31578947 -0. ]\n", - " [ 0. 0. 10. ]]\n" - ] - } - ], - "source": [ - "print(covA_inv)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Creating mock datasets A, B and AB\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "covA_inv = linalg.inv(covA)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 526.31578947 -473.68421053 -0. ]\n", - " [-473.68421053 526.31578947 -0. ]\n", - " [ 0. 0. 10. ]]\n" - ] - } - ], - "source": [ - "print(covA_inv)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.01 , 0.009, 0. ],\n", - " [0.009, 0.01 , 0. ],\n", - " [0. , 0. , 0.1 ]])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "t = linalg.inv(covA_inv)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.01 , 0.009, 0. ],\n", - " [0.009, 0.01 , 0. ],\n", - " [0. , 0. , 0.1 ]])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 2.10526316, -1.06578947, -0. ],\n", - " [-1.70526316, 1.31578947, -0. ],\n", - " [ 0. , 0. , 0.3 ]])" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 38\u001b[0m \u001b[39m# Creating mock dataset AB\u001b[39;00m\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[0;32m---> 40\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 41\u001b[0m samplesAB\u001b[39m.\u001b[39mplot_2d(axes)\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)\n", - "\n", - "# Creating mock dataset AB\n", - "nlive = 100\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", - "samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012logLlogL_birthnlive
weights
08.606047e-1440.9579190.0102780.764609-333.867790-inf200
11.189399e-1370.9360970.0125350.315644-319.728712-inf199
21.393459e-1270.9449670.0662070.126178-296.544520-inf198
36.461298e-1250.9288940.0614960.943672-290.405309-inf197
45.659704e-1210.9991000.1524020.520428-281.327427-inf196
........................
10492.248341e-010.0859970.2912880.501905-0.013805-0.3192055
10502.249385e-010.1093100.3121150.532662-0.013340-0.9395714
10512.257491e-010.0951580.2899410.498126-0.009743-0.9395713
10522.263745e-010.1079050.3036120.488828-0.006977-0.5518992
10532.273513e-010.1053650.3069660.497583-0.002671-10.8055251
\n", - "

1054 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2 logL logL_birth \\\n", - " weights \n", - "0 8.606047e-144 0.957919 0.010278 0.764609 -333.867790 -inf \n", - "1 1.189399e-137 0.936097 0.012535 0.315644 -319.728712 -inf \n", - "2 1.393459e-127 0.944967 0.066207 0.126178 -296.544520 -inf \n", - "3 6.461298e-125 0.928894 0.061496 0.943672 -290.405309 -inf \n", - "4 5.659704e-121 0.999100 0.152402 0.520428 -281.327427 -inf \n", - "... ... ... ... ... ... \n", - "1049 2.248341e-01 0.085997 0.291288 0.501905 -0.013805 -0.319205 \n", - "1050 2.249385e-01 0.109310 0.312115 0.532662 -0.013340 -0.939571 \n", - "1051 2.257491e-01 0.095158 0.289941 0.498126 -0.009743 -0.939571 \n", - "1052 2.263745e-01 0.107905 0.303612 0.488828 -0.006977 -0.551899 \n", - "1053 2.273513e-01 0.105365 0.306966 0.497583 -0.002671 -10.805525 \n", - "\n", - " nlive \n", - " weights \n", - "0 8.606047e-144 200 \n", - "1 1.189399e-137 199 \n", - "2 1.393459e-127 198 \n", - "3 6.461298e-125 197 \n", - "4 5.659704e-121 196 \n", - "... ... \n", - "1049 2.248341e-01 5 \n", - "1050 2.249385e-01 4 \n", - "1051 2.257491e-01 3 \n", - "1052 2.263745e-01 2 \n", - "1053 2.273513e-01 1 \n", - "\n", - "[1054 rows x 6 columns]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samplesA" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'samplesAB' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samplesAB\n", - "\u001b[0;31mNameError\u001b[0m: name 'samplesAB' is not defined" - ] - } - ], - "source": [ - "samplesAB" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 33\n\u001b[1;32m 38\u001b[0m \u001b[39m# Creating mock dataset AB\u001b[39;00m\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[0;32m---> 40\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 41\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*meanA+covB_inv*meanB)\n", - "\n", - "# Creating mock dataset AB\n", - "nlive = 100\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 2.10526316, -1.06578947, -0. ],\n", - " [-1.70526316, 1.31578947, -0. ],\n", - " [ 0. , 0. , 0.3 ]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0, 1], [0, 1], [0, 1]]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bounds" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " - ] - } - ], - "source": [ - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 2.10526316, -1.06578947, -0. ],\n", - " [-1.70526316, 1.31578947, -0. ],\n", - " [ 0. , 0. , 0.3 ]])" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m [[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]]\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, bounds)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "boundsAB = [[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3).", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m [[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]]\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", - "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:517\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m__init__.pxd:741\u001b[0m, in \u001b[0;36mnumpy.PyArray_MultiIterNew3\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3)." - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "boundsAB = [[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[[0, 1], [0, 1], [0, 1]], [[0, 1], [0, 1], [0, 1]], [[0, 1], [0, 1], [0, 1]]]" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "boundsAB" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3).", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]])\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", - "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:517\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m__init__.pxd:741\u001b[0m, in \u001b[0;36mnumpy.PyArray_MultiIterNew3\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape. Mismatch is between arg 0 with shape (200, 3) and arg 1 with shape (3, 3)." - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB, boundsAB)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (200,3) (3,3) ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m boundsAB \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]],[[\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m]]])\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:110\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[1;32m 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39muniform(\u001b[39m*\u001b[39mbounds\u001b[39m.\u001b[39mT, (\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mnlive, ndims))\n\u001b[0;32m--> 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n\u001b[1;32m 113\u001b[0m logLs \u001b[39m=\u001b[39m samples\u001b[39m.\u001b[39mlogL\u001b[39m.\u001b[39miloc[\u001b[39m-\u001b[39mnlive]\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:98\u001b[0m, in \u001b[0;36mcorrelated_gaussian..logLike\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[0;32m---> 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39;49mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (200,3) (3,3) " - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 2.10526316, -1.06578947, -0. ],\n", - " [-1.70526316, 1.31578947, -0. ],\n", - " [ 0. , 0. , 0.3 ]])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "100" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nlive" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 526.31578947, -473.68421053, -0. ],\n", - " [-473.68421053, 526.31578947, -0. ],\n", - " [ 0. , 0. , 10. ]])" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA_inv" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.1, 0.3, 0.5]" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanA" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 526.31578947, -473.68421053, -0. ],\n", - " [-473.68421053, 526.31578947, -0. ],\n", - " [ 0. , 0. , 10. ]])" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covB_inv" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.7, 0.2, 0.1]" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanB" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 52.63157895, -142.10526316, -0. ],\n", - " [ -47.36842105, 157.89473684, -0. ],\n", - " [ 0. , 0. , 5. ]])" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA_inv*meanA" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[39m.\u001b[39;49masmatrix(covA_inv)\u001b[39m*\u001b[39;49mmeanA\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/matrixlib/defmatrix.py:218\u001b[0m, in \u001b[0;36mmatrix.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__mul__\u001b[39m(\u001b[39mself\u001b[39m, other):\n\u001b[1;32m 216\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, (N\u001b[39m.\u001b[39mndarray, \u001b[39mlist\u001b[39m, \u001b[39mtuple\u001b[39m)) :\n\u001b[1;32m 217\u001b[0m \u001b[39m# This promotes 1-D vectors to row vectors\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39;49mdot(\u001b[39mself\u001b[39;49m, asmatrix(other))\n\u001b[1;32m 219\u001b[0m \u001b[39mif\u001b[39;00m isscalar(other) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39m(other, \u001b[39m'\u001b[39m\u001b[39m__rmul__\u001b[39m\u001b[39m'\u001b[39m) :\n\u001b[1;32m 220\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39mdot(\u001b[39mself\u001b[39m, other)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)" - ] - } - ], - "source": [ - "np.asmatrix(covA_inv)*meanA" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[39m.\u001b[39;49masmatrix(covA_inv)\u001b[39m*\u001b[39;49mnp\u001b[39m.\u001b[39;49masmatrix(meanA)\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/matrixlib/defmatrix.py:218\u001b[0m, in \u001b[0;36mmatrix.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__mul__\u001b[39m(\u001b[39mself\u001b[39m, other):\n\u001b[1;32m 216\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, (N\u001b[39m.\u001b[39mndarray, \u001b[39mlist\u001b[39m, \u001b[39mtuple\u001b[39m)) :\n\u001b[1;32m 217\u001b[0m \u001b[39m# This promotes 1-D vectors to row vectors\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39;49mdot(\u001b[39mself\u001b[39;49m, asmatrix(other))\n\u001b[1;32m 219\u001b[0m \u001b[39mif\u001b[39;00m isscalar(other) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39m(other, \u001b[39m'\u001b[39m\u001b[39m__rmul__\u001b[39m\u001b[39m'\u001b[39m) :\n\u001b[1;32m 220\u001b[0m \u001b[39mreturn\u001b[39;00m N\u001b[39m.\u001b[39mdot(\u001b[39mself\u001b[39m, other)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)" - ] - } - ], - "source": [ - "np.asmatrix(covA_inv)*np.asmatrix(meanA)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[-89.47368421],\n", - " [110.52631579],\n", - " [ 5. ]])" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.asmatrix(covA_inv)*(np.asmatrix(meanA).transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.01 , 0.009, 0. ],\n", - " [0.009, 0.01 , 0. ],\n", - " [0. , 0. , 0.1 ]])" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.asmatrix(covA)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 526.31578947, -473.68421053, -0. ],\n", - " [-473.68421053, 526.31578947, -0. ],\n", - " [ 0. , 0. , 10. ]])" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA_inv" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.01 , 0.009, 0. ],\n", - " [0.009, 0.01 , 0. ],\n", - " [0. , 0. , 0.1 ]])" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.asmatrix(covA).transpose()" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'reshape'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[47], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA_inv\u001b[39m*\u001b[39mmeanA\u001b[39m.\u001b[39;49mreshape(\u001b[39m3\u001b[39m,\u001b[39m1\u001b[39m)\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'reshape'" - ] - } - ], - "source": [ - "covA_inv*meanA.reshape(3,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[-89.47368421],\n", - " [110.52631579],\n", - " [ 5. ]])" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA_inv*np.asmatrix(meanA).reshape(3,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 526.31578947, -473.68421053, -0. ],\n", - " [-473.68421053, 526.31578947, -0. ],\n", - " [ 0. , 0. , 10. ]])" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA_inv" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.1, 0.3, 0.5]" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanA" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-89.30000000000001" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "526 *0.1-473*0.3" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "ename": "LinAlgError", - "evalue": "Last 2 dimensions of the array must be square", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 39\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 40\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 41\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 42\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", - "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.4 ],\n", - " [0.25],\n", - " [0.3 ]])" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "meanAB = meanAB.transpose()" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "ename": "LinAlgError", - "evalue": "Last 2 dimensions of the array must be square", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 43\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", - "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = meanAB.flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = meanAB.transpose().flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = meanAB.transpose().flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = meanAB.transpose().flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "ename": "LinAlgError", - "evalue": "Last 2 dimensions of the array must be square", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 43\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", - "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0, 1], [0, 1], [0, 1]]" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bounds" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "ename": "LinAlgError", - "evalue": "Last 2 dimensions of the array must be square", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m meanAB\u001b[39m=\u001b[39m[\u001b[39m0.4\u001b[39m , \u001b[39m0.25\u001b[39m, \u001b[39m0.3\u001b[39m ]\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:533\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[1;32m 532\u001b[0m _assert_stacked_2d(a)\n\u001b[0;32m--> 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n\u001b[1;32m 536\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->D\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->d\u001b[39m\u001b[39m'\u001b[39m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:190\u001b[0m, in \u001b[0;36m_assert_stacked_square\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 188\u001b[0m m, n \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:]\n\u001b[1;32m 189\u001b[0m \u001b[39mif\u001b[39;00m m \u001b[39m!=\u001b[39m n:\n\u001b[0;32m--> 190\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39mLast 2 dimensions of the array must be square\u001b[39m\u001b[39m'\u001b[39m)\n", - "\u001b[0;31mLinAlgError\u001b[0m: Last 2 dimensions of the array must be square" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=[0.4 , 0.25, 0.3 ]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Output size (200, 1) is not compatible with broadcast dimensions of inputs (200, 3).", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[39m#meanAB=[0.4 , 0.25, 0.3 ]\u001b[39;00m\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB,bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:109\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 105\u001b[0m bounds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(bounds, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 107\u001b[0m logLmax \u001b[39m=\u001b[39m logLike(mean)\n\u001b[0;32m--> 109\u001b[0m points \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mrandom\u001b[39m.\u001b[39;49muniform(\u001b[39m*\u001b[39;49mbounds\u001b[39m.\u001b[39;49mT, (\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mnlive, ndims))\n\u001b[1;32m 110\u001b[0m samples \u001b[39m=\u001b[39m NestedSamples(points, logL\u001b[39m=\u001b[39mlogLike(points), logL_birth\u001b[39m=\u001b[39m\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minf)\n\u001b[1;32m 112\u001b[0m \u001b[39mwhile\u001b[39;00m (\u001b[39m1\u001b[39m\u001b[39m/\u001b[39msamples\u001b[39m.\u001b[39mnlive\u001b[39m.\u001b[39miloc[:\u001b[39m-\u001b[39mnlive])\u001b[39m.\u001b[39msum() \u001b[39m<\u001b[39m samples\u001b[39m.\u001b[39mD_KL()\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m:\n", - "File \u001b[0;32mmtrand.pyx:1154\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.uniform\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:600\u001b[0m, in \u001b[0;36mnumpy.random._common.cont\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:518\u001b[0m, in \u001b[0;36mnumpy.random._common.cont_broadcast_2\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m_common.pyx:245\u001b[0m, in \u001b[0;36mnumpy.random._common.validate_output_shape\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: Output size (200, 1) is not compatible with broadcast dimensions of inputs (200, 3)." - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "#meanAB=[0.4 , 0.25, 0.3 ]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0, 1], [0, 1], [0, 1]]" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bounds" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB.ndim" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "ename": "LinAlgError", - "evalue": "1-dimensional array given. Array must be at least two-dimensional", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 6\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[1;32m 42\u001b[0m meanAB\u001b[39m=\u001b[39m[\u001b[39m0.4\u001b[39m , \u001b[39m0.25\u001b[39m, \u001b[39m0.3\u001b[39m ]\n\u001b[0;32m----> 43\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB\u001b[39m.\u001b[39;49mflatten(),bounds)\n\u001b[1;32m 44\u001b[0m \u001b[39m#samplesAB.plot_2d(axes)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/codes/anesthetic/anesthetic/examples/perfect_ns.py:95\u001b[0m, in \u001b[0;36mcorrelated_gaussian\u001b[0;34m(nlive, mean, cov, bounds)\u001b[0m\n\u001b[1;32m 93\u001b[0m mean \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(mean, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[1;32m 94\u001b[0m cov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(cov, dtype\u001b[39m=\u001b[39m\u001b[39mfloat\u001b[39m)\n\u001b[0;32m---> 95\u001b[0m invcov \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49minv(cov)\n\u001b[1;32m 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlogLike\u001b[39m(x):\n\u001b[1;32m 98\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m-\u001b[39m\u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m ((x\u001b[39m-\u001b[39mmean) \u001b[39m@\u001b[39m invcov \u001b[39m*\u001b[39m (x\u001b[39m-\u001b[39mmean))\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m<__array_function__ internals>:200\u001b[0m, in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:532\u001b[0m, in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 471\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 472\u001b[0m \u001b[39mCompute the (multiplicative) inverse of a matrix.\u001b[39;00m\n\u001b[1;32m 473\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 529\u001b[0m \n\u001b[1;32m 530\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 531\u001b[0m a, wrap \u001b[39m=\u001b[39m _makearray(a)\n\u001b[0;32m--> 532\u001b[0m _assert_stacked_2d(a)\n\u001b[1;32m 533\u001b[0m _assert_stacked_square(a)\n\u001b[1;32m 534\u001b[0m t, result_t \u001b[39m=\u001b[39m _commonType(a)\n", - "File \u001b[0;32m~/Documents/Cambridge/project2/myenv/lib/python3.8/site-packages/numpy/linalg/linalg.py:183\u001b[0m, in \u001b[0;36m_assert_stacked_2d\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 181\u001b[0m \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m arrays:\n\u001b[1;32m 182\u001b[0m \u001b[39mif\u001b[39;00m a\u001b[39m.\u001b[39mndim \u001b[39m<\u001b[39m \u001b[39m2\u001b[39m:\n\u001b[0;32m--> 183\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m'\u001b[39m\u001b[39m%d\u001b[39;00m\u001b[39m-dimensional array given. Array must be \u001b[39m\u001b[39m'\u001b[39m\n\u001b[1;32m 184\u001b[0m \u001b[39m'\u001b[39m\u001b[39mat least two-dimensional\u001b[39m\u001b[39m'\u001b[39m \u001b[39m%\u001b[39m a\u001b[39m.\u001b[39mndim)\n", - "\u001b[0;31mLinAlgError\u001b[0m: 1-dimensional array given. Array must be at least two-dimensional" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=[0.4 , 0.25, 0.3 ]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB.flatten(),bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'cosA' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[79], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m cosA\n", - "\u001b[0;31mNameError\u001b[0m: name 'cosA' is not defined" - ] - } - ], - "source": [ - "cosA" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.01, 0.009, 0], [0.009, 0.01, 0], [0, 0, 0.1]]" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covA" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 81, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=[0.4 , 0.25, 0.3]\n", - "covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012logLlogL_birthnlive
weights
01.467395e-2620.0182080.9681070.512536-608.317803-inf200
11.662490e-2180.0014470.8536330.898664-506.879231-inf199
24.384759e-2180.0103750.8645090.091090-505.909413-inf198
35.861166e-2100.1204410.9487450.935246-487.198518-inf197
42.067021e-2070.0138110.8431520.044832-481.333003-inf196
........................
12072.205249e-010.3978760.2411900.315647-0.027948-11.6005595
12082.209846e-010.4125410.2577400.281244-0.025866-0.5711134
12092.239392e-010.3943770.2458820.270074-0.012584-0.3353583
12102.243973e-010.3952610.2484960.279307-0.010541-0.3353582
12112.247963e-010.3928820.2411490.307434-0.008765-0.3353581
\n", - "

1212 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2 logL logL_birth \\\n", - " weights \n", - "0 1.467395e-262 0.018208 0.968107 0.512536 -608.317803 -inf \n", - "1 1.662490e-218 0.001447 0.853633 0.898664 -506.879231 -inf \n", - "2 4.384759e-218 0.010375 0.864509 0.091090 -505.909413 -inf \n", - "3 5.861166e-210 0.120441 0.948745 0.935246 -487.198518 -inf \n", - "4 2.067021e-207 0.013811 0.843152 0.044832 -481.333003 -inf \n", - "... ... ... ... ... ... \n", - "1207 2.205249e-01 0.397876 0.241190 0.315647 -0.027948 -11.600559 \n", - "1208 2.209846e-01 0.412541 0.257740 0.281244 -0.025866 -0.571113 \n", - "1209 2.239392e-01 0.394377 0.245882 0.270074 -0.012584 -0.335358 \n", - "1210 2.243973e-01 0.395261 0.248496 0.279307 -0.010541 -0.335358 \n", - "1211 2.247963e-01 0.392882 0.241149 0.307434 -0.008765 -0.335358 \n", - "\n", - " nlive \n", - " weights \n", - "0 1.467395e-262 200 \n", - "1 1.662490e-218 199 \n", - "2 4.384759e-218 198 \n", - "3 5.861166e-210 197 \n", - "4 2.067021e-207 196 \n", - "... ... \n", - "1207 2.205249e-01 5 \n", - "1208 2.209846e-01 4 \n", - "1209 2.239392e-01 3 \n", - "1210 2.243973e-01 2 \n", - "1211 2.247963e-01 1 \n", - "\n", - "[1212 rows x 6 columns]" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samplesAB" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.005, 0.0045, 0.0], [0.0045, 0.005, 0.0], [0.0, 0.0, 0.05]]" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.4 , 0.25, 0.3 ]])" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [], - "source": [ - "a = meanAB.tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]]" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'strip'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[89], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m a\u001b[39m.\u001b[39;49mstrip()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'strip'" - ] - } - ], - "source": [ - "a.strip()" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [], - "source": [ - "a = meanAB.flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.4 , 0.25, 0.3 ])" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [], - "source": [ - "a = meanAB.flatten().tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 96, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [], - "source": [ - "b = covAB.flatten().tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.004999999999999997,\n", - " 0.004499999999999996,\n", - " 0.0,\n", - " 0.004499999999999996,\n", - " 0.0049999999999999975,\n", - " 0.0,\n", - " 0.0,\n", - " 0.0,\n", - " 0.05]" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 99, - "metadata": {}, - "outputs": [], - "source": [ - "b = covAB.tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", - " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", - " [0.0, 0.0, 0.05]]" - ] - }, - "execution_count": 100, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'reshape'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[101], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m b\u001b[39m.\u001b[39;49mreshape(\u001b[39m1\u001b[39m,\u001b[39m3\u001b[39m)\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'reshape'" - ] - } - ], - "source": [ - "b.reshape(1,3)" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "cannot reshape array of size 9 into shape (1,3)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[102], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m b \u001b[39m=\u001b[39m covAB\u001b[39m.\u001b[39;49mreshape(\u001b[39m1\u001b[39;49m,\u001b[39m3\u001b[39;49m)\u001b[39m.\u001b[39mtolist()\n", - "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 9 into shape (1,3)" - ] - } - ], - "source": [ - "b = covAB.reshape(1,3).tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "metadata": {}, - "outputs": [], - "source": [ - "b = covAB.reshape(1,9).tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.004999999999999997,\n", - " 0.004499999999999996,\n", - " 0.0,\n", - " 0.004499999999999996,\n", - " 0.0049999999999999975,\n", - " 0.0,\n", - " 0.0,\n", - " 0.0,\n", - " 0.05]]" - ] - }, - "execution_count": 104, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'ndim'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[105], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA\u001b[39m.\u001b[39;49mndim\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'ndim'" - ] - } - ], - "source": [ - "covA.ndim" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'ndim'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[106], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m covA\u001b[39m.\u001b[39;49mndim()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'ndim'" - ] - } - ], - "source": [ - "covA.ndim()" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.005 , 0.0045, 0. ],\n", - " [0.0045, 0.005 , 0. ],\n", - " [0. , 0. , 0.05 ]])" - ] - }, - "execution_count": 107, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [], - "source": [ - "b=covAB.flatten()" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.005 , 0.0045, 0. , 0.0045, 0.005 , 0. , 0. , 0. ,\n", - " 0.05 ])" - ] - }, - "execution_count": 109, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.005 , 0.0045, 0. ])" - ] - }, - "execution_count": 110, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", - " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", - " [0.0, 0.0, 0.05]]" - ] - }, - "execution_count": 111, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB.tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "metadata": {}, - "outputs": [], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "covAB=covAB.tolist()\n", - "covAB=[covAB[0],covAB[1],covAB[2]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 113, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", - " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", - " [0.0, 0.0, 0.05]]" - ] - }, - "execution_count": 113, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 114, - "metadata": {}, - "outputs": [], - "source": [ - "covAB = linalg.inv(covAB_inv)" - ] - }, - { - "cell_type": "code", - "execution_count": 115, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'flatten'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m \u001b[39m#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\u001b[39;00m\n\u001b[1;32m 44\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "covAB=covAB.tolist()\n", - "#covAB=[covAB[0],covAB[1],covAB[2]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'flatten'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m \u001b[39m#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\u001b[39;00m\n\u001b[1;32m 44\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "covAB=covAB.tolist()\n", - "covAB=[covAB[0],covAB[1],covAB[2]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.39999999999999947, 0.24999999999999944, 0.30000000000000004]" - ] - }, - "execution_count": 117, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "meanAB" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": {}, - "outputs": [], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "#covAB=[[0.005 , 0.0045, 0. ],[0.0045, 0.005 , 0. ],[0. , 0. , 0.05 ]]\n", - "covAB=covAB.tolist()\n", - "#covAB=[covAB[0],covAB[1],covAB[2]]\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "#samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 120, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0.004999999999999997, 0.004499999999999996, 0.0],\n", - " [0.004499999999999996, 0.0049999999999999975, 0.0],\n", - " [0.0, 0.0, 0.05]]" - ] - }, - "execution_count": 120, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covAB" - ] - }, - { - "cell_type": "code", - "execution_count": 121, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'flatten'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 5\n\u001b[1;32m 40\u001b[0m nlive \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 41\u001b[0m \u001b[39m#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\u001b[39;00m\n\u001b[0;32m----> 42\u001b[0m meanAB\u001b[39m=\u001b[39mmeanAB\u001b[39m.\u001b[39;49mflatten()\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 43\u001b[0m covAB\u001b[39m=\u001b[39mcovAB\u001b[39m.\u001b[39mtolist()\n\u001b[1;32m 44\u001b[0m samplesAB \u001b[39m=\u001b[39m correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'flatten'" - ] - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB=meanAB.flatten().tolist()\n", - "covAB=covAB.tolist()\n", - "samplesAB = correlated_gaussian(nlive, meanAB, covAB,bounds)\n", - "samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012
0DiagonalAx...OffDiagona...OffDiagona...
1OffDiagona...DiagonalAx...OffDiagona...
2OffDiagona...OffDiagona...DiagonalAx...
\n", - "
" - ], - "text/plain": [ - " 0 1 2\n", - "0 DiagonalAx... OffDiagona... OffDiagona...\n", - "1 OffDiagona... DiagonalAx... OffDiagona...\n", - "2 OffDiagona... OffDiagona... DiagonalAx..." - ] - }, - "execution_count": 123, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Creating mock dataset AB\n", - "nlive = 100\n", - "#boundsAB = np.array([[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]],[[0, 1], [0,1], [0, 1]]])\n", - "meanAB_=meanAB.flatten().tolist()\n", - "covAB_=covAB.tolist()\n", - "samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds)\n", - "samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012logLlogL_birthnlive
weights
03.159818e-2680.0320580.9928430.610632-621.584807-inf200
13.485225e-2010.0356740.8505970.156593-467.213587-inf199
22.431671e-1960.0062680.8096860.011415-456.060616-inf198
34.560066e-1930.1990280.9874290.044495-448.524102-inf197
46.901140e-1880.1489170.9265060.702908-436.596827-inf196
........................
12302.385761e-010.4042000.2593180.318285-0.021252-0.5689815
12312.395665e-010.3885960.2373880.289041-0.017109-0.3378704
12322.406134e-010.3894500.2422440.298375-0.012748-0.9852763
12332.418517e-010.4030890.2502710.281706-0.007615-0.3378702
12342.422749e-010.4074970.2560890.301366-0.005867-0.3378701
\n", - "

1235 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2 logL logL_birth \\\n", - " weights \n", - "0 3.159818e-268 0.032058 0.992843 0.610632 -621.584807 -inf \n", - "1 3.485225e-201 0.035674 0.850597 0.156593 -467.213587 -inf \n", - "2 2.431671e-196 0.006268 0.809686 0.011415 -456.060616 -inf \n", - "3 4.560066e-193 0.199028 0.987429 0.044495 -448.524102 -inf \n", - "4 6.901140e-188 0.148917 0.926506 0.702908 -436.596827 -inf \n", - "... ... ... ... ... ... \n", - "1230 2.385761e-01 0.404200 0.259318 0.318285 -0.021252 -0.568981 \n", - "1231 2.395665e-01 0.388596 0.237388 0.289041 -0.017109 -0.337870 \n", - "1232 2.406134e-01 0.389450 0.242244 0.298375 -0.012748 -0.985276 \n", - "1233 2.418517e-01 0.403089 0.250271 0.281706 -0.007615 -0.337870 \n", - "1234 2.422749e-01 0.407497 0.256089 0.301366 -0.005867 -0.337870 \n", - "\n", - " nlive \n", - " weights \n", - "0 3.159818e-268 200 \n", - "1 3.485225e-201 199 \n", - "2 2.431671e-196 198 \n", - "3 4.560066e-193 197 \n", - "4 6.901140e-188 196 \n", - "... ... \n", - "1230 2.385761e-01 5 \n", - "1231 2.395665e-01 4 \n", - "1232 2.406134e-01 3 \n", - "1233 2.418517e-01 2 \n", - "1234 2.422749e-01 1 \n", - "\n", - "[1235 rows x 6 columns]" - ] - }, - "execution_count": 124, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samplesAB" - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012
0DiagonalAx...OffDiagona...OffDiagona...
1OffDiagona...DiagonalAx...OffDiagona...
2OffDiagona...OffDiagona...DiagonalAx...
\n", - "
" - ], - "text/plain": [ - " 0 1 2\n", - "0 DiagonalAx... OffDiagona... OffDiagona...\n", - "1 OffDiagona... DiagonalAx... OffDiagona...\n", - "2 OffDiagona... OffDiagona... DiagonalAx..." - ] - }, - "execution_count": 125, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Creating mock datasets A, B and AB\n", - "# Creating mock dataset A\n", - "nlive = 100\n", - "meanA = [0.1, 0.3, 0.5]\n", - "covA = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesA = correlated_gaussian(nlive, meanA, covA, bounds) # output is Nested sampling run\n", - "#samplesA.gui()\n", - "#plt.show()\n", - "\n", - "# Creating mock dataset B\n", - "nlive = 100\n", - "meanB = [0.7, 0.2, 0.1]\n", - "covB = [[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]]\n", - "#bounds = [[0, 1], [0,1], [0, 1]]\n", - "samplesB = correlated_gaussian(nlive, meanB, covB, bounds)\n", - "# Make a plot\n", - "axes = samplesA.plot_2d([0,1,2])\n", - "samplesB.plot_2d(axes)\n", - "\n", - "# Calculate covariance of AB using equation 19 from paper\n", - "covA_inv = linalg.inv(covA)\n", - "covB_inv = linalg.inv(covB)\n", - "covAB_inv = covA_inv+covB_inv\n", - "covAB = linalg.inv(covAB_inv)\n", - "\n", - "# Calculate mean of AB using equation 20 from paper\n", - "meanAB = covAB*(covA_inv*(np.asmatrix(meanA).transpose())+covB_inv*(np.asmatrix(meanB).transpose()))\n", - "meanAB = np.asarray(meanAB.transpose())\n", - "\n", - "# Creating mock dataset AB\n", - "nlive = 100\n", - "# Matching the input for the func correlated_gaussian\n", - "meanAB_=meanAB.flatten().tolist()\n", - "covAB_=covAB.tolist()\n", - "\n", - "samplesAB = correlated_gaussian(nlive, meanAB_, covAB_,bounds)\n", - "samplesAB.plot_2d(axes)" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for -: 'method' and 'method'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 14\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n\u001b[0;32m---> 60\u001b[0m samples \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB,samplesAB,nsamples)\n", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 11\u001b[0m, in \u001b[0;36mtension_stats\u001b[0;34m(A, B, AB, nsamples)\n\u001b[1;32m 55\u001b[0m \u001b[39m# Create a new sample\u001b[39;00m\n\u001b[1;32m 56\u001b[0m samples \u001b[39m=\u001b[39m Samples(index\u001b[39m=\u001b[39mA\u001b[39m.\u001b[39mindex)\n\u001b[0;32m---> 57\u001b[0m samples[\u001b[39m'\u001b[39m\u001b[39mlogR\u001b[39m\u001b[39m'\u001b[39m]\u001b[39m=\u001b[39mAB\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39;49mA\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39mB\u001b[39m.\u001b[39mlogZ\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'method' and 'method'" - ] - } - ], - "source": [ - "nsamples = 1000\n", - "Beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " A.stats(nsamples)\n", - " B.stats(nsamples)\n", - " AB.stats(nsamples)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples\n", - "samples = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for -: 'method' and 'method'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 14\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples,A,statsA\n\u001b[0;32m---> 60\u001b[0m samples,A,statsA \u001b[39m=\u001b[39m tension_stats(samplesA,samplesB,samplesAB,nsamples)\n", - "\u001b[1;32m/Users/ongdily/Documents/Cambridge/project2/codes/anesthetic/tension_stats_2.py\u001b[0m in \u001b[0;36mline 11\u001b[0m, in \u001b[0;36mtension_stats\u001b[0;34m(A, B, AB, nsamples)\n\u001b[1;32m 55\u001b[0m \u001b[39m# Create a new sample\u001b[39;00m\n\u001b[1;32m 56\u001b[0m samples \u001b[39m=\u001b[39m Samples(index\u001b[39m=\u001b[39mA\u001b[39m.\u001b[39mindex)\n\u001b[0;32m---> 57\u001b[0m samples[\u001b[39m'\u001b[39m\u001b[39mlogR\u001b[39m\u001b[39m'\u001b[39m]\u001b[39m=\u001b[39mAB\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39;49mA\u001b[39m.\u001b[39;49mlogZ\u001b[39m-\u001b[39mB\u001b[39m.\u001b[39mlogZ\n\u001b[1;32m 58\u001b[0m \u001b[39m# do the same for logS, logI, d_G, p, return these values in a table\u001b[39;00m\n\u001b[1;32m 59\u001b[0m \u001b[39mreturn\u001b[39;00m samples,A,statsA\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'method' and 'method'" - ] - } - ], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " B.stats(nsamples,beta)\n", - " AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA\n", - "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " B.stats(nsamples,beta)\n", - " AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " #samples['logR']=AB.logZ-A.logZ-B.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA\n", - "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 129, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012logLlogL_birthnlive
weights
06.440561e-1310.9029580.0059860.528754-304.249343-inf200
19.059360e-1100.9705940.1742340.381037-255.553874-inf199
21.502676e-1070.9155260.1261740.752995-250.442669-inf198
31.175806e-1040.9622780.1902550.655991-243.780207-inf197
43.785914e-1000.8310710.0732960.879531-233.400534-inf196
........................
10732.001752e-010.1215240.3232210.499609-0.027063-0.8550425
10742.012080e-010.0864160.2903010.546931-0.021917-0.4891124
10752.013631e-010.1002400.3089050.484046-0.021146-0.4891123
10762.029350e-010.1163190.3142690.498682-0.013371-0.4891122
10772.031425e-010.0991590.3033260.539819-0.012349-0.4891121
\n", - "

1078 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2 logL logL_birth \\\n", - " weights \n", - "0 6.440561e-131 0.902958 0.005986 0.528754 -304.249343 -inf \n", - "1 9.059360e-110 0.970594 0.174234 0.381037 -255.553874 -inf \n", - "2 1.502676e-107 0.915526 0.126174 0.752995 -250.442669 -inf \n", - "3 1.175806e-104 0.962278 0.190255 0.655991 -243.780207 -inf \n", - "4 3.785914e-100 0.831071 0.073296 0.879531 -233.400534 -inf \n", - "... ... ... ... ... ... \n", - "1073 2.001752e-01 0.121524 0.323221 0.499609 -0.027063 -0.855042 \n", - "1074 2.012080e-01 0.086416 0.290301 0.546931 -0.021917 -0.489112 \n", - "1075 2.013631e-01 0.100240 0.308905 0.484046 -0.021146 -0.489112 \n", - "1076 2.029350e-01 0.116319 0.314269 0.498682 -0.013371 -0.489112 \n", - "1077 2.031425e-01 0.099159 0.303326 0.539819 -0.012349 -0.489112 \n", - "\n", - " nlive \n", - " weights \n", - "0 6.440561e-131 200 \n", - "1 9.059360e-110 199 \n", - "2 1.502676e-107 198 \n", - "3 1.175806e-104 197 \n", - "4 3.785914e-100 196 \n", - "... ... \n", - "1073 2.001752e-01 5 \n", - "1074 2.012080e-01 4 \n", - "1075 2.013631e-01 3 \n", - "1076 2.029350e-01 2 \n", - "1077 2.031425e-01 1 \n", - "\n", - "[1078 rows x 6 columns]" - ] - }, - "execution_count": 129, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A" - ] - }, - { - "cell_type": "code", - "execution_count": 130, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.3384253.174730-1.1636942.028366
1-4.0202712.933097-1.0871741.833509
2-4.4464153.220232-1.2261842.031067
3-4.0390502.963091-1.0759591.550850
4-4.0109462.912096-1.0988501.853250
...............
995-4.2840073.195151-1.0888561.625164
996-4.3971973.220436-1.1767611.863146
997-4.0334772.979882-1.0535951.658587
998-4.3899843.176785-1.2131992.053731
999-3.9008492.810499-1.0903491.616558
\n", - "

1000 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " logZ D_KL logL_P d_G\n", - "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", - "samples \n", - "0 -4.338425 3.174730 -1.163694 2.028366\n", - "1 -4.020271 2.933097 -1.087174 1.833509\n", - "2 -4.446415 3.220232 -1.226184 2.031067\n", - "3 -4.039050 2.963091 -1.075959 1.550850\n", - "4 -4.010946 2.912096 -1.098850 1.853250\n", - "... ... ... ... ...\n", - "995 -4.284007 3.195151 -1.088856 1.625164\n", - "996 -4.397197 3.220436 -1.176761 1.863146\n", - "997 -4.033477 2.979882 -1.053595 1.658587\n", - "998 -4.389984 3.176785 -1.213199 2.053731\n", - "999 -3.900849 2.810499 -1.090349 1.616558\n", - "\n", - "[1000 rows x 4 columns]" - ] - }, - "execution_count": 130, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "statsA" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "metadata": {}, - "outputs": [], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " statsB=B.stats(nsamples,beta)\n", - " statsAB=AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA\n", - "samples,A,statsA = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logR
weights
06.440561e-131NaN
19.059360e-110NaN
21.502676e-107NaN
31.175806e-104NaN
43.785914e-100NaN
.........
10732.001752e-01NaN
10742.012080e-01NaN
10752.013631e-01NaN
10762.029350e-01NaN
10772.031425e-01NaN
\n", - "

1078 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " logR\n", - " weights \n", - "0 6.440561e-131 NaN\n", - "1 9.059360e-110 NaN\n", - "2 1.502676e-107 NaN\n", - "3 1.175806e-104 NaN\n", - "4 3.785914e-100 NaN\n", - "... ...\n", - "1073 2.001752e-01 NaN\n", - "1074 2.012080e-01 NaN\n", - "1075 2.013631e-01 NaN\n", - "1076 2.029350e-01 NaN\n", - "1077 2.031425e-01 NaN\n", - "\n", - "[1078 rows x 1 columns]" - ] - }, - "execution_count": 132, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samples" - ] - }, - { - "cell_type": "code", - "execution_count": 133, - "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "EOL while scanning string literal (, line 1)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m Cell \u001b[0;32mIn[133], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m statsA\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n" - ] - } - ], - "source": [ - "statsA\"" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.1717443.056473-1.1152711.786759
1-4.0468643.009728-1.0371361.597706
2-4.3112283.202833-1.1083951.809025
3-4.1209472.972869-1.1480781.879480
4-4.3511523.157193-1.1939602.091767
...............
995-3.9253182.862501-1.0628171.614719
996-4.4804333.319033-1.1614002.062474
997-4.3017203.160843-1.1408771.703830
998-4.1772713.036093-1.1411782.059596
999-4.0980362.980327-1.1177081.819270
\n", - "

1000 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " logZ D_KL logL_P d_G\n", - "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", - "samples \n", - "0 -4.171744 3.056473 -1.115271 1.786759\n", - "1 -4.046864 3.009728 -1.037136 1.597706\n", - "2 -4.311228 3.202833 -1.108395 1.809025\n", - "3 -4.120947 2.972869 -1.148078 1.879480\n", - "4 -4.351152 3.157193 -1.193960 2.091767\n", - "... ... ... ... ...\n", - "995 -3.925318 2.862501 -1.062817 1.614719\n", - "996 -4.480433 3.319033 -1.161400 2.062474\n", - "997 -4.301720 3.160843 -1.140877 1.703830\n", - "998 -4.177271 3.036093 -1.141178 2.059596\n", - "999 -4.098036 2.980327 -1.117708 1.819270\n", - "\n", - "[1000 rows x 4 columns]" - ] - }, - "execution_count": 134, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "statsA" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "metadata": {}, - "outputs": [], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " statsB=B.stats(nsamples,beta)\n", - " statsAB=AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA,statsB,statsAB\n", - "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 136, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.2801043.103178-1.1769262.203933
1-4.6271343.400734-1.2264002.354423
2-4.6072453.402678-1.2045672.375870
3-4.2828273.037355-1.2454732.120491
4-4.4541023.259298-1.1948042.230798
...............
995-4.4802523.255807-1.2244462.220415
996-4.4484043.214183-1.2342212.128176
997-4.2972243.076654-1.2205712.316718
998-4.6741193.454976-1.2191442.371506
999-4.4302023.204460-1.2257422.408287
\n", - "

1000 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " logZ D_KL logL_P d_G\n", - "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", - "samples \n", - "0 -4.280104 3.103178 -1.176926 2.203933\n", - "1 -4.627134 3.400734 -1.226400 2.354423\n", - "2 -4.607245 3.402678 -1.204567 2.375870\n", - "3 -4.282827 3.037355 -1.245473 2.120491\n", - "4 -4.454102 3.259298 -1.194804 2.230798\n", - "... ... ... ... ...\n", - "995 -4.480252 3.255807 -1.224446 2.220415\n", - "996 -4.448404 3.214183 -1.234221 2.128176\n", - "997 -4.297224 3.076654 -1.220571 2.316718\n", - "998 -4.674119 3.454976 -1.219144 2.371506\n", - "999 -4.430202 3.204460 -1.225742 2.408287\n", - "\n", - "[1000 rows x 4 columns]" - ] - }, - "execution_count": 136, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "statsB" - ] - }, - { - "cell_type": "code", - "execution_count": 137, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logZD_KLlogL_Pd_G
labels$\\ln\\mathcal{Z}$$\\mathcal{D}_\\mathrm{KL}$$\\langle\\ln\\mathcal{L}\\rangle_\\mathcal{P}$$d_\\mathrm{G}$
samples
0-4.9906023.574315-1.4162872.634555
1-5.0828373.619382-1.4634552.569358
2-5.1766143.761474-1.4151412.692252
3-4.7960053.440258-1.3557472.369404
4-5.0481693.595502-1.4526662.506467
...............
995-4.8756113.548798-1.3268132.363104
996-4.8812223.493873-1.3873492.525472
997-4.8709383.538388-1.3325502.511589
998-5.0845793.585871-1.4987082.551930
999-4.8901433.492245-1.3978982.433410
\n", - "

1000 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " logZ D_KL logL_P d_G\n", - "labels $\\ln\\mathca... $\\mathcal{D... $\\langle\\ln... $d_\\mathrm{G}$\n", - "samples \n", - "0 -4.990602 3.574315 -1.416287 2.634555\n", - "1 -5.082837 3.619382 -1.463455 2.569358\n", - "2 -5.176614 3.761474 -1.415141 2.692252\n", - "3 -4.796005 3.440258 -1.355747 2.369404\n", - "4 -5.048169 3.595502 -1.452666 2.506467\n", - "... ... ... ... ...\n", - "995 -4.875611 3.548798 -1.326813 2.363104\n", - "996 -4.881222 3.493873 -1.387349 2.525472\n", - "997 -4.870938 3.538388 -1.332550 2.511589\n", - "998 -5.084579 3.585871 -1.498708 2.551930\n", - "999 -4.890143 3.492245 -1.397898 2.433410\n", - "\n", - "[1000 rows x 4 columns]" - ] - }, - "execution_count": 137, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "statsAB" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "samples\n", - "0 3.087781\n", - "1 3.498871\n", - "2 3.512691\n", - "3 3.682961\n", - "4 3.614406\n", - " ... \n", - "995 3.525633\n", - "996 3.702340\n", - "997 3.607038\n", - "998 3.669652\n", - "999 3.523506\n", - "Name: $\\ln\\mathcal{Z}$, Length: 1000, dtype: float64" - ] - }, - "execution_count": 138, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "statsAB.logZ-statsA.logZ-statsB.logZ" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "metadata": {}, - "outputs": [], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " statsB=B.stats(nsamples,beta)\n", - " statsAB=AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=A.index)\n", - " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA,statsB,statsAB\n", - "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logR
weights
06.440561e-131NaN
19.059360e-110NaN
21.502676e-107NaN
31.175806e-104NaN
43.785914e-100NaN
.........
10732.001752e-01NaN
10742.012080e-01NaN
10752.013631e-01NaN
10762.029350e-01NaN
10772.031425e-01NaN
\n", - "

1078 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " logR\n", - " weights \n", - "0 6.440561e-131 NaN\n", - "1 9.059360e-110 NaN\n", - "2 1.502676e-107 NaN\n", - "3 1.175806e-104 NaN\n", - "4 3.785914e-100 NaN\n", - "... ...\n", - "1073 2.001752e-01 NaN\n", - "1074 2.012080e-01 NaN\n", - "1075 2.013631e-01 NaN\n", - "1076 2.029350e-01 NaN\n", - "1077 2.031425e-01 NaN\n", - "\n", - "[1078 rows x 1 columns]" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samples" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [], - "source": [ - "nsamples = 1000\n", - "beta = 1\n", - "def tension_stats(A,B,AB,nsamples):\n", - " # A, B and AB are datasets created with anesthetic.examples.perfect_ns_correlated_gaussian\n", - " statsA= A.stats(nsamples,beta)\n", - " statsB=B.stats(nsamples,beta)\n", - " statsAB=AB.stats(nsamples,beta)\n", - " # Create a new sample\n", - " samples = Samples(index=statsA.index)\n", - " samples['logR']=statsAB.logZ-statsA.logZ-statsB.logZ\n", - " # do the same for logS, logI, d_G, p, return these values in a table\n", - " return samples,A,statsA,statsB,statsAB\n", - "samples,A,statsA,statsB,statsAB = tension_stats(samplesA,samplesB,samplesAB,nsamples)" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
logR
samples
03.673867
13.654226
23.620559
33.650832
43.903685
......
9953.578809
9963.778822
9973.559742
9983.635960
9993.725074
\n", - "

1000 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " logR\n", - "samples \n", - "0 3.673867\n", - "1 3.654226\n", - "2 3.620559\n", - "3 3.650832\n", - "4 3.903685\n", - "... ...\n", - "995 3.578809\n", - "996 3.778822\n", - "997 3.559742\n", - "998 3.635960\n", - "999 3.725074\n", - "\n", - "[1000 rows x 1 columns]" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samples" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "myenv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/README.rst b/README.rst index 7a289866..dfb8e89c 100644 --- a/README.rst +++ b/README.rst @@ -2,7 +2,7 @@ anesthetic: nested sampling post-processing =========================================== :Authors: Will Handley and Lukas Hergt -:Version: 2.5.0 +:Version: 2.8.0 :Homepage: https://github.com/handley-lab/anesthetic :Documentation: http://anesthetic.readthedocs.io/ diff --git a/anesthetic/__init__.py b/anesthetic/__init__.py index a707354e..732b238f 100644 --- a/anesthetic/__init__.py +++ b/anesthetic/__init__.py @@ -9,7 +9,6 @@ import pandas.plotting._misc from anesthetic._format import _DataFrameFormatter from anesthetic._version import __version__ # noqa: F401 -print('test tension branch') # TODO: remove this when conda pandas version catches up from packaging.version import parse assert parse(pandas.__version__) >= parse('2.0.0') diff --git a/anesthetic/_version.py b/anesthetic/_version.py index e59b17b4..f2df444a 100644 --- a/anesthetic/_version.py +++ b/anesthetic/_version.py @@ -1 +1 @@ -__version__ = '2.5.0' +__version__ = '2.8.0' diff --git a/anesthetic/tension_pvalue.py b/anesthetic/tension_pvalue.py new file mode 100644 index 00000000..06bdea66 --- /dev/null +++ b/anesthetic/tension_pvalue.py @@ -0,0 +1,27 @@ +from anesthetic.samples import Samples +from scipy.stats import chi2 + + +def tension_stats(A, B, AB, nsamples, beta): + # Compute Nested Sampling statistics + statsA = A.stats(nsamples, beta) + statsB = B.stats(nsamples, beta) + statsAB = AB.stats(nsamples, beta) + + samples = Samples(index=statsA.index) + print(samples) + logR = statsAB.logZ-statsA.logZ-statsB.logZ + samples['logR'] = logR + + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI'] = logI + + logS = logR-logI + samples['logS'] = logS + + d_G = statsA.d_G + statsB.d_G - statsAB.d_G + samples['d_G'] = d_G + + p = chi2.sf(d_G-2*logS, d_G) + samples['p'] = p + return samples diff --git a/pairwise_comparison.py b/pairwise_comparison.py deleted file mode 100644 index 841c0adf..00000000 --- a/pairwise_comparison.py +++ /dev/null @@ -1,58 +0,0 @@ -from anesthetic import read_chains, make_2d_axes -from anesthetic.tension import tension_stats - - -# Change dir1, dir2 and dir3 to change datasets for comparison -dir1 = 'bao.sdss_dr16' -dir2 = 'planck_2018_plik' #'planck_2018_CamSpec'#'planck_2018_plik_nolens' #'planck_2018_CamSpec_nolens' -dir3 = "+".join(sorted([dir1,dir2])) # Put dir1 and dir2 in alphabetical order - -dir_list = ['bao.sdss_dr16','bicep_keck_2018','des_y1.joint','planck_2018_CamSpec','planck_2018_CamSpec_nolens','planck_2018_plik','planck_2018_plik_nolens','sn.pantheon','bicep_keck_2018'] - - -# Read the chains for the 3 datasets to be compared -samples1 = read_chains(f"../ns/klcdm/{dir1}/{dir1}_polychord_raw/{dir1}") -samples2 = read_chains(f"../ns/klcdm/{dir2}/{dir2}_polychord_raw/{dir2}") -samples3 = read_chains(f"../ns/klcdm/{dir3}/{dir3}_polychord_raw/{dir3}") - -#%% -# Make a fig and axes, set the parameters to plot -fig, axes = make_2d_axes(['omk', 'H0', 'omegam']) # must match the column index -# Plot datasets on the same ax -samples1.plot_2d(axes, label='BAO') -samples2.plot_2d(axes, label='Planck') -samples3.plot_2d(axes, label='BAO+Planck') -# Set location of legend -axes.iloc[-1, 0].legend(loc='lower center', bbox_to_anchor=(len(axes)/2, len(axes))) - - -#%% -nsamples = 1000 -beta = 1 -samples = tension_stats(samples1,samples2,samples3,nsamples,beta) -#%% -fig, ax = plt.subplots(2,2) - -#%% -plt.figure() -plt.title('logR') -samples.logR.plot.hist() -plt.show() - -plt.figure() -plt.title('logI') -samples.logI.plot.hist() -plt.show() - -plt.figure() -plt.title('logS') -samples.logS.plot.hist() -plt.show() - -plt.figure() -plt.title('d_G') -samples.d_G.plot.hist() -plt.show() - - -# %% diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py index 4607d2d5..07258b9b 100644 --- a/tests/test_tension_stats.py +++ b/tests/test_tension_stats.py @@ -1,6 +1,8 @@ +#from anesthetic.samples import Samples from anesthetic.examples.perfect_ns import correlated_gaussian +#from anesthetic import read_chains, make_2d_axes import numpy as np -import matplotlib.pyplot as plt +#import matplotlib.pyplot as plt from scipy import linalg from anesthetic.tension import tension_stats @@ -18,32 +20,27 @@ def get_covAB(covA, covB): def get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0): meandiff = np.array(meanA)-np.array(meanB) - logLmaxAB = -1/2 * meandiff@linalg.solve(covA+covB, meandiff)+logLmaxA - +logLmaxB + logLmaxAB = (-1/2 * meandiff@linalg.solve(covA+covB, meandiff) + + logLmaxA + logLmaxB) return logLmaxAB def get_logR(meanA, meanB, covA, covB, V): meandiff = np.array(meanA)-np.array(meanB) - logR = -1/2*meandiff@linalg.solve(covA+covB, meandiff) - -1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) + logR = (-1/2*meandiff@linalg.solve(covA+covB, meandiff) - + 1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) return logR - def get_logS(meanA, meanB, covA, covB, d): meandiff = np.array(meanA)-np.array(meanB) logS = d/2 - 1/2*meandiff@linalg.solve(covA+covB, meandiff) return logS - def get_logI(covA, covB, d, V): - logI = - d/2 - 1/2 * np.log(linalg.det(2*np.pi*(covA + covB))) + np.log(V) + logI = -d/2 - 1/2 * np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) return logI - -def test_tension_stats_compatiable_gaussian(samples_plot=False, - stats_table=False, - stats_plot=False, hist_plot=False): +def test_tension_stats_compatiable_gaussian(): nlive = 1000 bounds = [[0, 1], [0, 1], [0, 1]] @@ -56,7 +53,7 @@ def test_tension_stats_compatiable_gaussian(samples_plot=False, covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 logLmaxB = 0 samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) - + covAB = get_covAB(covA, covB) meanAB = get_meanAB(meanA, meanB, covA, covB, covAB) logLmaxAB = get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0) @@ -65,57 +62,26 @@ def test_tension_stats_compatiable_gaussian(samples_plot=False, nsamples = 1000 beta = 1 samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + + logR_std = samples.logR.std() + logR_mean = samples.logR.mean() - logR_min = samples.logR.min() - logR_max = samples.logR.max() - - logS_min = samples.logS.min() - logS_max = samples.logS.max() + logS_std = samples.logS.std() + logS_mean = samples.logS.mean() - logI_min = samples.logI.min() - logI_max = samples.logI.max() + logI_std = samples.logI.std() + logI_mean = samples.logI.mean() logR_exact = get_logR(meanA, meanB, covA, covB, V=1) logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) logI_exact = get_logI(covA, covB, d=len(bounds), V=1) - if samples_plot: - axes = samplesA.plot_2d([0, 1, 2]) - samplesB.plot_2d(axes) - samplesAB.plot_2d(axes) - - if stats_table: - print(samples) - - if stats_plot: - axes = samples.plot_2d(['logR', 'logI', 'logS', 'd_G']) - - if hist_plot: - plt.figure() - samples.logR.plot.hist() - plt.axvline(logR_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logS.plot.hist() - plt.axvline(logS_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logI.plot.hist() - plt.axvline(logI_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - assert logR_min < logR_exact < logR_max - assert logS_min < logS_exact < logS_max - assert logI_min < logI_exact < logI_max + assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std -def test_tension_stats_incompatiable_gaussian(samples_plot=False, - stats_table=False, stats_plot=False, hist_plot=False): +def test_tension_stats_incompatiable_gaussian(): nlive = 1000 bounds = [[0, 1], [0, 1], [0, 1]] @@ -138,49 +104,19 @@ def test_tension_stats_incompatiable_gaussian(samples_plot=False, beta = 1 samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) - logR_min = samples.logR.min() - logR_max = samples.logR.max() + logR_std = samples.logR.std() + logR_mean = samples.logR.mean() - logS_min = samples.logS.min() - logS_max = samples.logS.max() + logS_std = samples.logS.std() + logS_mean = samples.logS.mean() - logI_min = samples.logI.min() - logI_max = samples.logI.max() + logI_std = samples.logI.std() + logI_mean = samples.logI.mean() logR_exact = get_logR(meanA, meanB, covA, covB, V=1) logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) logI_exact = get_logI(covA, covB, d=len(bounds), V=1) - if samples_plot: - axes = samplesA.plot_2d([0, 1, 2]) - samplesB.plot_2d(axes) - samplesAB.plot_2d(axes) - - if stats_table: - print(samples) - - if stats_plot: - axes = samples.plot_2d(['logR', 'logI', 'logS', 'd_G']) - - if hist_plot: - plt.figure() - samples.logR.plot.hist() - plt.axvline(logR_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logS.plot.hist() - plt.axvline(logS_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logI.plot.hist() - plt.axvline(logI_exact, color='r', label='Exact solution') - plt.legend() - plt.show() - - assert logR_min < logR_exact < logR_max - assert logS_min < logS_exact < logS_max - assert logI_min < logI_exact < logI_max \ No newline at end of file + assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std diff --git a/tests/test_tension_stats_2.py b/tests/test_tension_stats_2.py deleted file mode 100644 index d55a1cc1..00000000 --- a/tests/test_tension_stats_2.py +++ /dev/null @@ -1,184 +0,0 @@ -#%% -from anesthetic.samples import Samples -from anesthetic.examples.perfect_ns import correlated_gaussian -from anesthetic import read_chains, make_2d_axes -import numpy as np -import matplotlib.pyplot as plt -from scipy import linalg -from anesthetic.tension import tension_stats - - -def get_meanAB(meanA, meanB,covA,covB,covAB): - meanAB = covAB@(np.linalg.solve(covA,meanA)+np.linalg.solve(covB,meanB)) - return meanAB - -def get_covAB(covA,covB): - covAB_inv = linalg.inv(covA) + linalg.inv(covB) - covAB = linalg.inv(covAB_inv) - return covAB - -def get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0): - meandiff = np.array(meanA)-np.array(meanB) - logLmaxAB = -1/2 * meandiff@linalg.solve(covA+covB,meandiff)+logLmaxA+logLmaxB - return logLmaxAB - -def get_logR(meanA,meanB,covA,covB,V): - meandiff = np.array(meanA)-np.array(meanB) - logR = -1/2*meandiff@linalg.solve(covA+covB,meandiff)-1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1]+np.log(V) - return logR - -def get_logS(meanA,meanB,covA,covB,d): - meandiff = np.array(meanA)-np.array(meanB) - logS = d/2 - 1/2*meandiff@linalg.solve(covA+covB,meandiff) - return logS - -def get_logI(covA,covB,d,V): - logI = -d/2 -1/2* np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) - return logI - -def test_tension_stats_compatiable_gaussian(samples_plot=True,stats_table=True, stats_plot=True, hist_plot=True): - nlive = 1000 - bounds = [[0, 1], [0,1], [0, 1]] - - meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 - logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) - - meanB = [0.1, 0.3, 0.5] - covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 - logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) - - covAB = get_covAB(covA,covB) - meanAB = get_meanAB(meanA, meanB,covA,covB,covAB) - logLmaxAB = get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0) - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) - - nsamples = 1000 - beta = 1 - samples = tension_stats(samplesA,samplesB,samplesAB,nsamples,beta) - - logR_min = samples.logR.min() - logR_max = samples.logR.max() - - logS_min = samples.logS.min() - logS_max = samples.logS.max() - - logI_min = samples.logI.min() - logI_max = samples.logI.max() - - logR_exact = get_logR(meanA,meanB,covA,covB,V=1) - logS_exact = get_logS(meanA,meanB,covA,covB,d=len(bounds)) - logI_exact = get_logI(covA,covB,d=len(bounds),V=1) - - if samples_plot: - axes = samplesA.plot_2d([0,1,2]) - samplesB.plot_2d(axes) - samplesAB.plot_2d(axes) - - if stats_table: - print(samples) - - if stats_plot: - axes = samples.plot_2d(['logR','logI','logS','d_G']) - - if hist_plot: - plt.figure() - samples.logR.plot.hist() - plt.axvline(logR_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logS.plot.hist() - plt.axvline(logS_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logI.plot.hist() - plt.axvline(logI_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - assert logR_min < logR_exact < logR_max - assert logS_min < logS_exact < logS_max - assert logI_min < logI_exact < logI_max - - - -def test_tension_stats_incompatiable_gaussian(samples_plot=True,stats_table=True, stats_plot=True, hist_plot=True): - nlive = 1000 - bounds = [[0, 1], [0,1], [0, 1]] - - meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 - logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) - - meanB = [0.15, 0.25, 0.45] - covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 - logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds,logLmaxB) - - covAB = get_covAB(covA,covB) - meanAB = get_meanAB(meanA, meanB,covA,covB,covAB) - logLmaxAB = get_logLmaxAB(meanA,meanB,covA,covB,logLmaxA=0, logLmaxB=0) - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) - - nsamples = 1000 - beta = 1 - samples = tension_stats(samplesA,samplesB,samplesAB,nsamples,beta) - - logR_min = samples.logR.min() - logR_max = samples.logR.max() - - logS_min = samples.logS.min() - logS_max = samples.logS.max() - - logI_min = samples.logI.min() - logI_max = samples.logI.max() - - logR_exact = get_logR(meanA,meanB,covA,covB,V=1) - logS_exact = get_logS(meanA,meanB,covA,covB,d=len(bounds)) - logI_exact = get_logI(covA,covB,d=len(bounds),V=1) - - if samples_plot: - axes = samplesA.plot_2d([0,1,2]) - samplesB.plot_2d(axes) - samplesAB.plot_2d(axes) - - if stats_table: - print(samples) - - if stats_plot: - axes = samples.plot_2d(['logR','logI','logS','d_G']) - - if hist_plot: - plt.figure() - samples.logR.plot.hist() - plt.axvline(logR_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logS.plot.hist() - plt.axvline(logS_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - plt.figure() - samples.logI.plot.hist() - plt.axvline(logI_exact,color='r',label='Exact solution') - plt.legend() - plt.show() - - assert logR_min < logR_exact < logR_max - assert logS_min < logS_exact < logS_max - assert logI_min < logI_exact < logI_max - - -test_tension_stats_compatiable_gaussian() -#test_tension_stats_incompatiable_gaussian() -# %% From b0994b3ae27a30b6b8cfe6faa9199cabb60c89c4 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Tue, 5 Mar 2024 10:12:42 +0000 Subject: [PATCH 14/49] bump version to 2.9.0 --- README.rst | 2 +- anesthetic/_version.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index dfb8e89c..d9b8554e 100644 --- a/README.rst +++ b/README.rst @@ -2,7 +2,7 @@ anesthetic: nested sampling post-processing =========================================== :Authors: Will Handley and Lukas Hergt -:Version: 2.8.0 +:Version: 2.9.0 :Homepage: https://github.com/handley-lab/anesthetic :Documentation: http://anesthetic.readthedocs.io/ diff --git a/anesthetic/_version.py b/anesthetic/_version.py index f2df444a..387cfacc 100644 --- a/anesthetic/_version.py +++ b/anesthetic/_version.py @@ -1 +1 @@ -__version__ = '2.8.0' +__version__ = '2.9.0' From aec6a25c7376e4a4c07d699debb91d1f7adf3091 Mon Sep 17 00:00:00 2001 From: dilyong Date: Tue, 5 Mar 2024 16:10:36 +0000 Subject: [PATCH 15/49] Deleted duplicate files. --- anesthetic/tension.py | 30 ++++++++++++++++++++---------- anesthetic/tension_pvalue.py | 27 --------------------------- tests/test_tension_stats.py | 3 --- 3 files changed, 20 insertions(+), 40 deletions(-) delete mode 100644 anesthetic/tension_pvalue.py diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 1e9f7153..06bdea66 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -1,17 +1,27 @@ from anesthetic.samples import Samples +from scipy.stats import chi2 -def tension_stats(A,B,AB,nsamples,beta): +def tension_stats(A, B, AB, nsamples, beta): # Compute Nested Sampling statistics - statsA = A.stats(nsamples,beta) - statsB = B.stats(nsamples,beta) - statsAB = AB.stats(nsamples,beta) + statsA = A.stats(nsamples, beta) + statsB = B.stats(nsamples, beta) + statsAB = AB.stats(nsamples, beta) samples = Samples(index=statsA.index) + print(samples) logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR']=logR - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI']=logI - samples['logS']=logR-logI - samples['d_G']=statsA.d_G + statsB.d_G - statsAB.d_G - return samples \ No newline at end of file + samples['logR'] = logR + + logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL + samples['logI'] = logI + + logS = logR-logI + samples['logS'] = logS + + d_G = statsA.d_G + statsB.d_G - statsAB.d_G + samples['d_G'] = d_G + + p = chi2.sf(d_G-2*logS, d_G) + samples['p'] = p + return samples diff --git a/anesthetic/tension_pvalue.py b/anesthetic/tension_pvalue.py deleted file mode 100644 index 06bdea66..00000000 --- a/anesthetic/tension_pvalue.py +++ /dev/null @@ -1,27 +0,0 @@ -from anesthetic.samples import Samples -from scipy.stats import chi2 - - -def tension_stats(A, B, AB, nsamples, beta): - # Compute Nested Sampling statistics - statsA = A.stats(nsamples, beta) - statsB = B.stats(nsamples, beta) - statsAB = AB.stats(nsamples, beta) - - samples = Samples(index=statsA.index) - print(samples) - logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR'] = logR - - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI'] = logI - - logS = logR-logI - samples['logS'] = logS - - d_G = statsA.d_G + statsB.d_G - statsAB.d_G - samples['d_G'] = d_G - - p = chi2.sf(d_G-2*logS, d_G) - samples['p'] = p - return samples diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py index 07258b9b..cb6a61aa 100644 --- a/tests/test_tension_stats.py +++ b/tests/test_tension_stats.py @@ -1,8 +1,5 @@ -#from anesthetic.samples import Samples from anesthetic.examples.perfect_ns import correlated_gaussian -#from anesthetic import read_chains, make_2d_axes import numpy as np -#import matplotlib.pyplot as plt from scipy import linalg from anesthetic.tension import tension_stats From 03b9b1c07f38bb3b70d1763ed7465fabedc6a40c Mon Sep 17 00:00:00 2001 From: Will Handley Date: Mon, 18 Mar 2024 09:51:47 +0000 Subject: [PATCH 16/49] Reorganised tests --- tests/test_tension.py | 99 ++++++++++++++++++++++++++++++ tests/test_tension_stats.py | 119 ------------------------------------ 2 files changed, 99 insertions(+), 119 deletions(-) create mode 100644 tests/test_tension.py delete mode 100644 tests/test_tension_stats.py diff --git a/tests/test_tension.py b/tests/test_tension.py new file mode 100644 index 00000000..e193d64d --- /dev/null +++ b/tests/test_tension.py @@ -0,0 +1,99 @@ +from anesthetic.examples.perfect_ns import correlated_gaussian +import numpy as np +from scipy.linalg import inv, solve, slogdet +from anesthetic.tension import tension_stats + + +def test_tension_stats_compatiable_gaussian(): + d = 3 + V = 1. + nlive = 1000 + bounds = [[0, 1], [0, 1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], + [0.009, .01, 0], + [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.1, 0.3, 0.5] + covB = np.array([[.01, -0.009, 0.01], + [-0.009, .01, -0.001], + [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + + covAB = inv(inv(covA) + inv(covB)) + meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) + dmeanAB = meanA-meanB + logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + + logR_std = samples.logR.std() + logR_mean = samples.logR.mean() + logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - + 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) + assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + + logS_std = samples.logS.std() + logS_mean = samples.logS.mean() + logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) + assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + + logI_std = samples.logI.std() + logI_mean = samples.logI.mean() + logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) + assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std + + +def test_tension_stats_incompatiable_gaussian(): + np.random.rand(0) + d = 3 + V = 1. + nlive = 1000 + bounds = [[0, 1], [0, 1], [0, 1]] + + meanA = [0.1, 0.3, 0.5] + covA = np.array([[.01, 0.009, 0], + [0.009, .01, 0], + [0, 0, 0.1]])*0.01 + logLmaxA = 0 + samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + + meanB = [0.15, 0.25, 0.45] + covB = np.array([[.01, -0.009, 0.01], + [-0.009, .01, -0.001], + [0.01, -0.001, 0.1]])*0.01 + logLmaxB = 0 + samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + + covAB = inv(inv(covA) + inv(covB)) + meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) + dmeanAB = meanA-meanB + logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB + samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + + nsamples = 1000 + beta = 1 + samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + + logR_std = samples.logR.std() + logR_mean = samples.logR.mean() + logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - + 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) + assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + + logS_std = samples.logS.std() + logS_mean = samples.logS.mean() + logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) + assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + + logI_std = samples.logI.std() + logI_mean = samples.logI.mean() + logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) + assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std diff --git a/tests/test_tension_stats.py b/tests/test_tension_stats.py deleted file mode 100644 index cb6a61aa..00000000 --- a/tests/test_tension_stats.py +++ /dev/null @@ -1,119 +0,0 @@ -from anesthetic.examples.perfect_ns import correlated_gaussian -import numpy as np -from scipy import linalg -from anesthetic.tension import tension_stats - - -def get_meanAB(meanA, meanB, covA, covB, covAB): - meanAB = covAB@(np.linalg.solve(covA, meanA)+np.linalg.solve(covB, meanB)) - return meanAB - - -def get_covAB(covA, covB): - covAB_inv = linalg.inv(covA) + linalg.inv(covB) - covAB = linalg.inv(covAB_inv) - return covAB - - -def get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0): - meandiff = np.array(meanA)-np.array(meanB) - logLmaxAB = (-1/2 * meandiff@linalg.solve(covA+covB, meandiff) + - logLmaxA + logLmaxB) - return logLmaxAB - - -def get_logR(meanA, meanB, covA, covB, V): - meandiff = np.array(meanA)-np.array(meanB) - logR = (-1/2*meandiff@linalg.solve(covA+covB, meandiff) - - 1/2*np.linalg.slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) - return logR - -def get_logS(meanA, meanB, covA, covB, d): - meandiff = np.array(meanA)-np.array(meanB) - logS = d/2 - 1/2*meandiff@linalg.solve(covA+covB, meandiff) - return logS - -def get_logI(covA, covB, d, V): - logI = -d/2 - 1/2 * np.log(linalg.det(2*np.pi*(covA+covB))) + np.log(V) - return logI - -def test_tension_stats_compatiable_gaussian(): - nlive = 1000 - bounds = [[0, 1], [0, 1], [0, 1]] - - meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 - logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) - - meanB = [0.1, 0.3, 0.5] - covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 - logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) - - covAB = get_covAB(covA, covB) - meanAB = get_meanAB(meanA, meanB, covA, covB, covAB) - logLmaxAB = get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0) - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) - - nsamples = 1000 - beta = 1 - samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) - - logR_std = samples.logR.std() - logR_mean = samples.logR.mean() - - logS_std = samples.logS.std() - logS_mean = samples.logS.mean() - - logI_std = samples.logI.std() - logI_mean = samples.logI.mean() - - logR_exact = get_logR(meanA, meanB, covA, covB, V=1) - logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) - logI_exact = get_logI(covA, covB, d=len(bounds), V=1) - - assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std - assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std - assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std - - -def test_tension_stats_incompatiable_gaussian(): - nlive = 1000 - bounds = [[0, 1], [0, 1], [0, 1]] - - meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], [0.009, .01, 0], [0, 0, 0.1]])*0.01 - logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) - - meanB = [0.15, 0.25, 0.45] - covB = np.array([[.01, -0.009, 0.01], [-0.009, .01, -0.001], [0.01, -0.001, 0.1]])*0.01 - logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) - - covAB = get_covAB(covA, covB) - meanAB = get_meanAB(meanA, meanB, covA, covB, covAB) - logLmaxAB = get_logLmaxAB(meanA, meanB, covA, covB, logLmaxA=0, logLmaxB=0) - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) - - nsamples = 1000 - beta = 1 - samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) - - logR_std = samples.logR.std() - logR_mean = samples.logR.mean() - - logS_std = samples.logS.std() - logS_mean = samples.logS.mean() - - logI_std = samples.logI.std() - logI_mean = samples.logI.mean() - - logR_exact = get_logR(meanA, meanB, covA, covB, V=1) - logS_exact = get_logS(meanA, meanB, covA, covB, d=len(bounds)) - logI_exact = get_logI(covA, covB, d=len(bounds), V=1) - - assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std - assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std - assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std From 9dd5ca1ea8dfa210ac35d59c302856a7e6f43677 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Mon, 18 Mar 2024 10:04:07 +0000 Subject: [PATCH 17/49] numpy linalg --- tests/test_tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index e193d64d..bdd77914 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -1,6 +1,6 @@ from anesthetic.examples.perfect_ns import correlated_gaussian import numpy as np -from scipy.linalg import inv, solve, slogdet +from numpy.linalg import inv, solve, slogdet from anesthetic.tension import tension_stats From e82f125b67bd138fdb7156bd7776941c1ff3faed Mon Sep 17 00:00:00 2001 From: dilyong Date: Wed, 20 Mar 2024 23:48:09 +0000 Subject: [PATCH 18/49] For anesthetic.tension.tension_stats(), I 1) added docstrings, 2) added latex labels, 3) set nsamples=None and beta=None to match NestedSamples.stats, 4) changed samples to samples_stats for a more instructive name. I have tested the updated anesthetic.tension.tension_stats() using the tests/test_tension.py and no AssertionError is raised. I printed out the output of tension_stats() and checked that the latex labels are fine. --- anesthetic/tension.py | 83 +++++++++++++++++++++++++++++++++++++------ tests/test_tension.py | 34 +++++++++--------- 2 files changed, 91 insertions(+), 26 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 06bdea66..5868210d 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -2,26 +2,89 @@ from scipy.stats import chi2 -def tension_stats(A, B, AB, nsamples, beta): - # Compute Nested Sampling statistics +def tension_stats(A, B, AB, nsamples=None, beta=None): + r"""Compute tension statistics between two samples + + Using nested sampling we can compute: + + - ``logZ``: Bayesian evidence + + .. math:: + \log Z = \int L \pi d\theta + + - ``D_KL``: Kullback--Leibler divergence + + .. math:: + D_{KL} = \int P \log(P / \pi) d\theta + + - ``logL_P``: posterior averaged log-likelihood + + .. math:: + \langle\log L\rangle_P = \int P \log L d\theta + + - ``d_G``: Gaussian model dimensionality + (or posterior variance of the log-likelihood) + + .. math:: + d_G/2 = \langle(\log L)^2\rangle_P - \langle\log L\rangle_P^2 + + - ``p``: p-value for the tension between two samples + + .. math:: + p = \int_{d_G - 2 \log S}^{\infty} \chi^2 (x)dx + + Parameters + ---------- + A : :class:`Samples`/:class:`NestedSamples` + Dataset A + List or array-like of one or more nested sampling runs + + B : :class:`Samples`/:class:`NestedSamples` + Dataset B + List or array-like of one or more nested sampling runs + + AB : :class:`Samples`/:class:`NestedSamples` + Dataset AB + List or array-like of one or more nested sampling runs + + nsamples : int, optional + - If nsamples is not supplied, calculate mean value + - If nsamples is integer, draw nsamples from the distribution of + values inferred by nested sampling + + beta : float, array-like, optional + inverse temperature(s) beta=1/kT. Default self.beta + + Returns + ------- + samples_stats : :class:`pandas.DataFrame` + DataFrame containing the following tension statistics: + logZ, D_KL, logL_P, d_G, p + """ + statsA = A.stats(nsamples, beta) statsB = B.stats(nsamples, beta) statsAB = AB.stats(nsamples, beta) - samples = Samples(index=statsA.index) - print(samples) + samples_stats = Samples(index=statsA.index) + logR = statsAB.logZ-statsA.logZ-statsB.logZ - samples['logR'] = logR + samples_stats['logR'] = logR + samples_stats.set_label('logR', r'$\log{R}$') logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples['logI'] = logI + samples_stats['logI'] = logI + samples_stats.set_label('logI', r'$\log{I}$') logS = logR-logI - samples['logS'] = logS + samples_stats['logS'] = logS + samples_stats.set_label('logS', r'$\log{S}$') d_G = statsA.d_G + statsB.d_G - statsAB.d_G - samples['d_G'] = d_G + samples_stats['d_G'] = d_G + samples_stats.set_label('d_G', r'$d_G$') p = chi2.sf(d_G-2*logS, d_G) - samples['p'] = p - return samples + samples_stats['p'] = p + samples_stats.set_label('p', r'$p$') + return samples_stats diff --git a/tests/test_tension.py b/tests/test_tension.py index bdd77914..976a287f 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -26,27 +26,28 @@ def test_tension_stats_compatiable_gaussian(): covAB = inv(inv(covA) + inv(covB)) meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) - dmeanAB = meanA-meanB + dmeanAB = np.array(meanA)-np.array(meanB) logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) nsamples = 1000 beta = 1 - samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + samples_stats = tension_stats(samplesA, samplesB, samplesAB, + nsamples, beta) - logR_std = samples.logR.std() - logR_mean = samples.logR.mean() + logR_std = samples_stats.logR.std() + logR_mean = samples_stats.logR.mean() logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std - logS_std = samples.logS.std() - logS_mean = samples.logS.mean() + logS_std = samples_stats.logS.std() + logS_mean = samples_stats.logS.mean() logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std - logI_std = samples.logI.std() - logI_mean = samples.logI.mean() + logI_std = samples_stats.logI.std() + logI_mean = samples_stats.logI.mean() logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std @@ -74,26 +75,27 @@ def test_tension_stats_incompatiable_gaussian(): covAB = inv(inv(covA) + inv(covB)) meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) - dmeanAB = meanA-meanB + dmeanAB = np.array(meanA)-np.array(meanB) logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) nsamples = 1000 beta = 1 - samples = tension_stats(samplesA, samplesB, samplesAB, nsamples, beta) + samples_stats = tension_stats(samplesA, samplesB, samplesAB, + nsamples, beta) - logR_std = samples.logR.std() - logR_mean = samples.logR.mean() + logR_std = samples_stats.logR.std() + logR_mean = samples_stats.logR.mean() logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std - logS_std = samples.logS.std() - logS_mean = samples.logS.mean() + logS_std = samples_stats.logS.std() + logS_mean = samples_stats.logS.mean() logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std - logI_std = samples.logI.std() - logI_mean = samples.logI.mean() + logI_std = samples_stats.logI.std() + logI_mean = samples_stats.logI.mean() logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std From 979f6218651421ec25967beaffa77dec2ac95bf2 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 21 Mar 2024 00:17:34 +0000 Subject: [PATCH 19/49] Added docstring in public module. --- anesthetic/tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 5868210d..91773403 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -1,3 +1,4 @@ +"""Tension statistics between two datasets""" from anesthetic.samples import Samples from scipy.stats import chi2 @@ -61,7 +62,6 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): DataFrame containing the following tension statistics: logZ, D_KL, logL_P, d_G, p """ - statsA = A.stats(nsamples, beta) statsB = B.stats(nsamples, beta) statsAB = AB.stats(nsamples, beta) From 84c8e6e04ee92e31f39f749fdc5cd2a187754258 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 21 Mar 2024 14:05:18 +0000 Subject: [PATCH 20/49] Fixed pydocstyle issue. --- anesthetic/tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 91773403..d20c0c9c 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -1,4 +1,4 @@ -"""Tension statistics between two datasets""" +"""Tension statistics between two datasets.""" from anesthetic.samples import Samples from scipy.stats import chi2 From 99091909e3d2a95ea8c62449e607d2f4e4f33a4c Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 21 Mar 2024 14:21:04 +0000 Subject: [PATCH 21/49] Fixed pydocstyle issue. --- anesthetic/tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index d20c0c9c..501e60cc 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -4,7 +4,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): - r"""Compute tension statistics between two samples + r"""Compute tension statistics between two samples. Using nested sampling we can compute: From 6723f4c70716449e083125df766aa1cfe687b4c1 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 4 Apr 2024 18:23:17 +0100 Subject: [PATCH 22/49] In test_tension.py, 1) added a test for latex labels, and 2) changed the volume V to 6 and changed the bounds. --- tests/test_tension.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index 976a287f..9741bb6f 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -6,9 +6,9 @@ def test_tension_stats_compatiable_gaussian(): d = 3 - V = 1. + V = 6.0 nlive = 1000 - bounds = [[0, 1], [0, 1], [0, 1]] + bounds = [[-1, 1], [0, 3], [0, 1]] meanA = [0.1, 0.3, 0.5] covA = np.array([[.01, 0.009, 0], @@ -51,13 +51,17 @@ def test_tension_stats_compatiable_gaussian(): logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std + assert samples_stats.get_labels().tolist() == (['$\\log{R}$', + '$\\log{I}$', '$\\log{S}$', + '$d_G$', '$p$']) + def test_tension_stats_incompatiable_gaussian(): np.random.rand(0) d = 3 - V = 1. + V = 6. nlive = 1000 - bounds = [[0, 1], [0, 1], [0, 1]] + bounds = [[-1, 1], [0, 3], [0, 1]] meanA = [0.1, 0.3, 0.5] covA = np.array([[.01, 0.009, 0], @@ -99,3 +103,7 @@ def test_tension_stats_incompatiable_gaussian(): logI_mean = samples_stats.logI.mean() logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std + + assert samples_stats.get_labels().tolist() == (['$\\log{R}$', + '$\\log{I}$', '$\\log{S}$', + '$d_G$', '$p$']) From 9739361b45886f35ebdfc1780bc3d958f5091171 Mon Sep 17 00:00:00 2001 From: dilyong Date: Thu, 4 Apr 2024 18:27:10 +0100 Subject: [PATCH 23/49] Changed V --- tests/test_tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index 9741bb6f..780e6cbd 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -59,7 +59,7 @@ def test_tension_stats_compatiable_gaussian(): def test_tension_stats_incompatiable_gaussian(): np.random.rand(0) d = 3 - V = 6. + V = 6.0 nlive = 1000 bounds = [[-1, 1], [0, 3], [0, 1]] From 25ab2c1f926fe39e1a4e4bac4892fe2f417e5ec6 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Fri, 5 Apr 2024 11:46:27 +0100 Subject: [PATCH 24/49] typographical changes --- anesthetic/tension.py | 12 ++++++------ tests/test_tension.py | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 501e60cc..5b7d9e5b 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -11,28 +11,28 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): - ``logZ``: Bayesian evidence .. math:: - \log Z = \int L \pi d\theta + \log Z = \log \int L \pi d\theta - ``D_KL``: Kullback--Leibler divergence .. math:: - D_{KL} = \int P \log(P / \pi) d\theta + D_{KL} = \int \mathcal{P} \log(\mathcal{P} / \pi) d\theta - ``logL_P``: posterior averaged log-likelihood .. math:: - \langle\log L\rangle_P = \int P \log L d\theta + \langle\log L\rangle_\mathcal{P} = \int \mathcal{P} \log L d\theta - ``d_G``: Gaussian model dimensionality (or posterior variance of the log-likelihood) .. math:: - d_G/2 = \langle(\log L)^2\rangle_P - \langle\log L\rangle_P^2 + d_\mathrm{G}/2 = \mathrm{var}(\log L)_\mathcal{P} - ``p``: p-value for the tension between two samples .. math:: - p = \int_{d_G - 2 \log S}^{\infty} \chi^2 (x)dx + p = \int_{d_\mathrm{G} - 2 \log S}^{\infty} \chi^2 (x)dx Parameters ---------- @@ -82,7 +82,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): d_G = statsA.d_G + statsB.d_G - statsAB.d_G samples_stats['d_G'] = d_G - samples_stats.set_label('d_G', r'$d_G$') + samples_stats.set_label('d_G', r'$d_\mathrm{G}$') p = chi2.sf(d_G-2*logS, d_G) samples_stats['p'] = p diff --git a/tests/test_tension.py b/tests/test_tension.py index 780e6cbd..0962445c 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -104,6 +104,6 @@ def test_tension_stats_incompatiable_gaussian(): logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std - assert samples_stats.get_labels().tolist() == (['$\\log{R}$', - '$\\log{I}$', '$\\log{S}$', - '$d_G$', '$p$']) + assert samples_stats.get_labels().tolist() == ([r'$\log{R}$', + r'$\log{I}$', r'$\log{S}$', + r'$d_\mathrm{G}$', r'$p$']) From 1691a02e31cdcec14cd5eb40eecf905194411449 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Fri, 5 Apr 2024 12:31:41 +0100 Subject: [PATCH 25/49] both tests correct --- tests/test_tension.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index 0962445c..bd0bdf89 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -51,9 +51,9 @@ def test_tension_stats_compatiable_gaussian(): logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std - assert samples_stats.get_labels().tolist() == (['$\\log{R}$', - '$\\log{I}$', '$\\log{S}$', - '$d_G$', '$p$']) + assert samples_stats.get_labels().tolist() == ([r'$\log{R}$', + r'$\log{I}$', r'$\log{S}$', + r'$d_\mathrm{G}$', r'$p$']) def test_tension_stats_incompatiable_gaussian(): From 110029ac24ecd0f28250bd6690abf31c28d4d752 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Fri, 5 Apr 2024 12:50:08 +0100 Subject: [PATCH 26/49] Correction to docstring kl --- anesthetic/tension.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 5b7d9e5b..047fb1a3 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -16,7 +16,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): - ``D_KL``: Kullback--Leibler divergence .. math:: - D_{KL} = \int \mathcal{P} \log(\mathcal{P} / \pi) d\theta + D_\mathrm{KL} = \int \mathcal{P} \log(\mathcal{P} / \pi) d\theta - ``logL_P``: posterior averaged log-likelihood From 89fab367f0210606b39a0c1efc6e0f96c578da06 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Fri, 5 Apr 2024 17:26:35 +0100 Subject: [PATCH 27/49] Further docstring updates --- anesthetic/tension.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 047fb1a3..69916ed5 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -16,18 +16,18 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): - ``D_KL``: Kullback--Leibler divergence .. math:: - D_\mathrm{KL} = \int \mathcal{P} \log(\mathcal{P} / \pi) d\theta + D_\mathrm{KL} = \int P \log(P / \pi) d\theta - ``logL_P``: posterior averaged log-likelihood .. math:: - \langle\log L\rangle_\mathcal{P} = \int \mathcal{P} \log L d\theta + \langle\log L\rangle_P = \int P \log L d\theta - ``d_G``: Gaussian model dimensionality (or posterior variance of the log-likelihood) .. math:: - d_\mathrm{G}/2 = \mathrm{var}(\log L)_\mathcal{P} + d_\mathrm{G}/2 = \mathrm{var}(\log L)_P - ``p``: p-value for the tension between two samples @@ -54,7 +54,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): values inferred by nested sampling beta : float, array-like, optional - inverse temperature(s) beta=1/kT. Default self.beta + inverse temperature(s) beta=1/kT. Default 1 Returns ------- @@ -62,9 +62,9 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): DataFrame containing the following tension statistics: logZ, D_KL, logL_P, d_G, p """ - statsA = A.stats(nsamples, beta) - statsB = B.stats(nsamples, beta) - statsAB = AB.stats(nsamples, beta) + statsA = A.stats(nsample=nsamples, beta=beta) + statsB = B.stats(nsample=nsamples, beta=beta) + statsAB = AB.stats(nsample=nsamples, beta=beta) samples_stats = Samples(index=statsA.index) From 8f2e60a77c4ab6301c6f9ee171d39006123dc240 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Mon, 8 Apr 2024 14:49:31 +0100 Subject: [PATCH 28/49] Corrected typo --- anesthetic/tension.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 69916ed5..95197adb 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -62,9 +62,9 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): DataFrame containing the following tension statistics: logZ, D_KL, logL_P, d_G, p """ - statsA = A.stats(nsample=nsamples, beta=beta) - statsB = B.stats(nsample=nsamples, beta=beta) - statsAB = AB.stats(nsample=nsamples, beta=beta) + statsA = A.stats(nsamples=nsamples, beta=beta) + statsB = B.stats(nsamples=nsamples, beta=beta) + statsAB = AB.stats(nsamples=nsamples, beta=beta) samples_stats = Samples(index=statsA.index) From 815a7e5a4261823b55a6e8f492a63971013ce19e Mon Sep 17 00:00:00 2001 From: lukashergt Date: Mon, 8 Apr 2024 15:48:01 -0700 Subject: [PATCH 29/49] fix link in docstring --- anesthetic/read/csv.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/read/csv.py b/anesthetic/read/csv.py index 3dd2713e..3a3ef0ea 100644 --- a/anesthetic/read/csv.py +++ b/anesthetic/read/csv.py @@ -5,7 +5,7 @@ def read_csv(filename, *args, **kwargs): - """Read a CSV file into a :class:`Samples` object.""" + """Read a CSV file into a :class:`anesthetic.samples.Samples` object.""" filename = Path(filename) kwargs['label'] = kwargs.get('label', filename.stem) wldf = wl_read_csv(filename.with_suffix('.csv')) From ab2d14eff9a5d3f5c5d6b70bf5779d29f01ac4c0 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Mon, 8 Apr 2024 15:48:49 -0700 Subject: [PATCH 30/49] add anesthetic.read.csv module to documentation --- docs/source/anesthetic.read.rst | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/source/anesthetic.read.rst b/docs/source/anesthetic.read.rst index 518686da..cf488135 100644 --- a/docs/source/anesthetic.read.rst +++ b/docs/source/anesthetic.read.rst @@ -25,6 +25,15 @@ anesthetic.read.cobaya module :show-inheritance: +anesthetic.read.csv module +-------------------------- + +.. automodule:: anesthetic.read.csv + :members: + :undoc-members: + :show-inheritance: + + anesthetic.read.getdist module ------------------------------ From c11c5f6ffde9fa6afdfc42f9cdc11b5a0861a65b Mon Sep 17 00:00:00 2001 From: lukashergt Date: Mon, 8 Apr 2024 15:49:34 -0700 Subject: [PATCH 31/49] add anesthetic.tension module to documentation --- docs/source/anesthetic.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/source/anesthetic.rst b/docs/source/anesthetic.rst index b256f3bb..266ccbe1 100644 --- a/docs/source/anesthetic.rst +++ b/docs/source/anesthetic.rst @@ -72,6 +72,7 @@ anesthetic.samples module .. automodule:: anesthetic.samples :members: :undoc-members: + :show-inheritance: anesthetic.scripts module @@ -83,6 +84,15 @@ anesthetic.scripts module :show-inheritance: +anesthetic.tension module +~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. automodule:: anesthetic.tension + :members: + :undoc-members: + :show-inheritance: + + anesthetic.testing module ~~~~~~~~~~~~~~~~~~~~~~~~~ From d1f1c2a859bd96b06c8f260fb5f3ce871e1700c4 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Mon, 8 Apr 2024 16:32:26 -0700 Subject: [PATCH 32/49] fix links and some formatting issues in `tension.py` docstrings --- anesthetic/tension.py | 48 +++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 95197adb..6b7b0e8e 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -3,62 +3,62 @@ from scipy.stats import chi2 -def tension_stats(A, B, AB, nsamples=None, beta=None): - r"""Compute tension statistics between two samples. +def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 + """Compute tension statistics between two samples. Using nested sampling we can compute: - ``logZ``: Bayesian evidence - .. math:: - \log Z = \log \int L \pi d\theta + .. math:: + \\log Z = \\log \\int L \\pi d\\theta - ``D_KL``: Kullback--Leibler divergence - .. math:: - D_\mathrm{KL} = \int P \log(P / \pi) d\theta + .. math:: + D_\\mathrm{KL} = \\int P \\log(P / \\pi) d\\theta - ``logL_P``: posterior averaged log-likelihood - .. math:: - \langle\log L\rangle_P = \int P \log L d\theta + .. math:: + \\langle\\log L\\rangle_P = \\int P \\log L d\\theta - ``d_G``: Gaussian model dimensionality - (or posterior variance of the log-likelihood) + (or posterior variance of the log-likelihood) - .. math:: - d_\mathrm{G}/2 = \mathrm{var}(\log L)_P + .. math:: + d_\\mathrm{G}/2 = \\mathrm{var}(\\log L)_P - ``p``: p-value for the tension between two samples - .. math:: - p = \int_{d_\mathrm{G} - 2 \log S}^{\infty} \chi^2 (x)dx + .. math:: + p = \\int_{d_\\mathrm{G} - 2 \\log S}^{\\infty} \\chi^2 (x)dx Parameters ---------- - A : :class:`Samples`/:class:`NestedSamples` - Dataset A - List or array-like of one or more nested sampling runs + A : :class:`anesthetic.samples.Samples` or \ + :class:`anesthetic.samples.NestedSamples` + (Nested) Samples from a sampling run using only dataset A. - B : :class:`Samples`/:class:`NestedSamples` - Dataset B - List or array-like of one or more nested sampling runs + B : :class:`anesthetic.samples.Samples` or \ + :class:`anesthetic.samples.NestedSamples` + (Nested) Samples from a sampling run using only dataset B. - AB : :class:`Samples`/:class:`NestedSamples` - Dataset AB - List or array-like of one or more nested sampling runs + AB : :class:`anesthetic.samples.Samples` or \ + :class:`anesthetic.samples.NestedSamples` + (Nested) Samples from a sampling run using datasets A and B jointly. nsamples : int, optional - If nsamples is not supplied, calculate mean value - If nsamples is integer, draw nsamples from the distribution of - values inferred by nested sampling + values inferred by nested sampling beta : float, array-like, optional inverse temperature(s) beta=1/kT. Default 1 Returns ------- - samples_stats : :class:`pandas.DataFrame` + samples_stats : :class:`anesthetic.samples.Samples` DataFrame containing the following tension statistics: logZ, D_KL, logL_P, d_G, p """ From 4947c6953f5f68d3b10d4eee84246dbb55f12b6f Mon Sep 17 00:00:00 2001 From: dilyong Date: Sun, 14 Apr 2024 15:59:56 +0100 Subject: [PATCH 33/49] Updated the docstrings in anesthetic/tension.py. --- anesthetic/tension.py | 22 ++++++++++++---------- tests/test.ipynb | 0 2 files changed, 12 insertions(+), 10 deletions(-) delete mode 100644 tests/test.ipynb diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 6b7b0e8e..334920d2 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -8,31 +8,33 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 Using nested sampling we can compute: - - ``logZ``: Bayesian evidence + - ``logR``: Logarithmic of R statistic .. math:: - \\log Z = \\log \\int L \\pi d\\theta + \\log R = \\log Z_\\mathrm{AB} - \\log Z_\\mathrm{A} + - \\log Z_\\mathrm{B} - - ``D_KL``: Kullback--Leibler divergence + - ``logI``: Logarithmic of information ratio .. math:: - D_\\mathrm{KL} = \\int P \\log(P / \\pi) d\\theta + \\log I = D_\\mathrm{KL}^A + D_\\mathrm{KL}^B - D_\\mathrm{KL}^{AB} - - ``logL_P``: posterior averaged log-likelihood + - ``logS``: Logarithmic of suspiciousness .. math:: - \\langle\\log L\\rangle_P = \\int P \\log L d\\theta + \\log S = \\log L_\\mathrm{AB} - \\log + L_\\mathrm{A} - \\log L_\\mathrm{B} - ``d_G``: Gaussian model dimensionality (or posterior variance of the log-likelihood) .. math:: - d_\\mathrm{G}/2 = \\mathrm{var}(\\log L)_P + d_\\mathrm{G}/2 = \\mathrm{var}(\\log L)_P - ``p``: p-value for the tension between two samples .. math:: - p = \\int_{d_\\mathrm{G} - 2 \\log S}^{\\infty} \\chi^2 (x)dx + p = \\int_{d_\\mathrm{G} - 2 \\log S}^{\\infty} \\chi^2 (x)dx Parameters ---------- @@ -60,7 +62,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 ------- samples_stats : :class:`anesthetic.samples.Samples` DataFrame containing the following tension statistics: - logZ, D_KL, logL_P, d_G, p + logR, logI, logS, d_G, p """ statsA = A.stats(nsamples=nsamples, beta=beta) statsB = B.stats(nsamples=nsamples, beta=beta) @@ -76,7 +78,7 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 samples_stats['logI'] = logI samples_stats.set_label('logI', r'$\log{I}$') - logS = logR-logI + logS = statsAB.logL_P - statsA.logL_P - statsB.logL_P samples_stats['logS'] = logS samples_stats.set_label('logS', r'$\log{S}$') diff --git a/tests/test.ipynb b/tests/test.ipynb deleted file mode 100644 index e69de29b..00000000 From 7a1078500fc050069d621e002bce0ba2ad782f75 Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 09:59:58 +0100 Subject: [PATCH 34/49] Updated docstrings --- anesthetic/tension.py | 26 +++++++++++++++----------- tests/example_data/.DS_Store | Bin 6148 -> 0 bytes tests/test_tension.py | 18 +++++++++--------- 3 files changed, 24 insertions(+), 20 deletions(-) delete mode 100644 tests/example_data/.DS_Store diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 334920d2..7a7353a9 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -3,7 +3,7 @@ from scipy.stats import chi2 -def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 +def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 """Compute tension statistics between two samples. Using nested sampling we can compute: @@ -11,30 +11,34 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 - ``logR``: Logarithmic of R statistic .. math:: - \\log R = \\log Z_\\mathrm{AB} - \\log Z_\\mathrm{A} - - \\log Z_\\mathrm{B} + \\log \mathcal{R} = \\log \mathcal{Z}_\\mathrm{AB} + - \\log \mathcal{Z}_\\mathrm{A} + - \\log \mathcal{Z}_\\mathrm{B} - ``logI``: Logarithmic of information ratio .. math:: - \\log I = D_\\mathrm{KL}^A + D_\\mathrm{KL}^B - D_\\mathrm{KL}^{AB} + \\log \mathcal{I} = \mathcal{D}_\\mathrm{KL}^A + + \mathcal{D}_\\mathrm{KL}^B + - \mathcal{D}_\\mathrm{KL}^{AB} - ``logS``: Logarithmic of suspiciousness .. math:: - \\log S = \\log L_\\mathrm{AB} - \\log - L_\\mathrm{A} - \\log L_\\mathrm{B} + \\log \mathcal{S} = \\log \mathcal{L}_\\mathrm{AB} + - \\log \mathcal{L}_\\mathrm{A} + - \\log \mathcal{L}_\\mathrm{B} - ``d_G``: Gaussian model dimensionality (or posterior variance of the log-likelihood) .. math:: - d_\\mathrm{G}/2 = \\mathrm{var}(\\log L)_P + d_\\mathrm{G}/2 = \\mathrm{var}(\\log \mathcal{L})_\mathcal{P} - ``p``: p-value for the tension between two samples .. math:: - p = \\int_{d_\\mathrm{G} - 2 \\log S}^{\\infty} \\chi^2 (x)dx + p = \\int_{d_\\mathrm{G} - 2 \\log \mathcal{S}}^{\\infty} \\chi^2 (x)dx Parameters ---------- @@ -72,15 +76,15 @@ def tension_stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 logR = statsAB.logZ-statsA.logZ-statsB.logZ samples_stats['logR'] = logR - samples_stats.set_label('logR', r'$\log{R}$') + samples_stats.set_label('logR', r'$\log\mathcal{R}$') logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL samples_stats['logI'] = logI - samples_stats.set_label('logI', r'$\log{I}$') + samples_stats.set_label('logI', r'$\log\mathcal{I}$') logS = statsAB.logL_P - statsA.logL_P - statsB.logL_P samples_stats['logS'] = logS - samples_stats.set_label('logS', r'$\log{S}$') + samples_stats.set_label('logS', r'$\log\mathcal{S}$') d_G = statsA.d_G + statsB.d_G - statsAB.d_G samples_stats['d_G'] = d_G diff --git a/tests/example_data/.DS_Store b/tests/example_data/.DS_Store deleted file mode 100644 index b2e0fe8e1cab31a37f66466d83e29e91e67a1355..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKUrWO<5Kp$LDMRRk!X5*@4%{CZh%cqiFJMIwWM>v$eCkCxmE=``}5HK@k?q+z%JGXk96lMztPB*U7Y; zxCiGdE5an3E_6Z?Pa)*)Cdpz|`f8cQxy}uYLpY8zaXYJ3e>CjM!JxnH%GK$h*Oe#3 z(R%HO!=vM~%gJ*(%hanOlLOaU_AS=%28!OxOR&gNl|6!8$JQ}~!~iis3=jjvfUOOp zO;ivA!~ikyjR8C#Bs4_NVr5Vt9nj(R8T~Cp6wvW4fha9{7Au3`0pTVU(4=zv#NZ|! z#-)w(ELH|hI^%j}n8&VMKVGvTZ6 N2xvm6BL;qffls*=NSFWs diff --git a/tests/test_tension.py b/tests/test_tension.py index bd0bdf89..66366e24 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -1,7 +1,7 @@ from anesthetic.examples.perfect_ns import correlated_gaussian import numpy as np from numpy.linalg import inv, solve, slogdet -from anesthetic.tension import tension_stats +from anesthetic.tension import stats def test_tension_stats_compatiable_gaussian(): @@ -32,8 +32,7 @@ def test_tension_stats_compatiable_gaussian(): nsamples = 1000 beta = 1 - samples_stats = tension_stats(samplesA, samplesB, samplesAB, - nsamples, beta) + samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() @@ -51,8 +50,9 @@ def test_tension_stats_compatiable_gaussian(): logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std - assert samples_stats.get_labels().tolist() == ([r'$\log{R}$', - r'$\log{I}$', r'$\log{S}$', + assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', + r'$\log\mathcal{I}$', + r'$\log\mathcal{S}$', r'$d_\mathrm{G}$', r'$p$']) @@ -85,8 +85,7 @@ def test_tension_stats_incompatiable_gaussian(): nsamples = 1000 beta = 1 - samples_stats = tension_stats(samplesA, samplesB, samplesAB, - nsamples, beta) + samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() @@ -104,6 +103,7 @@ def test_tension_stats_incompatiable_gaussian(): logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std - assert samples_stats.get_labels().tolist() == ([r'$\log{R}$', - r'$\log{I}$', r'$\log{S}$', + assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', + r'$\log\mathcal{I}$', + r'$\log\mathcal{S}$', r'$d_\mathrm{G}$', r'$p$']) From 69c932af396280406b7b9275f0fee18a5ba916fb Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 10:10:48 +0100 Subject: [PATCH 35/49] Updated docstring to avoid Samples --- anesthetic/tension.py | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 7a7353a9..d867ed36 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -42,17 +42,14 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 Parameters ---------- - A : :class:`anesthetic.samples.Samples` or \ - :class:`anesthetic.samples.NestedSamples` - (Nested) Samples from a sampling run using only dataset A. + A : :class:`anesthetic.samples.NestedSamples` + Nested Samples from a sampling run using only dataset A. - B : :class:`anesthetic.samples.Samples` or \ - :class:`anesthetic.samples.NestedSamples` - (Nested) Samples from a sampling run using only dataset B. + B : :class:`anesthetic.samples.NestedSamples` + Nested Samples from a sampling run using only dataset B. - AB : :class:`anesthetic.samples.Samples` or \ - :class:`anesthetic.samples.NestedSamples` - (Nested) Samples from a sampling run using datasets A and B jointly. + AB : :class:`anesthetic.samples.NestedSamples` + Nested Samples from a sampling run using datasets A and B jointly. nsamples : int, optional - If nsamples is not supplied, calculate mean value From 7e90ac5bbe63c7220852c4d5b08a0c8dad7e44ce Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 10:19:04 +0100 Subject: [PATCH 36/49] replaced \\m --- anesthetic/tension.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index d867ed36..3b92d3b8 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -11,34 +11,34 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 - ``logR``: Logarithmic of R statistic .. math:: - \\log \mathcal{R} = \\log \mathcal{Z}_\\mathrm{AB} - - \\log \mathcal{Z}_\\mathrm{A} - - \\log \mathcal{Z}_\\mathrm{B} + \\log\\mathcal{R} = \\log\\mathcal{Z}_\\\mathrm{AB} + - \\log\\mathcal{Z}_\\mathrm{A} + - \\log\\mathcal{Z}_\\mathrm{B} - ``logI``: Logarithmic of information ratio .. math:: - \\log \mathcal{I} = \mathcal{D}_\\mathrm{KL}^A - + \mathcal{D}_\\mathrm{KL}^B - - \mathcal{D}_\\mathrm{KL}^{AB} + \\log\mathcal{I} = \\mathcal{D}_\\mathrm{KL}^A + + \\mathcal{D}_\\mathrm{KL}^B + - \\mathcal{D}_\\mathrm{KL}^{AB} - ``logS``: Logarithmic of suspiciousness .. math:: - \\log \mathcal{S} = \\log \mathcal{L}_\\mathrm{AB} - - \\log \mathcal{L}_\\mathrm{A} - - \\log \mathcal{L}_\\mathrm{B} + \\log\mathcal{S} = \\log\\mathcal{L}_\\mathrm{AB} + - \\log\\mathcal{L}_\\mathrm{A} + - \\log\\mathcal{L}_\\mathrm{B} - ``d_G``: Gaussian model dimensionality (or posterior variance of the log-likelihood) .. math:: - d_\\mathrm{G}/2 = \\mathrm{var}(\\log \mathcal{L})_\mathcal{P} + d_\\mathrm{G}/2 = \\mathrm{var}(\\log\mathcal{L})_\mathcal{P} - ``p``: p-value for the tension between two samples .. math:: - p = \\int_{d_\\mathrm{G} - 2 \\log \mathcal{S}}^{\\infty} \\chi^2 (x)dx + p = \\int_{d_\\mathrm{G} - 2 \\log\mathcal{S}}^{\\infty} \\chi^2 (x)dx Parameters ---------- From 75d3067af50b0d868a7a33aa82682a21e658d9cc Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 10:24:30 +0100 Subject: [PATCH 37/49] Further string corrections --- anesthetic/tension.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 3b92d3b8..605f611a 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -11,22 +11,22 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 - ``logR``: Logarithmic of R statistic .. math:: - \\log\\mathcal{R} = \\log\\mathcal{Z}_\\\mathrm{AB} + \\log\\mathcal{R} = \\log\\mathcal{Z}_\\\mathrm{AB} - \\log\\mathcal{Z}_\\mathrm{A} - \\log\\mathcal{Z}_\\mathrm{B} - ``logI``: Logarithmic of information ratio .. math:: - \\log\mathcal{I} = \\mathcal{D}_\\mathrm{KL}^A - + \\mathcal{D}_\\mathrm{KL}^B + \\log\\mathcal{I} = \\mathcal{D}_\\mathrm{KL}^A + + \\mathcal{D}_\\mathrm{KL}^B - \\mathcal{D}_\\mathrm{KL}^{AB} - ``logS``: Logarithmic of suspiciousness .. math:: - \\log\mathcal{S} = \\log\\mathcal{L}_\\mathrm{AB} - - \\log\\mathcal{L}_\\mathrm{A} + \\log\\mathcal{S} = \\log\\mathcal{L}_\\mathrm{AB} + - \\log\\mathcal{L}_\\mathrm{A} - \\log\\mathcal{L}_\\mathrm{B} - ``d_G``: Gaussian model dimensionality From 740eacfff63c3c77e442d084629b3557b69dd55c Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 10:32:55 +0100 Subject: [PATCH 38/49] Further debugging docstrings --- anesthetic/tension.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 605f611a..74b18881 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -11,7 +11,7 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 - ``logR``: Logarithmic of R statistic .. math:: - \\log\\mathcal{R} = \\log\\mathcal{Z}_\\\mathrm{AB} + \\log\\mathcal{R} = \\log\\mathcal{Z}_\\mathrm{AB} - \\log\\mathcal{Z}_\\mathrm{A} - \\log\\mathcal{Z}_\\mathrm{B} @@ -33,12 +33,12 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 (or posterior variance of the log-likelihood) .. math:: - d_\\mathrm{G}/2 = \\mathrm{var}(\\log\mathcal{L})_\mathcal{P} + d_\\mathrm{G}/2 = \\mathrm{var}(\\log\\mathcal{L})_\\mathcal{P} - ``p``: p-value for the tension between two samples .. math:: - p = \\int_{d_\\mathrm{G} - 2 \\log\mathcal{S}}^{\\infty} \\chi^2 (x)dx + p = \\int_{d_\\mathrm{G} - 2 \\log\\mathcal{S}}^{\\infty} \\chi^2 (x)dx Parameters ---------- From d236f34d63aa09273eb7881e621336e22584bddd Mon Sep 17 00:00:00 2001 From: Will Handley Date: Thu, 19 Sep 2024 11:02:06 +0100 Subject: [PATCH 39/49] Logarithmic -> Logarithm --- anesthetic/tension.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 74b18881..00a97ee7 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -8,21 +8,21 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 Using nested sampling we can compute: - - ``logR``: Logarithmic of R statistic + - ``logR``: Logarithm of R statistic .. math:: \\log\\mathcal{R} = \\log\\mathcal{Z}_\\mathrm{AB} - \\log\\mathcal{Z}_\\mathrm{A} - \\log\\mathcal{Z}_\\mathrm{B} - - ``logI``: Logarithmic of information ratio + - ``logI``: Logarithm of information ratio .. math:: \\log\\mathcal{I} = \\mathcal{D}_\\mathrm{KL}^A + \\mathcal{D}_\\mathrm{KL}^B - \\mathcal{D}_\\mathrm{KL}^{AB} - - ``logS``: Logarithmic of suspiciousness + - ``logS``: Logarithm of suspiciousness .. math:: \\log\\mathcal{S} = \\log\\mathcal{L}_\\mathrm{AB} From 73d6180478d1ef553fd50076180a7dd5c9a02915 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Thu, 26 Sep 2024 17:13:59 -0700 Subject: [PATCH 40/49] correct spelling of compatible --- tests/test_tension.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index 66366e24..a5e57aa8 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -4,7 +4,7 @@ from anesthetic.tension import stats -def test_tension_stats_compatiable_gaussian(): +def test_tension_stats_compatible_gaussian(): d = 3 V = 6.0 nlive = 1000 @@ -56,7 +56,7 @@ def test_tension_stats_compatiable_gaussian(): r'$d_\mathrm{G}$', r'$p$']) -def test_tension_stats_incompatiable_gaussian(): +def test_tension_stats_incompatible_gaussian(): np.random.rand(0) d = 3 V = 6.0 From 5675e25d4cdbcc19fb4b3742066b29f3e767c6fc Mon Sep 17 00:00:00 2001 From: lukashergt Date: Thu, 26 Sep 2024 17:28:50 -0700 Subject: [PATCH 41/49] surround `@` by spaces --- tests/test_tension.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index a5e57aa8..746ff13f 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -25,9 +25,9 @@ def test_tension_stats_compatible_gaussian(): samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) covAB = inv(inv(covA) + inv(covB)) - meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) + meanAB = covAB @ (solve(covA, meanA) + solve(covB, meanB)) dmeanAB = np.array(meanA)-np.array(meanB) - logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB + logLmaxAB = -dmeanAB @ solve(covA+covB, dmeanAB) / 2 + logLmaxA + logLmaxB samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) nsamples = 1000 @@ -36,18 +36,18 @@ def test_tension_stats_compatible_gaussian(): logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() - logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - - 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) + logR_exact = np.log(V) - (dmeanAB @ solve(covA+covB, dmeanAB) / 2 + + slogdet(2*np.pi*(covA+covB))[1] / 2) assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std logS_std = samples_stats.logS.std() logS_mean = samples_stats.logS.mean() - logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) + logS_exact = d / 2 - dmeanAB @ solve(covA+covB, dmeanAB) / 2 assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std logI_std = samples_stats.logI.std() logI_mean = samples_stats.logI.mean() - logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) + logI_exact = np.log(V) - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', @@ -78,9 +78,9 @@ def test_tension_stats_incompatible_gaussian(): samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) covAB = inv(inv(covA) + inv(covB)) - meanAB = covAB@(solve(covA, meanA)+solve(covB, meanB)) + meanAB = covAB @ (solve(covA, meanA)+solve(covB, meanB)) dmeanAB = np.array(meanA)-np.array(meanB) - logLmaxAB = -1/2 * dmeanAB@solve(covA+covB, dmeanAB) + logLmaxA + logLmaxB + logLmaxAB = -dmeanAB @ solve(covA+covB, dmeanAB) / 2 + logLmaxA + logLmaxB samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) nsamples = 1000 @@ -89,18 +89,18 @@ def test_tension_stats_incompatible_gaussian(): logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() - logR_exact = (-1/2*dmeanAB@solve(covA+covB, dmeanAB) - - 1/2*slogdet(2*np.pi*(covA+covB))[1] + np.log(V)) + logR_exact = np.log(V) - (dmeanAB @ solve(covA+covB, dmeanAB) / 2 + + slogdet(2*np.pi*(covA+covB))[1] / 2) assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std logS_std = samples_stats.logS.std() logS_mean = samples_stats.logS.mean() - logS_exact = d/2 - 1/2*dmeanAB@solve(covA+covB, dmeanAB) + logS_exact = d / 2 - dmeanAB @ solve(covA+covB, dmeanAB) / 2 assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std logI_std = samples_stats.logI.std() logI_mean = samples_stats.logI.mean() - logI_exact = -d/2 - 1/2 * slogdet(2*np.pi*(covA+covB))[1] + np.log(V) + logI_exact = np.log(V) - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', From a7b7fb5dfa6c6a5637b4d4b2905319cfe59dc4ba Mon Sep 17 00:00:00 2001 From: lukashergt Date: Thu, 26 Sep 2024 17:37:14 -0700 Subject: [PATCH 42/49] remove occurences of missing leading 0, e.g. `.01` --- tests/test_tension.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index 746ff13f..af51e3c6 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -11,16 +11,16 @@ def test_tension_stats_compatible_gaussian(): bounds = [[-1, 1], [0, 3], [0, 1]] meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], - [0.009, .01, 0], - [0, 0, 0.1]])*0.01 + covA = 0.01 * np.array([[0.010, 0.009, 0.0], + [0.009, 0.010, 0.0], + [0.000, 0.000, 0.1]]) logLmaxA = 0 samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) meanB = [0.1, 0.3, 0.5] - covB = np.array([[.01, -0.009, 0.01], - [-0.009, .01, -0.001], - [0.01, -0.001, 0.1]])*0.01 + covB = 0.01 * np.array([[+0.010, -0.009, +0.010], + [-0.009, +0.010, -0.001], + [+0.010, -0.001, +0.100]]) logLmaxB = 0 samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) @@ -64,16 +64,16 @@ def test_tension_stats_incompatible_gaussian(): bounds = [[-1, 1], [0, 3], [0, 1]] meanA = [0.1, 0.3, 0.5] - covA = np.array([[.01, 0.009, 0], - [0.009, .01, 0], - [0, 0, 0.1]])*0.01 + covA = 0.01 * np.array([[0.010, 0.009, 0.0], + [0.009, 0.010, 0.0], + [0.000, 0.000, 0.1]]) logLmaxA = 0 samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) meanB = [0.15, 0.25, 0.45] - covB = np.array([[.01, -0.009, 0.01], - [-0.009, .01, -0.001], - [0.01, -0.001, 0.1]])*0.01 + covB = 0.01 * np.array([[+0.010, -0.009, +0.010], + [-0.009, +0.010, -0.001], + [+0.010, -0.001, +0.100]]) logLmaxB = 0 samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) From e3bf650e0b4b5cd5b168ef5143d431762dbad469 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Thu, 26 Sep 2024 18:06:30 -0700 Subject: [PATCH 43/49] use `ln` rather than `log` for the latex labels --- anesthetic/tension.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index 00a97ee7..d6081720 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -71,17 +71,17 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 samples_stats = Samples(index=statsA.index) - logR = statsAB.logZ-statsA.logZ-statsB.logZ + logR = statsAB.logZ - statsA.logZ - statsB.logZ samples_stats['logR'] = logR - samples_stats.set_label('logR', r'$\log\mathcal{R}$') + samples_stats.set_label('logR', r'$\ln\mathcal{R}$') logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL samples_stats['logI'] = logI - samples_stats.set_label('logI', r'$\log\mathcal{I}$') + samples_stats.set_label('logI', r'$\ln\mathcal{I}$') logS = statsAB.logL_P - statsA.logL_P - statsB.logL_P samples_stats['logS'] = logS - samples_stats.set_label('logS', r'$\log\mathcal{S}$') + samples_stats.set_label('logS', r'$\ln\mathcal{S}$') d_G = statsA.d_G + statsB.d_G - statsAB.d_G samples_stats['d_G'] = d_G From 9dae22f804f0462f6fda9ddf401947c7b9d49631 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Fri, 27 Sep 2024 01:28:51 -0700 Subject: [PATCH 44/49] streamline and speed up tension tests a bit --- tests/test_tension.py | 108 +++++++++++++++++++++++------------------- 1 file changed, 60 insertions(+), 48 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index af51e3c6..c82a8854 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -1,109 +1,121 @@ +from pytest import approx from anesthetic.examples.perfect_ns import correlated_gaussian import numpy as np -from numpy.linalg import inv, solve, slogdet +from numpy.linalg import inv, slogdet from anesthetic.tension import stats def test_tension_stats_compatible_gaussian(): + np.random.seed(42) d = 3 - V = 6.0 - nlive = 1000 + nlive = 10 * d bounds = [[-1, 1], [0, 3], [0, 1]] + logV = np.log(np.diff(bounds).ravel().prod()) - meanA = [0.1, 0.3, 0.5] + muA = np.array([0.1, 0.3, 0.5]) covA = 0.01 * np.array([[0.010, 0.009, 0.0], [0.009, 0.010, 0.0], [0.000, 0.000, 0.1]]) + invcovA = inv(covA) logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + samplesA = correlated_gaussian(nlive, muA, covA, bounds, logLmaxA) - meanB = [0.1, 0.3, 0.5] + muB = np.array([0.1, 0.3, 0.5]) covB = 0.01 * np.array([[+0.010, -0.009, +0.010], [-0.009, +0.010, -0.001], [+0.010, -0.001, +0.100]]) + invcovB = inv(covB) logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + samplesB = correlated_gaussian(nlive, muB, covB, bounds, logLmaxB) - covAB = inv(inv(covA) + inv(covB)) - meanAB = covAB @ (solve(covA, meanA) + solve(covB, meanB)) - dmeanAB = np.array(meanA)-np.array(meanB) - logLmaxAB = -dmeanAB @ solve(covA+covB, dmeanAB) / 2 + logLmaxA + logLmaxB - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + covAB = inv(invcovA + invcovB) + muAB = covAB @ (invcovA @ muA + invcovB @ muB) + dmuAB = muA - muB + dmu_cov_dmu_AB = dmuAB @ invcovA @ covAB @ invcovB @ dmuAB + logLmaxAB = logLmaxA + logLmaxB - dmu_cov_dmu_AB / 2 + samplesAB = correlated_gaussian(nlive, muAB, covAB, bounds, logLmaxAB) - nsamples = 1000 + nsamples = 10 beta = 1 samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() - logR_exact = np.log(V) - (dmeanAB @ solve(covA+covB, dmeanAB) / 2 - + slogdet(2*np.pi*(covA+covB))[1] / 2) - assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + logR_exact = logV - dmu_cov_dmu_AB/2 - slogdet(2*np.pi*(covA+covB))[1]/2 + assert logR_mean == approx(logR_exact, abs=3*logR_std) logS_std = samples_stats.logS.std() logS_mean = samples_stats.logS.mean() - logS_exact = d / 2 - dmeanAB @ solve(covA+covB, dmeanAB) / 2 - assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + logS_exact = d / 2 - dmu_cov_dmu_AB / 2 + assert logS_mean == approx(logS_exact, abs=3*logS_std) logI_std = samples_stats.logI.std() logI_mean = samples_stats.logI.mean() - logI_exact = np.log(V) - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 - assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std + logI_exact = logV - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 + assert logI_mean == approx(logI_exact, abs=3*logI_std) - assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', - r'$\log\mathcal{I}$', - r'$\log\mathcal{S}$', - r'$d_\mathrm{G}$', r'$p$']) + assert logS_mean == approx(logR_mean - logI_mean, abs=3*logS_std) + + assert samples_stats.get_labels().tolist() == ([r'$\ln\mathcal{R}$', + r'$\ln\mathcal{I}$', + r'$\ln\mathcal{S}$', + r'$d_\mathrm{G}$', + r'$p$']) def test_tension_stats_incompatible_gaussian(): - np.random.rand(0) + np.random.seed(42) d = 3 - V = 6.0 - nlive = 1000 + nlive = 10 * d bounds = [[-1, 1], [0, 3], [0, 1]] + logV = np.log(np.diff(bounds).ravel().prod()) - meanA = [0.1, 0.3, 0.5] + muA = np.array([0.1, 0.3, 0.5]) covA = 0.01 * np.array([[0.010, 0.009, 0.0], [0.009, 0.010, 0.0], [0.000, 0.000, 0.1]]) + invcovA = inv(covA) logLmaxA = 0 - samplesA = correlated_gaussian(nlive, meanA, covA, bounds, logLmaxA) + samplesA = correlated_gaussian(nlive, muA, covA, bounds, logLmaxA) - meanB = [0.15, 0.25, 0.45] + muB = np.array([0.15, 0.25, 0.45]) covB = 0.01 * np.array([[+0.010, -0.009, +0.010], [-0.009, +0.010, -0.001], [+0.010, -0.001, +0.100]]) + invcovB = inv(covB) logLmaxB = 0 - samplesB = correlated_gaussian(nlive, meanB, covB, bounds, logLmaxB) + samplesB = correlated_gaussian(nlive, muB, covB, bounds, logLmaxB) - covAB = inv(inv(covA) + inv(covB)) - meanAB = covAB @ (solve(covA, meanA)+solve(covB, meanB)) - dmeanAB = np.array(meanA)-np.array(meanB) - logLmaxAB = -dmeanAB @ solve(covA+covB, dmeanAB) / 2 + logLmaxA + logLmaxB - samplesAB = correlated_gaussian(nlive, meanAB, covAB, bounds, logLmaxAB) + covAB = inv(invcovA + invcovB) + muAB = covAB @ (invcovA @ muA + invcovB @ muB) + dmuAB = muA - muB + dmu_cov_dmu_AB = dmuAB @ invcovA @ covAB @ invcovB @ dmuAB + logLmaxAB = logLmaxA + logLmaxB - dmu_cov_dmu_AB / 2 + samplesAB = correlated_gaussian(nlive, muAB, covAB, bounds, logLmaxAB) - nsamples = 1000 + nsamples = 10 beta = 1 samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) logR_std = samples_stats.logR.std() logR_mean = samples_stats.logR.mean() - logR_exact = np.log(V) - (dmeanAB @ solve(covA+covB, dmeanAB) / 2 - + slogdet(2*np.pi*(covA+covB))[1] / 2) - assert logR_mean - 3 * logR_std < logR_exact < logR_mean + 3 * logR_std + logR_exact = logV - dmu_cov_dmu_AB/2 - slogdet(2*np.pi*(covA+covB))[1]/2 + assert logR_mean == approx(logR_exact, abs=3*logR_std) logS_std = samples_stats.logS.std() logS_mean = samples_stats.logS.mean() - logS_exact = d / 2 - dmeanAB @ solve(covA+covB, dmeanAB) / 2 - assert logS_mean - 3 * logS_std < logS_exact < logS_mean + 3 * logS_std + logS_exact = d / 2 - dmu_cov_dmu_AB / 2 + assert logS_mean == approx(logS_exact, abs=3*logS_std) logI_std = samples_stats.logI.std() logI_mean = samples_stats.logI.mean() - logI_exact = np.log(V) - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 - assert logI_mean - 3 * logI_std < logI_exact < logI_mean + 3 * logI_std + logI_exact = logV - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 + assert logI_mean == approx(logI_exact, abs=3*logI_std) + + assert logS_mean == approx(logR_mean - logI_mean, abs=3*logS_std) - assert samples_stats.get_labels().tolist() == ([r'$\log\mathcal{R}$', - r'$\log\mathcal{I}$', - r'$\log\mathcal{S}$', - r'$d_\mathrm{G}$', r'$p$']) + assert samples_stats.get_labels().tolist() == ([r'$\ln\mathcal{R}$', + r'$\ln\mathcal{I}$', + r'$\ln\mathcal{S}$', + r'$d_\mathrm{G}$', + r'$p$']) From 8c70f2f7f5ea228efc9a10a9b464186e7abfa985 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Fri, 27 Sep 2024 01:32:00 -0700 Subject: [PATCH 45/49] make tension docstring more readable --- anesthetic/tension.py | 78 ++++++++++++++++++++----------------------- 1 file changed, 36 insertions(+), 42 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index d6081720..ef52779e 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -4,90 +4,84 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 - """Compute tension statistics between two samples. + r"""Compute tension statistics between two samples. Using nested sampling we can compute: - - ``logR``: Logarithm of R statistic + - ``logR``: R statistic for dataset consistency .. math:: - \\log\\mathcal{R} = \\log\\mathcal{Z}_\\mathrm{AB} - - \\log\\mathcal{Z}_\\mathrm{A} - - \\log\\mathcal{Z}_\\mathrm{B} + \log R = \log Z_{AB} - \log Z_{A} - \log Z_{B} - - ``logI``: Logarithm of information ratio + - ``logI``: information ratio .. math:: - \\log\\mathcal{I} = \\mathcal{D}_\\mathrm{KL}^A - + \\mathcal{D}_\\mathrm{KL}^B - - \\mathcal{D}_\\mathrm{KL}^{AB} + \log I = D_{KL}^{A} + D_{KL}^{B} - D_{KL}^{AB} - - ``logS``: Logarithm of suspiciousness + - ``logS``: suspiciousness .. math:: - \\log\\mathcal{S} = \\log\\mathcal{L}_\\mathrm{AB} - - \\log\\mathcal{L}_\\mathrm{A} - - \\log\\mathcal{L}_\\mathrm{B} + \log S = \log L_{AB} - \log L_{A} - \log L_{B} - - ``d_G``: Gaussian model dimensionality - (or posterior variance of the log-likelihood) + - ``d_G``: Gaussian model dimensionality of shared constrained parameters .. math:: - d_\\mathrm{G}/2 = \\mathrm{var}(\\log\\mathcal{L})_\\mathcal{P} + d = d_{A} + d_{B} - d_{AB} - ``p``: p-value for the tension between two samples .. math:: - p = \\int_{d_\\mathrm{G} - 2 \\log\\mathcal{S}}^{\\infty} \\chi^2 (x)dx + p = \int_{d-2\log{S}}^{\infty} \chi^2_d(x) dx Parameters ---------- A : :class:`anesthetic.samples.NestedSamples` - Nested Samples from a sampling run using only dataset A. + NestedSamples object from a sampling run using only dataset A. + Alternatively, you can pass the precomputed stats object returned from + :meth:`anesthetic.samples.NestedSamples.stats`. B : :class:`anesthetic.samples.NestedSamples` - Nested Samples from a sampling run using only dataset B. + NestedSamples object from a sampling run using only dataset B. + Alternatively, you can pass the precomputed stats object returned from + :meth:`anesthetic.samples.NestedSamples.stats`. AB : :class:`anesthetic.samples.NestedSamples` - Nested Samples from a sampling run using datasets A and B jointly. + NestedSamples object from a sampling run using both datasets A and B + jointly. nsamples : int, optional - If nsamples is not supplied, calculate mean value - If nsamples is integer, draw nsamples from the distribution of values inferred by nested sampling - beta : float, array-like, optional - inverse temperature(s) beta=1/kT. Default 1 + beta : float, array-like, default=1 + Inverse temperature(s) beta=1/kT. Returns ------- - samples_stats : :class:`anesthetic.samples.Samples` - DataFrame containing the following tension statistics: - logR, logI, logS, d_G, p + samples : :class:`anesthetic.samples.Samples` + DataFrame containing the following tension statistics in columns: + ['logR', 'logI', 'logS', 'd_G', 'p'] """ statsA = A.stats(nsamples=nsamples, beta=beta) statsB = B.stats(nsamples=nsamples, beta=beta) statsAB = AB.stats(nsamples=nsamples, beta=beta) - samples_stats = Samples(index=statsA.index) + samples = Samples(index=statsA.index) - logR = statsAB.logZ - statsA.logZ - statsB.logZ - samples_stats['logR'] = logR - samples_stats.set_label('logR', r'$\ln\mathcal{R}$') + samples['logR'] = statsAB['logZ'] - statsA['logZ'] - statsB['logZ'] + samples.set_label('logR', r'$\ln\mathcal{R}$') - logI = statsA.D_KL + statsB.D_KL - statsAB.D_KL - samples_stats['logI'] = logI - samples_stats.set_label('logI', r'$\ln\mathcal{I}$') + samples['logI'] = statsA['D_KL'] + statsB['D_KL'] - statsAB['D_KL'] + samples.set_label('logI', r'$\ln\mathcal{I}$') - logS = statsAB.logL_P - statsA.logL_P - statsB.logL_P - samples_stats['logS'] = logS - samples_stats.set_label('logS', r'$\ln\mathcal{S}$') + samples['logS'] = statsAB['logL_P'] - statsA['logL_P'] - statsB['logL_P'] + samples.set_label('logS', r'$\ln\mathcal{S}$') - d_G = statsA.d_G + statsB.d_G - statsAB.d_G - samples_stats['d_G'] = d_G - samples_stats.set_label('d_G', r'$d_\mathrm{G}$') + samples['d_G'] = statsA['d_G'] + statsB['d_G'] - statsAB['d_G'] + samples.set_label('d_G', r'$d_\mathrm{G}$') - p = chi2.sf(d_G-2*logS, d_G) - samples_stats['p'] = p - samples_stats.set_label('p', r'$p$') - return samples_stats + p = chi2.sf(samples['d_G'] - 2 * samples['logS'], df=samples['d_G']) + samples['p'] = p + samples.set_label('p', '$p$') + return samples From 88b7ec68527681bf8de7c88f883ae5932f210722 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Fri, 27 Sep 2024 02:20:19 -0700 Subject: [PATCH 46/49] optionally allow for passing a pre-computed stats instance to tension computation to save computing time for high-nsamples runs --- anesthetic/tension.py | 45 +++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-) diff --git a/anesthetic/tension.py b/anesthetic/tension.py index ef52779e..fb9c8590 100644 --- a/anesthetic/tension.py +++ b/anesthetic/tension.py @@ -35,27 +35,31 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 Parameters ---------- - A : :class:`anesthetic.samples.NestedSamples` - NestedSamples object from a sampling run using only dataset A. - Alternatively, you can pass the precomputed stats object returned from + A : :class:`anesthetic.samples.Samples` + :class:`anesthetic.samples.NestedSamples` object from a sampling run + using only dataset A. + Alternatively, you can pass a precomputed stats object returned from :meth:`anesthetic.samples.NestedSamples.stats`. - B : :class:`anesthetic.samples.NestedSamples` - NestedSamples object from a sampling run using only dataset B. + B : :class:`anesthetic.samples.Samples` + :class:`anesthetic.samples.NestedSamples` object from a sampling run + using only dataset B. Alternatively, you can pass the precomputed stats object returned from :meth:`anesthetic.samples.NestedSamples.stats`. - AB : :class:`anesthetic.samples.NestedSamples` - NestedSamples object from a sampling run using both datasets A and B - jointly. + AB : :class:`anesthetic.samples.Samples` + :class:`anesthetic.samples.NestedSamples` object from a sampling run + using both datasets A and B jointly. + Alternatively, you can pass the precomputed stats object returned from + :meth:`anesthetic.samples.NestedSamples.stats`. nsamples : int, optional - - If nsamples is not supplied, calculate mean value + - If nsamples is not supplied, calculate mean value. - If nsamples is integer, draw nsamples from the distribution of - values inferred by nested sampling + values inferred by nested sampling. beta : float, array-like, default=1 - Inverse temperature(s) beta=1/kT. + Inverse temperature(s) `beta=1/kT`. Returns ------- @@ -63,9 +67,22 @@ def stats(A, B, AB, nsamples=None, beta=None): # noqa: D301 DataFrame containing the following tension statistics in columns: ['logR', 'logI', 'logS', 'd_G', 'p'] """ - statsA = A.stats(nsamples=nsamples, beta=beta) - statsB = B.stats(nsamples=nsamples, beta=beta) - statsAB = AB.stats(nsamples=nsamples, beta=beta) + columns = ['logZ', 'D_KL', 'logL_P', 'd_G'] + if set(columns).issubset(A.drop_labels().columns): + statsA = A + else: + statsA = A.stats(nsamples=nsamples, beta=beta) + if set(columns).issubset(B.drop_labels().columns): + statsB = B + else: + statsB = B.stats(nsamples=nsamples, beta=beta) + if set(columns).issubset(AB.drop_labels().columns): + statsAB = AB + else: + statsAB = AB.stats(nsamples=nsamples, beta=beta) + if statsA.shape != statsAB.shape or statsB.shape != statsAB.shape: + raise ValueError("Shapes of stats_A, stats_B, and stats_AB do not " + "match. Make sure to pass consistent `nsamples`.") samples = Samples(index=statsA.index) From 51c0975643e06bb8ecaf3751c0f64aefb45dd058 Mon Sep 17 00:00:00 2001 From: lukashergt Date: Fri, 27 Sep 2024 02:21:29 -0700 Subject: [PATCH 47/49] simplify tension tests and add test for direct input of nested sampling stats to tension stats --- tests/test_tension.py | 75 +++++++++++++++++++++++-------------------- 1 file changed, 40 insertions(+), 35 deletions(-) diff --git a/tests/test_tension.py b/tests/test_tension.py index c82a8854..751fa28e 100644 --- a/tests/test_tension.py +++ b/tests/test_tension.py @@ -1,7 +1,8 @@ -from pytest import approx +from pytest import approx, raises from anesthetic.examples.perfect_ns import correlated_gaussian import numpy as np from numpy.linalg import inv, slogdet +from pandas.testing import assert_series_equal from anesthetic.tension import stats @@ -37,30 +38,32 @@ def test_tension_stats_compatible_gaussian(): nsamples = 10 beta = 1 - samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) + s = stats(samplesA, samplesB, samplesAB, nsamples, beta) - logR_std = samples_stats.logR.std() - logR_mean = samples_stats.logR.mean() logR_exact = logV - dmu_cov_dmu_AB/2 - slogdet(2*np.pi*(covA+covB))[1]/2 - assert logR_mean == approx(logR_exact, abs=3*logR_std) + assert s.logR.mean() == approx(logR_exact, abs=3*s.logR.std()) - logS_std = samples_stats.logS.std() - logS_mean = samples_stats.logS.mean() logS_exact = d / 2 - dmu_cov_dmu_AB / 2 - assert logS_mean == approx(logS_exact, abs=3*logS_std) + assert s.logS.mean() == approx(logS_exact, abs=3*s.logS.std()) - logI_std = samples_stats.logI.std() - logI_mean = samples_stats.logI.mean() logI_exact = logV - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 - assert logI_mean == approx(logI_exact, abs=3*logI_std) + assert s.logI.mean() == approx(logI_exact, abs=3*s.logI.std()) - assert logS_mean == approx(logR_mean - logI_mean, abs=3*logS_std) + assert s.logS.mean() == approx(s.logR.mean() - s.logI.mean(), + abs=3*s.logS.std()) - assert samples_stats.get_labels().tolist() == ([r'$\ln\mathcal{R}$', - r'$\ln\mathcal{I}$', - r'$\ln\mathcal{S}$', - r'$d_\mathrm{G}$', - r'$p$']) + assert s.get_labels().tolist() == ([r'$\ln\mathcal{R}$', + r'$\ln\mathcal{I}$', + r'$\ln\mathcal{S}$', + r'$d_\mathrm{G}$', + r'$p$']) + + with raises(ValueError): + stats(samplesA.stats(nsamples=5), samplesB, samplesAB, nsamples) + s2 = stats(samplesA.stats(nsamples=nsamples), + samplesB.stats(nsamples=nsamples), + samplesAB.stats(nsamples=nsamples)) + assert_series_equal(s2.mean(), s.mean(), atol=s2.std().max()) def test_tension_stats_incompatible_gaussian(): @@ -95,27 +98,29 @@ def test_tension_stats_incompatible_gaussian(): nsamples = 10 beta = 1 - samples_stats = stats(samplesA, samplesB, samplesAB, nsamples, beta) + s = stats(samplesA, samplesB, samplesAB, nsamples, beta) - logR_std = samples_stats.logR.std() - logR_mean = samples_stats.logR.mean() logR_exact = logV - dmu_cov_dmu_AB/2 - slogdet(2*np.pi*(covA+covB))[1]/2 - assert logR_mean == approx(logR_exact, abs=3*logR_std) + assert s.logR.mean() == approx(logR_exact, abs=3*s.logR.std()) - logS_std = samples_stats.logS.std() - logS_mean = samples_stats.logS.mean() logS_exact = d / 2 - dmu_cov_dmu_AB / 2 - assert logS_mean == approx(logS_exact, abs=3*logS_std) + assert s.logS.mean() == approx(logS_exact, abs=3*s.logS.std()) - logI_std = samples_stats.logI.std() - logI_mean = samples_stats.logI.mean() logI_exact = logV - d / 2 - slogdet(2*np.pi*(covA+covB))[1] / 2 - assert logI_mean == approx(logI_exact, abs=3*logI_std) - - assert logS_mean == approx(logR_mean - logI_mean, abs=3*logS_std) - - assert samples_stats.get_labels().tolist() == ([r'$\ln\mathcal{R}$', - r'$\ln\mathcal{I}$', - r'$\ln\mathcal{S}$', - r'$d_\mathrm{G}$', - r'$p$']) + assert s.logI.mean() == approx(logI_exact, abs=3*s.logI.std()) + + assert s.logS.mean() == approx(s.logR.mean() - s.logI.mean(), + abs=3*s.logS.std()) + + assert s.get_labels().tolist() == ([r'$\ln\mathcal{R}$', + r'$\ln\mathcal{I}$', + r'$\ln\mathcal{S}$', + r'$d_\mathrm{G}$', + r'$p$']) + + with raises(ValueError): + stats(samplesA.stats(nsamples=5), samplesB, samplesAB, nsamples) + s2 = stats(samplesA.stats(nsamples=nsamples), + samplesB.stats(nsamples=nsamples), + samplesAB.stats(nsamples=nsamples)) + assert_series_equal(s2.mean(), s.mean(), atol=s2.std().max()) From 0649d53c49de787c90763230b0514aba081cb311 Mon Sep 17 00:00:00 2001 From: Lukas Hergt Date: Fri, 27 Sep 2024 14:28:32 -0700 Subject: [PATCH 48/49] Update README.rst --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 4ecb81c2..a5fa35ed 100644 --- a/README.rst +++ b/README.rst @@ -2,7 +2,7 @@ anesthetic: nested sampling post-processing =========================================== :Authors: Will Handley and Lukas Hergt -:Version: 2.9.0 +:Version: 2.10.0 :Homepage: https://github.com/handley-lab/anesthetic :Documentation: http://anesthetic.readthedocs.io/ From 6b0778856dd17d7541ed9f2109cd4e07890dba92 Mon Sep 17 00:00:00 2001 From: Lukas Hergt Date: Fri, 27 Sep 2024 14:28:47 -0700 Subject: [PATCH 49/49] Update _version.py --- anesthetic/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anesthetic/_version.py b/anesthetic/_version.py index 387cfacc..e2e6e4b5 100644 --- a/anesthetic/_version.py +++ b/anesthetic/_version.py @@ -1 +1 @@ -__version__ = '2.9.0' +__version__ = '2.10.0'