diff --git a/.direnv/python-3.4.3/bin/activate b/.direnv/python-3.4.3/bin/activate new file mode 100644 index 0000000..8566868 --- /dev/null +++ b/.direnv/python-3.4.3/bin/activate @@ -0,0 +1,80 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + unset pydoc + + # reset old environment variables + if [ -n "$_OLD_VIRTUAL_PATH" ] ; then + PATH="$_OLD_VIRTUAL_PATH" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "$_OLD_VIRTUAL_PYTHONHOME" ] ; then + PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then + hash -r 2>/dev/null + fi + + if [ -n "$_OLD_VIRTUAL_PS1" ] ; then + PS1="$_OLD_VIRTUAL_PS1" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "$1" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "$PYTHONHOME" ] ; then + _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME" + unset PYTHONHOME +fi + +if [ -z "$VIRTUAL_ENV_DISABLE_PROMPT" ] ; then + _OLD_VIRTUAL_PS1="$PS1" + if [ "x" != x ] ; then + PS1="$PS1" + else + if [ "`basename \"$VIRTUAL_ENV\"`" = "__" ] ; then + # special case for Aspen magic directories + # see http://www.zetadev.com/software/aspen/ + PS1="[`basename \`dirname \"$VIRTUAL_ENV\"\``] $PS1" + else + PS1="(`basename \"$VIRTUAL_ENV\"`)$PS1" + fi + fi + export PS1 +fi + +alias pydoc="python -m pydoc" + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then + hash -r 2>/dev/null +fi diff --git a/.direnv/python-3.4.3/bin/activate.csh b/.direnv/python-3.4.3/bin/activate.csh new file mode 100644 index 0000000..67e5bfe --- /dev/null +++ b/.direnv/python-3.4.3/bin/activate.csh @@ -0,0 +1,42 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3" + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/bin:$PATH" + + + +if ("" != "") then + set env_name = "" +else + if (`basename "$VIRTUAL_ENV"` == "__") then + # special case for Aspen magic directories + # see http://www.zetadev.com/software/aspen/ + set env_name = `basename \`dirname "$VIRTUAL_ENV"\`` + else + set env_name = `basename "$VIRTUAL_ENV"` + endif +endif + +# Could be in a non-interactive environment, +# in which case, $prompt is undefined and we wouldn't +# care about the prompt anyway. +if ( $?prompt ) then + set _OLD_VIRTUAL_PROMPT="$prompt" + set prompt = "[$env_name] $prompt" +endif + +unset env_name + +alias pydoc python -m pydoc + +rehash + diff --git a/.direnv/python-3.4.3/bin/activate.fish b/.direnv/python-3.4.3/bin/activate.fish new file mode 100644 index 0000000..8566804 --- /dev/null +++ b/.direnv/python-3.4.3/bin/activate.fish @@ -0,0 +1,74 @@ +# This file must be used with "source bin/activate.fish" *from fish* (http://fishshell.com) +# you cannot run it directly + +function deactivate -d "Exit virtualenv and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + # set an empty local fish_function_path, so fish_prompt doesn't automatically reload + set -l fish_function_path + # erase the virtualenv's fish_prompt function, and restore the original + functions -e fish_prompt + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + end + + set -e VIRTUAL_ENV + if test "$argv[1]" != "nondestructive" + # Self destruct! + functions -e deactivate + end +end + +# unset irrelevant variables +deactivate nondestructive + +set -gx VIRTUAL_ENV "/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# unset PYTHONHOME if set +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # copy the current fish_prompt function as the function _old_fish_prompt + functions -c fish_prompt _old_fish_prompt + + # with the original prompt function copied, we can override with our own. + function fish_prompt + # Prompt override? + if test -n "" + printf "%s%s" "" (set_color normal) + _old_fish_prompt + return + end + # ...Otherwise, prepend env + set -l _checkbase (basename "$VIRTUAL_ENV") + if test $_checkbase = "__" + # special case for Aspen magic directories + # see http://www.zetadev.com/software/aspen/ + printf "%s[%s]%s " (set_color -b blue white) (basename (dirname "$VIRTUAL_ENV")) (set_color normal) + _old_fish_prompt + else + printf "%s(%s)%s" (set_color -b blue white) (basename "$VIRTUAL_ENV") (set_color normal) + _old_fish_prompt + end + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/.direnv/python-3.4.3/bin/activate_this.py b/.direnv/python-3.4.3/bin/activate_this.py new file mode 100644 index 0000000..f18193b --- /dev/null +++ b/.direnv/python-3.4.3/bin/activate_this.py @@ -0,0 +1,34 @@ +"""By using execfile(this_file, dict(__file__=this_file)) you will +activate this virtualenv environment. + +This can be used when you must use an existing Python interpreter, not +the virtualenv bin/python +""" + +try: + __file__ +except NameError: + raise AssertionError( + "You must run this like execfile('path/to/activate_this.py', dict(__file__='path/to/activate_this.py'))") +import sys +import os + +old_os_path = os.environ.get('PATH', '') +os.environ['PATH'] = os.path.dirname(os.path.abspath(__file__)) + os.pathsep + old_os_path +base = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if sys.platform == 'win32': + site_packages = os.path.join(base, 'Lib', 'site-packages') +else: + site_packages = os.path.join(base, 'lib', 'python%s' % sys.version[:3], 'site-packages') +prev_sys_path = list(sys.path) +import site +site.addsitedir(site_packages) +sys.real_prefix = sys.prefix +sys.prefix = base +# Move the added items to the front of the path: +new_sys_path = [] +for item in list(sys.path): + if item not in prev_sys_path: + new_sys_path.append(item) + sys.path.remove(item) +sys.path[:0] = new_sys_path diff --git a/.direnv/python-3.4.3/bin/easy_install b/.direnv/python-3.4.3/bin/easy_install new file mode 100755 index 0000000..5885b34 --- /dev/null +++ b/.direnv/python-3.4.3/bin/easy_install @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from setuptools.command.easy_install import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/easy_install-3.4 b/.direnv/python-3.4.3/bin/easy_install-3.4 new file mode 100755 index 0000000..5885b34 --- /dev/null +++ b/.direnv/python-3.4.3/bin/easy_install-3.4 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from setuptools.command.easy_install import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/f2py b/.direnv/python-3.4.3/bin/f2py new file mode 100755 index 0000000..3157387 --- /dev/null +++ b/.direnv/python-3.4.3/bin/f2py @@ -0,0 +1,24 @@ +#!/Users/travis/build/MacPython/numpy-wheels/venv/bin/python +# See http://cens.ioc.ee/projects/f2py2e/ +import os, sys +for mode in ["g3-numpy", "2e-numeric", "2e-numarray", "2e-numpy"]: + try: + i=sys.argv.index("--"+mode) + del sys.argv[i] + break + except ValueError: pass +os.environ["NO_SCIPY_IMPORT"]="f2py" +if mode=="g3-numpy": + sys.stderr.write("G3 f2py support is not implemented, yet.\n") + sys.exit(1) +elif mode=="2e-numeric": + from f2py2e import main +elif mode=="2e-numarray": + sys.argv.append("-DNUMARRAY") + from f2py2e import main +elif mode=="2e-numpy": + from numpy.f2py import main +else: + sys.stderr.write("Unknown mode: " + repr(mode) + "\n") + sys.exit(1) +main() diff --git a/.direnv/python-3.4.3/bin/ipcluster b/.direnv/python-3.4.3/bin/ipcluster new file mode 100755 index 0000000..18d547f --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipcluster @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipclusterapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/ipcluster3 b/.direnv/python-3.4.3/bin/ipcluster3 new file mode 100755 index 0000000..18d547f --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipcluster3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipclusterapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/ipcontroller b/.direnv/python-3.4.3/bin/ipcontroller new file mode 100755 index 0000000..4da013c --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipcontroller @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipcontrollerapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/ipcontroller3 b/.direnv/python-3.4.3/bin/ipcontroller3 new file mode 100755 index 0000000..4da013c --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipcontroller3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipcontrollerapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/ipengine b/.direnv/python-3.4.3/bin/ipengine new file mode 100755 index 0000000..ca544ae --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipengine @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipengineapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/ipengine3 b/.direnv/python-3.4.3/bin/ipengine3 new file mode 100755 index 0000000..ca544ae --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipengine3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.parallel.apps.ipengineapp import launch_new_instance + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_new_instance()) diff --git a/.direnv/python-3.4.3/bin/iptest b/.direnv/python-3.4.3/bin/iptest new file mode 100755 index 0000000..380fe86 --- /dev/null +++ b/.direnv/python-3.4.3/bin/iptest @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.testing.iptestcontroller import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/iptest3 b/.direnv/python-3.4.3/bin/iptest3 new file mode 100755 index 0000000..380fe86 --- /dev/null +++ b/.direnv/python-3.4.3/bin/iptest3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython.testing.iptestcontroller import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/ipython b/.direnv/python-3.4.3/bin/ipython new file mode 100755 index 0000000..2355c6a --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipython @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython import start_ipython + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(start_ipython()) diff --git a/.direnv/python-3.4.3/bin/ipython3 b/.direnv/python-3.4.3/bin/ipython3 new file mode 100755 index 0000000..2355c6a --- /dev/null +++ b/.direnv/python-3.4.3/bin/ipython3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from IPython import start_ipython + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(start_ipython()) diff --git a/.direnv/python-3.4.3/bin/jsonschema b/.direnv/python-3.4.3/bin/jsonschema new file mode 100755 index 0000000..9142b1e --- /dev/null +++ b/.direnv/python-3.4.3/bin/jsonschema @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from jsonschema.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/nosetests b/.direnv/python-3.4.3/bin/nosetests new file mode 100755 index 0000000..f170f1f --- /dev/null +++ b/.direnv/python-3.4.3/bin/nosetests @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from nose import run_exit + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run_exit()) diff --git a/.direnv/python-3.4.3/bin/nosetests-3.4 b/.direnv/python-3.4.3/bin/nosetests-3.4 new file mode 100755 index 0000000..f170f1f --- /dev/null +++ b/.direnv/python-3.4.3/bin/nosetests-3.4 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from nose import run_exit + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run_exit()) diff --git a/.direnv/python-3.4.3/bin/pip b/.direnv/python-3.4.3/bin/pip new file mode 100755 index 0000000..6ae6259 --- /dev/null +++ b/.direnv/python-3.4.3/bin/pip @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from pip import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/pip3 b/.direnv/python-3.4.3/bin/pip3 new file mode 100755 index 0000000..6ae6259 --- /dev/null +++ b/.direnv/python-3.4.3/bin/pip3 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from pip import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/pip3.4 b/.direnv/python-3.4.3/bin/pip3.4 new file mode 100755 index 0000000..6ae6259 --- /dev/null +++ b/.direnv/python-3.4.3/bin/pip3.4 @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from pip import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/pygmentize b/.direnv/python-3.4.3/bin/pygmentize new file mode 100755 index 0000000..3a94d1b --- /dev/null +++ b/.direnv/python-3.4.3/bin/pygmentize @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from pygments.cmdline import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/bin/python b/.direnv/python-3.4.3/bin/python new file mode 120000 index 0000000..bdceba4 --- /dev/null +++ b/.direnv/python-3.4.3/bin/python @@ -0,0 +1 @@ +python3.4 \ No newline at end of file diff --git a/.direnv/python-3.4.3/bin/python3 b/.direnv/python-3.4.3/bin/python3 new file mode 120000 index 0000000..bdceba4 --- /dev/null +++ b/.direnv/python-3.4.3/bin/python3 @@ -0,0 +1 @@ +python3.4 \ No newline at end of file diff --git a/.direnv/python-3.4.3/bin/python3.4 b/.direnv/python-3.4.3/bin/python3.4 new file mode 100755 index 0000000..eae24a2 Binary files /dev/null and b/.direnv/python-3.4.3/bin/python3.4 differ diff --git a/.direnv/python-3.4.3/bin/wheel b/.direnv/python-3.4.3/bin/wheel new file mode 100755 index 0000000..c2f78e9 --- /dev/null +++ b/.direnv/python-3.4.3/bin/wheel @@ -0,0 +1,11 @@ +#!/Users/sorenolegnowicz/cs/python/projects/honey-nut-clusters/.direnv/python-3.4.3/bin/python3.4 + +# -*- coding: utf-8 -*- +import re +import sys + +from wheel.tool import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/.direnv/python-3.4.3/include/python3.4m b/.direnv/python-3.4.3/include/python3.4m new file mode 120000 index 0000000..b1d022a --- /dev/null +++ b/.direnv/python-3.4.3/include/python3.4m @@ -0,0 +1 @@ +/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/include/python3.4m \ No newline at end of file diff --git a/.direnv/python-3.4.3/man/man1/nosetests.1 b/.direnv/python-3.4.3/man/man1/nosetests.1 new file mode 100644 index 0000000..5772845 --- /dev/null +++ b/.direnv/python-3.4.3/man/man1/nosetests.1 @@ -0,0 +1,581 @@ +.\" Man page generated from reStructuredText. +. +.TH "NOSETESTS" "1" "April 04, 2015" "1.3" "nose" +.SH NAME +nosetests \- Nicer testing for Python +. +.nr rst2man-indent-level 0 +. +.de1 rstReportMargin +\\$1 \\n[an-margin] +level \\n[rst2man-indent-level] +level margin: \\n[rst2man-indent\\n[rst2man-indent-level]] +- +\\n[rst2man-indent0] +\\n[rst2man-indent1] +\\n[rst2man-indent2] +.. +.de1 INDENT +.\" .rstReportMargin pre: +. RS \\$1 +. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin] +. nr rst2man-indent-level +1 +.\" .rstReportMargin post: +.. +.de UNINDENT +. RE +.\" indent \\n[an-margin] +.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]] +.nr rst2man-indent-level -1 +.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]] +.in \\n[rst2man-indent\\n[rst2man-indent-level]]u +.. +.SH NICER TESTING FOR PYTHON +.SS SYNOPSIS +.INDENT 0.0 +.INDENT 3.5 +nosetests [options] [names] +.UNINDENT +.UNINDENT +.SS DESCRIPTION +.sp +nose collects tests automatically from python source files, +directories and packages found in its working directory (which +defaults to the current working directory). Any python source file, +directory or package that matches the testMatch regular expression +(by default: \fI(?:^|[b_.\-])[Tt]est)\fP will be collected as a test (or +source for collection of tests). In addition, all other packages +found in the working directory will be examined for python source files +or directories that match testMatch. Package discovery descends all +the way down the tree, so package.tests and package.sub.tests and +package.sub.sub2.tests will all be collected. +.sp +Within a test directory or package, any python source file matching +testMatch will be examined for test cases. Within a test module, +functions and classes whose names match testMatch and TestCase +subclasses with any name will be loaded and executed as tests. Tests +may use the assert keyword or raise AssertionErrors to indicate test +failure. TestCase subclasses may do the same or use the various +TestCase methods available. +.sp +\fBIt is important to note that the default behavior of nose is to +not include tests from files which are executable.\fP To include +tests from such files, remove their executable bit or use +the \-\-exe flag (see \(aqOptions\(aq section below). +.SS Selecting Tests +.sp +To specify which tests to run, pass test names on the command line: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +nosetests only_test_this.py +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +Test names specified may be file or module names, and may optionally +indicate the test case to run by separating the module or file name +from the test case name with a colon. Filenames may be relative or +absolute. Examples: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +nosetests test.module +nosetests another.test:TestCase.test_method +nosetests a.test:TestCase +nosetests /path/to/test/file.py:test_function +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +You may also change the working directory where nose looks for tests +by using the \-w switch: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +nosetests \-w /path/to/tests +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +Note, however, that support for multiple \-w arguments is now deprecated +and will be removed in a future release. As of nose 0.10, you can get +the same behavior by specifying the target directories \fIwithout\fP +the \-w switch: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +nosetests /path/to/tests /another/path/to/tests +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +Further customization of test selection and loading is possible +through the use of plugins. +.sp +Test result output is identical to that of unittest, except for +the additional features (error classes, and plugin\-supplied +features such as output capture and assert introspection) detailed +in the options below. +.SS Configuration +.sp +In addition to passing command\-line options, you may also put +configuration options in your project\(aqs \fIsetup.cfg\fP file, or a .noserc +or nose.cfg file in your home directory. In any of these standard +ini\-style config files, you put your nosetests configuration in a +\fB[nosetests]\fP section. Options are the same as on the command line, +with the \-\- prefix removed. For options that are simple switches, you +must supply a value: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +[nosetests] +verbosity=3 +with\-doctest=1 +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +All configuration files that are found will be loaded and their +options combined. You can override the standard config file loading +with the \fB\-c\fP option. +.SS Using Plugins +.sp +There are numerous nose plugins available via easy_install and +elsewhere. To use a plugin, just install it. The plugin will add +command line options to nosetests. To verify that the plugin is installed, +run: +.INDENT 0.0 +.INDENT 3.5 +.sp +.nf +.ft C +nosetests \-\-plugins +.ft P +.fi +.UNINDENT +.UNINDENT +.sp +You can add \-v or \-vv to that command to show more information +about each plugin. +.sp +If you are running nose.main() or nose.run() from a script, you +can specify a list of plugins to use by passing a list of plugins +with the plugins keyword argument. +.SS 0.9 plugins +.sp +nose 1.0 can use SOME plugins that were written for nose 0.9. The +default plugin manager inserts a compatibility wrapper around 0.9 +plugins that adapts the changed plugin api calls. However, plugins +that access nose internals are likely to fail, especially if they +attempt to access test case or test suite classes. For example, +plugins that try to determine if a test passed to startTest is an +individual test or a suite will fail, partly because suites are no +longer passed to startTest and partly because it\(aqs likely that the +plugin is trying to find out if the test is an instance of a class +that no longer exists. +.SS 0.10 and 0.11 plugins +.sp +All plugins written for nose 0.10 and 0.11 should work with nose 1.0. +.SS Options +.INDENT 0.0 +.TP +.B \-V, \-\-version +Output nose version and exit +.UNINDENT +.INDENT 0.0 +.TP +.B \-p, \-\-plugins +Output list of available plugins and exit. Combine with higher verbosity for greater detail +.UNINDENT +.INDENT 0.0 +.TP +.B \-v=DEFAULT, \-\-verbose=DEFAULT +Be more verbose. [NOSE_VERBOSE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-verbosity=VERBOSITY +Set verbosity; \-\-verbosity=2 is the same as \-v +.UNINDENT +.INDENT 0.0 +.TP +.B \-q=DEFAULT, \-\-quiet=DEFAULT +Be less verbose +.UNINDENT +.INDENT 0.0 +.TP +.B \-c=FILES, \-\-config=FILES +Load configuration from config file(s). May be specified multiple times; in that case, all config files will be loaded and combined +.UNINDENT +.INDENT 0.0 +.TP +.B \-w=WHERE, \-\-where=WHERE +Look for tests in this directory. May be specified multiple times. The first directory passed will be used as the working directory, in place of the current working directory, which is the default. Others will be added to the list of tests to execute. [NOSE_WHERE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-py3where=PY3WHERE +Look for tests in this directory under Python 3.x. Functions the same as \(aqwhere\(aq, but only applies if running under Python 3.x or above. Note that, if present under 3.x, this option completely replaces any directories specified with \(aqwhere\(aq, so the \(aqwhere\(aq option becomes ineffective. [NOSE_PY3WHERE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-m=REGEX, \-\-match=REGEX, \-\-testmatch=REGEX +Files, directories, function names, and class names that match this regular expression are considered tests. Default: (?:^|[b_./\-])[Tt]est [NOSE_TESTMATCH] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-tests=NAMES +Run these tests (comma\-separated list). This argument is useful mainly from configuration files; on the command line, just pass the tests to run as additional arguments with no switch. +.UNINDENT +.INDENT 0.0 +.TP +.B \-l=DEFAULT, \-\-debug=DEFAULT +Activate debug logging for one or more systems. Available debug loggers: nose, nose.importer, nose.inspector, nose.plugins, nose.result and nose.selector. Separate multiple names with a comma. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-debug\-log=FILE +Log debug messages to this file (default: sys.stderr) +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-config=FILE, \-\-log\-config=FILE +Load logging config from this file \-\- bypasses all other logging config settings. +.UNINDENT +.INDENT 0.0 +.TP +.B \-I=REGEX, \-\-ignore\-files=REGEX +Completely ignore any file that matches this regular expression. Takes precedence over any other settings or plugins. Specifying this option will replace the default setting. Specify this option multiple times to add more regular expressions [NOSE_IGNORE_FILES] +.UNINDENT +.INDENT 0.0 +.TP +.B \-e=REGEX, \-\-exclude=REGEX +Don\(aqt run tests that match regular expression [NOSE_EXCLUDE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-i=REGEX, \-\-include=REGEX +This regular expression will be applied to files, directories, function names, and class names for a chance to include additional tests that do not match TESTMATCH. Specify this option multiple times to add more regular expressions [NOSE_INCLUDE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-x, \-\-stop +Stop running tests after the first error or failure +.UNINDENT +.INDENT 0.0 +.TP +.B \-P, \-\-no\-path\-adjustment +Don\(aqt make any changes to sys.path when loading tests [NOSE_NOPATH] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-exe +Look for tests in python modules that are executable. Normal behavior is to exclude executable modules, since they may not be import\-safe [NOSE_INCLUDE_EXE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-noexe +DO NOT look for tests in python modules that are executable. (The default on the windows platform is to do so.) +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-traverse\-namespace +Traverse through all path entries of a namespace package +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-first\-package\-wins, \-\-first\-pkg\-wins, \-\-1st\-pkg\-wins +nose\(aqs importer will normally evict a package from sys.modules if it sees a package with the same name in a different location. Set this option to disable that behavior. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-no\-byte\-compile +Prevent nose from byte\-compiling the source into .pyc files while nose is scanning for and running tests. +.UNINDENT +.INDENT 0.0 +.TP +.B \-a=ATTR, \-\-attr=ATTR +Run only tests that have attributes specified by ATTR [NOSE_ATTR] +.UNINDENT +.INDENT 0.0 +.TP +.B \-A=EXPR, \-\-eval\-attr=EXPR +Run only tests for whose attributes the Python expression EXPR evaluates to True [NOSE_EVAL_ATTR] +.UNINDENT +.INDENT 0.0 +.TP +.B \-s, \-\-nocapture +Don\(aqt capture stdout (any stdout output will be printed immediately) [NOSE_NOCAPTURE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-nologcapture +Disable logging capture plugin. Logging configuration will be left intact. [NOSE_NOLOGCAPTURE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-format=FORMAT +Specify custom format to print statements. Uses the same format as used by standard logging handlers. [NOSE_LOGFORMAT] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-datefmt=FORMAT +Specify custom date/time format to print statements. Uses the same format as used by standard logging handlers. [NOSE_LOGDATEFMT] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-filter=FILTER +Specify which statements to filter in/out. By default, everything is captured. If the output is too verbose, +use this option to filter out needless output. +Example: filter=foo will capture statements issued ONLY to + foo or foo.what.ever.sub but not foobar or other logger. +Specify multiple loggers with comma: filter=foo,bar,baz. +If any logger name is prefixed with a minus, eg filter=\-foo, +it will be excluded rather than included. Default: exclude logging messages from nose itself (\-nose). [NOSE_LOGFILTER] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-clear\-handlers +Clear all other logging handlers +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-logging\-level=DEFAULT +Set the log level to capture +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-coverage +Enable plugin Coverage: +Activate a coverage report using Ned Batchelder\(aqs coverage module. + [NOSE_WITH_COVERAGE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-package=PACKAGE +Restrict coverage output to selected packages [NOSE_COVER_PACKAGE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-erase +Erase previously collected coverage statistics before run +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-tests +Include test modules in coverage report [NOSE_COVER_TESTS] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-min\-percentage=DEFAULT +Minimum percentage of coverage for tests to pass [NOSE_COVER_MIN_PERCENTAGE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-inclusive +Include all python files under working directory in coverage report. Useful for discovering holes in test coverage if not all files are imported by the test suite. [NOSE_COVER_INCLUSIVE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-html +Produce HTML coverage information +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-html\-dir=DIR +Produce HTML coverage information in dir +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-branches +Include branch coverage in coverage report [NOSE_COVER_BRANCHES] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-xml +Produce XML coverage information +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-cover\-xml\-file=FILE +Produce XML coverage information in file +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-pdb +Drop into debugger on failures or errors +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-pdb\-failures +Drop into debugger on failures +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-pdb\-errors +Drop into debugger on errors +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-no\-deprecated +Disable special handling of DeprecatedTest exceptions. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-doctest +Enable plugin Doctest: +Activate doctest plugin to find and run doctests in non\-test modules. + [NOSE_WITH_DOCTEST] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-doctest\-tests +Also look for doctests in test modules. Note that classes, methods and functions should have either doctests or non\-doctest tests, not both. [NOSE_DOCTEST_TESTS] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-doctest\-extension=EXT +Also look for doctests in files with this extension [NOSE_DOCTEST_EXTENSION] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-doctest\-result\-variable=VAR +Change the variable name set to the result of the last interpreter command from the default \(aq_\(aq. Can be used to avoid conflicts with the _() function used for text translation. [NOSE_DOCTEST_RESULT_VAR] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-doctest\-fixtures=SUFFIX +Find fixtures for a doctest file in module with this name appended to the base name of the doctest file +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-doctest\-options=OPTIONS +Specify options to pass to doctest. Eg. \(aq+ELLIPSIS,+NORMALIZE_WHITESPACE\(aq +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-isolation +Enable plugin IsolationPlugin: +Activate the isolation plugin to isolate changes to external +modules to a single test module or package. The isolation plugin +resets the contents of sys.modules after each test module or +package runs to its state before the test. PLEASE NOTE that this +plugin should not be used with the coverage plugin, or in any other case +where module reloading may produce undesirable side\-effects. + [NOSE_WITH_ISOLATION] +.UNINDENT +.INDENT 0.0 +.TP +.B \-d, \-\-detailed\-errors, \-\-failure\-detail +Add detail to error output by attempting to evaluate failed asserts [NOSE_DETAILED_ERRORS] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-profile +Enable plugin Profile: +Use this plugin to run tests using the hotshot profiler. + [NOSE_WITH_PROFILE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-profile\-sort=SORT +Set sort order for profiler output +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-profile\-stats\-file=FILE +Profiler stats file; default is a new temp file on each run +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-profile\-restrict=RESTRICT +Restrict profiler output. See help for pstats.Stats for details +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-no\-skip +Disable special handling of SkipTest exceptions. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-id +Enable plugin TestId: +Activate to add a test id (like #1) to each test name output. Activate +with \-\-failed to rerun failing tests only. + [NOSE_WITH_ID] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-id\-file=FILE +Store test ids found in test runs in this file. Default is the file .noseids in the working directory. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-failed +Run the tests that failed in the last test run. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-processes=NUM +Spread test run among this many processes. Set a number equal to the number of processors or cores in your machine for best results. Pass a negative number to have the number of processes automatically set to the number of cores. Passing 0 means to disable parallel testing. Default is 0 unless NOSE_PROCESSES is set. [NOSE_PROCESSES] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-process\-timeout=SECONDS +Set timeout for return of results from each test runner process. Default is 10. [NOSE_PROCESS_TIMEOUT] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-process\-restartworker +If set, will restart each worker process once their tests are done, this helps control memory leaks from killing the system. [NOSE_PROCESS_RESTARTWORKER] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-with\-xunit +Enable plugin Xunit: This plugin provides test results in the standard XUnit XML format. [NOSE_WITH_XUNIT] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-xunit\-file=FILE +Path to xml file to store the xunit report in. Default is nosetests.xml in the working directory [NOSE_XUNIT_FILE] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-xunit\-testsuite\-name=PACKAGE +Name of the testsuite in the xunit xml, generated by plugin. Default test suite name is nosetests. +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-all\-modules +Enable plugin AllModules: Collect tests from all python modules. + [NOSE_ALL_MODULES] +.UNINDENT +.INDENT 0.0 +.TP +.B \-\-collect\-only +Enable collect\-only: +Collect and output test names only, don\(aqt run any tests. + [COLLECT_ONLY] +.UNINDENT +.SH AUTHOR +Nose developers +.SH COPYRIGHT +2009, Jason Pellerin +.\" Generated by docutils manpage writer. +. diff --git a/.direnv/python-3.4.3/pip-selfcheck.json b/.direnv/python-3.4.3/pip-selfcheck.json new file mode 100644 index 0000000..a609fa0 --- /dev/null +++ b/.direnv/python-3.4.3/pip-selfcheck.json @@ -0,0 +1 @@ +{"last_check":"2015-06-25T19:30:37Z","pypi_version":"7.0.3"} \ No newline at end of file diff --git a/.direnv/python-3.4.3/share/man/man1/ipcluster.1.gz b/.direnv/python-3.4.3/share/man/man1/ipcluster.1.gz new file mode 100644 index 0000000..2412b2c Binary files /dev/null and b/.direnv/python-3.4.3/share/man/man1/ipcluster.1.gz differ diff --git a/.direnv/python-3.4.3/share/man/man1/ipcontroller.1.gz b/.direnv/python-3.4.3/share/man/man1/ipcontroller.1.gz new file mode 100644 index 0000000..9a4ca6f Binary files /dev/null and b/.direnv/python-3.4.3/share/man/man1/ipcontroller.1.gz differ diff --git a/.direnv/python-3.4.3/share/man/man1/ipengine.1.gz b/.direnv/python-3.4.3/share/man/man1/ipengine.1.gz new file mode 100644 index 0000000..f35b28d Binary files /dev/null and b/.direnv/python-3.4.3/share/man/man1/ipengine.1.gz differ diff --git a/.direnv/python-3.4.3/share/man/man1/ipython.1.gz b/.direnv/python-3.4.3/share/man/man1/ipython.1.gz new file mode 100644 index 0000000..ce58bf4 Binary files /dev/null and b/.direnv/python-3.4.3/share/man/man1/ipython.1.gz differ diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..94840b3 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +layout python3 diff --git a/Clusters.ipynb b/Clusters.ipynb new file mode 100644 index 0000000..f61ab3f --- /dev/null +++ b/Clusters.ipynb @@ -0,0 +1,1024 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 336, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import random\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.cross_validation import train_test_split as tts" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "% matplotlib inline\n", + "plt.rcParams['figure.figsize'] = 10, 8" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "collapsed": false + }, + "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", + "
mfrtypecaloriesproteinfatsodiumfibercarbosugarspotassvitaminsshelfweightcups
name
100%_BranNC704113010.05.0628025310.33
100%_Natural_BranQC12035152.08.081350311.00
All-BranKC70412609.07.0532025310.33
All-Bran_with_Extra_FiberKC504014014.08.0033025310.50
Apple_Cinnamon_CheeriosGC110221801.510.5107025110.75
\n", + "
" + ], + "text/plain": [ + " mfr type calories protein fat sodium fiber \\\n", + "name \n", + "100%_Bran N C 70 4 1 130 10.0 \n", + "100%_Natural_Bran Q C 120 3 5 15 2.0 \n", + "All-Bran K C 70 4 1 260 9.0 \n", + "All-Bran_with_Extra_Fiber K C 50 4 0 140 14.0 \n", + "Apple_Cinnamon_Cheerios G C 110 2 2 180 1.5 \n", + "\n", + " carbo sugars potass vitamins shelf weight \\\n", + "name \n", + "100%_Bran 5.0 6 280 25 3 1 \n", + "100%_Natural_Bran 8.0 8 135 0 3 1 \n", + "All-Bran 7.0 5 320 25 3 1 \n", + "All-Bran_with_Extra_Fiber 8.0 0 330 25 3 1 \n", + "Apple_Cinnamon_Cheerios 10.5 10 70 25 1 1 \n", + "\n", + " cups \n", + "name \n", + "100%_Bran 0.33 \n", + "100%_Natural_Bran 1.00 \n", + "All-Bran 0.33 \n", + "All-Bran_with_Extra_Fiber 0.50 \n", + "Apple_Cinnamon_Cheerios 0.75 " + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = pd.read_csv('cereals.csv', na_values=-1).dropna()\n", + "data.set_index('name', inplace=True)\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#train, test = tts(data, test_size=.33)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pca_1 = PCA(n_components=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_1 = data.ix[:, 3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pca_1.fit(data_1)\n", + "reduced_data_1 = pca_1.transform(data_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df_1 = pd.DataFrame(reduced_data_1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###Unmodified Data" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHfCAYAAADz6rTQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhCAGAAAQCEEMAAAgEIIYAABAIP8/HtsEp2YS888AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(reduced_data_1[:,0], reduced_data_1[:,1], s=75)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This data is quite variant, let's make it abit more clear." + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "kmeans_1 = KMeans(7)\n", + "pred = kmeans_1.fit_predict(reduced_data_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHfCAYAAADz6rTQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(reduced_data_1[:,0], reduced_data_1[:,1], c=pred, cmap='hot', s=75)\n", + "plt.scatter(kmeans_1.cluster_centers_[:,0], \n", + " kmeans_1.cluster_centers_[:,1], alpha=.2, s=250, marker='*')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see if we can't hack down some of that variation!" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "v = lambda x: 1/x" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_2 = data_1.drop('shelf',1)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_2['normcup'] = data_2.cups.apply(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_2p1 = data_2.multiply(data_2.normcup, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": { + "collapsed": false + }, + "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", + "
proteinfatsodiumfibercarbosugarspotassvitaminsweight
name
100%_Bran12.1212123.030303393.93939430.30303015.15151518.181818848.48484875.7575763.030303
100%_Natural_Bran3.0000005.00000015.0000002.0000008.0000008.000000135.0000000.0000001.000000
All-Bran12.1212123.030303787.87878827.27272721.21212115.151515969.69697075.7575763.030303
All-Bran_with_Extra_Fiber8.0000000.000000280.00000028.00000016.0000000.000000660.00000050.0000002.000000
Apple_Cinnamon_Cheerios2.6666672.666667240.0000002.00000014.00000013.33333393.33333333.3333331.333333
\n", + "
" + ], + "text/plain": [ + " protein fat sodium fiber \\\n", + "name \n", + "100%_Bran 12.121212 3.030303 393.939394 30.303030 \n", + "100%_Natural_Bran 3.000000 5.000000 15.000000 2.000000 \n", + "All-Bran 12.121212 3.030303 787.878788 27.272727 \n", + "All-Bran_with_Extra_Fiber 8.000000 0.000000 280.000000 28.000000 \n", + "Apple_Cinnamon_Cheerios 2.666667 2.666667 240.000000 2.000000 \n", + "\n", + " carbo sugars potass vitamins \\\n", + "name \n", + "100%_Bran 15.151515 18.181818 848.484848 75.757576 \n", + "100%_Natural_Bran 8.000000 8.000000 135.000000 0.000000 \n", + "All-Bran 21.212121 15.151515 969.696970 75.757576 \n", + "All-Bran_with_Extra_Fiber 16.000000 0.000000 660.000000 50.000000 \n", + "Apple_Cinnamon_Cheerios 14.000000 13.333333 93.333333 33.333333 \n", + "\n", + " weight \n", + "name \n", + "100%_Bran 3.030303 \n", + "100%_Natural_Bran 1.000000 \n", + "All-Bran 3.030303 \n", + "All-Bran_with_Extra_Fiber 2.000000 \n", + "Apple_Cinnamon_Cheerios 1.333333 " + ] + }, + "execution_count": 188, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_2p2 = data_2p1.drop(['normcup', 'cups'], axis=1)\n", + "data_2p2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pca_2 = PCA(n_components=2)\n", + "pca_2.fit(data_2p2)\n", + "reduced_data_2 = pca_2.transform(data_2p2)" + ] + }, + { + "cell_type": "code", + "execution_count": 368, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "kmeans_2 = KMeans(3)\n", + "pred_2 = kmeans_2.fit_predict(reduced_data_2)\n", + "kmeans_2p1 = KMeans(6)\n", + "pred_2p1 = kmeans_2p1.fit_predict(reduced_data_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Two kinds of normalized data:" + ] + }, + { + "cell_type": "code", + "execution_count": 391, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 391, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAHpCAYAAADOCzteAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xd4lFXexvHvmZm0SUIV6SBKB3UVAVGRCIgIKKiIqCiu\nBVbcxYKsIhZ27aC4qK+FIqJrAwQVkGKjrCIggogIiPTeS/qU8/4xEwwhEzDJzCTk/lxXLoZ5nnnO\nbyaa3JxznnOMtRYRERERiQ5HtAsQERERKcsUxkRERESiSGFMREREJIoUxkRERESiSGFMREREJIoU\nxkRERESiSGFMRMLOGLPSGHNphNs8Yow5oxivd4Yxxm+M0c9NESlW+qEiUkYZYy4xxnxnjDlojNln\njPmfMeaCcLRlrW1urZ0fjmsX0GaytXZjJNsUESkMV7QLEJHIM8aUA6YD/YGJQBzQFsgqxLVc1lpv\n8VYoIlJ2qGdMpGxqCFhr7Uc2INNa+4W19uecE4wxtxtjVhlj9htjZhlj6uQ65jfGDDDGrAXWGmNe\nM8aMyN2AMeZTY8x9wccbjTHtg4+HGWMmGmMmGGMOB4cwW+R63fnGmGXBYxONMR8ZY57M700YY+ob\nY+YFe/f2GGM+zFPjmcaYGsEhy5yvdGOM/2TeZwh3GGO2GWO2G2MGBa9RzRiTZoyplOd97DbGOPOp\n22GMecQYsy74Pn8wxtTMbyjUGDPXGHNH8PFtxphvjTGvBN/zrzmfa67jvwevud4Yc9MJ3ouIlAAK\nYyJl0xrAZ4x52xjT2RhTMfdBY0x3YAhwDXAasAD4IM81ugOtgCbBYzfken1F4HIgJxzl3XftquBr\nygOfAa8GXxcLTAXeAioGz+mRz+tzPAnMstZWAGoCL+c9wVq7PThkmWytTQam5LyXk3yfeaUA9YFO\nwEPGmA7W2p3AXKBXrvNuAT6w1vryucYgoDdwpbW2HPBXICNEe5Zj338rYB1QGXgCmGKMqWCMSQRG\nAZ2D12wDLD/BexGREkBhTKQMstYeAS4h8Et+DLA72JN1evCUvwHPWmvXWGv9wLPAX4wxtXNd5llr\n7UFrbRbwP8AaY9oGj/UEvguGlPwssNbOsoHNcf8LnBt8/kLAaa19xVrrs9ZOBRYX8FaygTOMMTWt\ntdnW2u8Ket/GmIeARsDtf+J95vUva22GtXYlMB64Mfj8O0CfYDtOAmHr3RDXuAMYaq39DcBa+7O1\ndn9Bteey21o7Kvj5TCQQrLsR+F76gbONMQnW2l3W2lUneU0RiSKFMZEyylq72lr7V2ttbaA5UAP4\nT/BwXWCUMeaAMeYAsC/4fM1cl9iS61qWQC9YTjC5CXivgOZ35XqcDsQHh+ZqANvynLsFMCGu88/g\nscXB4c6/hmrQGHMlMBDoEQyQcHLvM68tuR5vDtYM8CnQNHgH5+XAIWvtDyGuURv4vYA2CpL389kE\nVLfWphPonfwbsN0YM90Y06iQbYhIBCmMiQjW2jXABAKhDAIho5+1tmKur0Rr7fe5X5bnMh8APY0x\ndQkMpX1ciFJ2cHwQqpNPWzl177LW9rPW1iRwM8Jrxpgz854XDCVvA9dba3OHmZN5n3nVyfN4W7CW\nTGASgd6xPgR6ykLZQmCoM6+04J/uXM9Vy3NO3s+nLrA9WMMca22n4GtWE+j1FJESTmFMpAwyxjQy\nxjxgjKkZ/HttAr1aC4OnvAE8YoxpGjxe3hhzfUHXtNYuB/YCYwnM4zpciNIWEpjL9ndjjCs4p6tl\nAe/jemNMreBfD/LHUF3uc8oR6LUams8w5p9+n8CjxpgEY0wz4Dbgo1zH3iEw/+tqQg9RQuAzejJ4\nA4IxxpxjjKlkrd1DINzdYoxxGmNuB87K89rTjTEDjTExwVobAZ8bY043xnQPzh3zEAh2+c1XE5ES\nRmFMpGw6ArQGFhljUgmEoBUEJpZjrf0EeB740BhzCPgZuCLX60NNqH8faB/8M5S8E9KPXs9amw1c\nS2BO1QHgZgJLcGSHuNYFwPfGmCMEAtfAXGuL5bRxPoG7R1/KdUfl4ZN8n/nVPo/ABPovgRHW2i+P\nHrT2WwJhcKm1dkv+lwBgJIElReYAhwj0YMUHj90FDCYQbJsC3+Z57SKgAbCHwA0MPa21Bwj8PL+f\nQJjbR2CpkrsLqEFESggTmOpRyBcbE0/gB1McEAt8aq0dEry9+yMC3ecbgV7W2oPB1wwhMHnWR+AH\n55wivQMROaUZYxYBr1lrJ0S7lpNhjPkSeN9a+1YYrn0bcIe1tu2JzhWR0qNIPWPBORKXWWv/ApwD\nXGaMuQR4GPjCWtsQ+Cr4d4JDATcQ+NdeZwLzO9Q7JyJHGWMuDa7b5TLG9CUwj21WtOs6GcaYlgR6\n4j460bkiIjmKHISCd/BAoGfMSWBo4WoCk4EJ/tkj+Lg7gXV3PMGhhHUEJvqKiORoRGB9rAMEht16\nWmt3FfyS6DPGTAC+AO6z1qad6PxCym+IV0RKuSINU0JgJWngRwKTTF+31v7TGHPAWlsxeNwA+621\nFY0xrwDfW2vfCx4bC8y01hbmrisRERGRUq/Ie1MGF0r8izGmPDDbGHNZnuPWGFNQ4jvu2AnOFxER\nESlRrLWh1kM8oWKbr2WtPQTMAFoAu4wx1QCMMdWB3cHTthFY7DBHLY5fwDDnevrK8/XEE09EvYaS\n9qXPRJ+LPhd9LvpM9LlE+6uoihTGjDGnGWMqBB8nEFh1ehmBveb6Bk/rC3wSfPwZ0NsYE2uMqUfg\n9uyCtjoREREROaUVdZiyOjAhOG/MAbxrrf3KGLMMmGiMuYPg0hYA1tpVxpiJwCrACwywxREpRURE\nREqpIoUxa+3PBG7jzvv8fqBjiNc8AzxTlHbLqpSUlGiXUOLoM8mfPpf86XPJnz6X4+kzyZ8+l/Ao\n8t2U4WCMUYeZiIiIlArGGGxJmMAvIiIiIn+ewpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESR\nwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiI\niESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmM\niYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhI\nFCmMiYiIiESRwpiIiIhIFCmMiYiIiESRwpiIiIhIFLmiXYDIqc7v97N582Z8Ph9169bF5dL/diIi\n8gf1jImEibWWN954g8aNG3PxxRfToUMH6taty9NPP43H44l2eSIiUkIojImEyQMPPMDYsWMZP348\nW7duZePGjcyaNYsFCxbQq1cvfD5ftEsUEZESwFhro13DcYwxtiTWJXKylixZwnXXXceKFSuoUKHC\nMceys7O55JJLGDRoEDfccEOUKhQRkeJijMFaawr7evWMiYTBmDFjGDBgwHFBDCA2NpbBgwczZsyY\nKFQmIiIljcKYSBj89ttvtGrVKuTxli1bsnbt2ghWJCIiJZXCmEgYlC9fnh07doQ8vmPHjnx7zURE\npOxRGBMJg969ezNmzBhCzX0cM2YMvXv3jnBVIiJSEimMiYTBtddey8GDBxk6dCher/fo8znLXXz5\n5Zf069cvihWWXIcPH+bVV1/lsssuo1WrVtx+++0sXrw42mWJiISN7qYUCZPdu3fTu3dv1q1bx7XX\nXktsbCzTpk0jLi6OiRMn0rBhw2iXWOKsXbuWyy+/nFatWnHbbbdRuXJlFixYwMsvv8ytt97K008/\nHe0SRUSOU9S7KRXGRMJs+fLlzJkzB5/Px8UXX0zbtm0xptD/z56yfD4fzZs35/777z+u13Dv3r20\na9eOxx57TMO7IlLiKIyJyClhxowZDBs2jCVLluR7fNq0aTz11FMsWrQowpWJiBRM64yJyCnh66+/\n5rrrrgt5vEuXLqxYsYLU1NQIViUiEn4KYyJSIlhrcThC/0gyxuT86zOCVYmIhJ/CmIiUCJdeeimf\nfvppyONz5syhcePGJCcnR7AqEZHwUxgTkRKhW7du7Ny5k/fff/+4Y4cPH2bIkCHce++9UahMRCS8\nNIFfREqMn3/+mc6dO3PFFVccXdpi/vz5vPTSS3Tu3JlRo0bpTlQRKXF0N6WInFL27t3L2LFj+fjj\nj0lLS6NZs2bcfffdXHbZZQpiIlIiKYyJiIiIRJGWthARESkFPB4P27Zt48CBA9EuRUoYhTEREZEw\nOnLkCA8++CCVK1emYYMGVKtaldatWvHVV19FuzQpITRMKSIiEiapqam0btWKTevX48/KwgFYwAc4\nExJ4c/Ro+vTpE+Uqpag0TCkiIlJCPfPMM2xavx4bDGIABnACnowMbuvbl44dOvDKK69w6NChKFYq\n0aSeMRERkTDw+/1UrlyZrIMHj+n58AFZBHpDXMHn4txurNPJtGnTaNeuXcRrlaLR3ZQiIiIl0MGD\nB6latSox2dlHn7NABhDLH0Eshw9wJSWxatUqateuHblCpcg0TCkiIlICJSQk4Pf7yd214CEwRJk3\niBF83mZn8+qrr0akPik5FMZERETCIC4ujg7t2+PL9ZyP/IPY0ePZ2UyeNCnMlUlJozAmIiISJk8+\n9RROt/uYQFYQA2TnGtaUskFhTEREJExatmzJ5MmTiS1XDldSEgDeAs63Dgdt2rSJTHFSYmgCv4iI\nSJhlZmYyZcoUvv76a9555x1cHs9xvSF+wOF289XXX9O6detolCmFpLspRURESpFRo0Yx9JFH8Kan\n4ww+5wVi3G4eHjKERx99NJrlSSEojImIiJQyCxYs4Jmnn2b+ggVYa7nwwgsZOnQoHTp0iHZpUggK\nYyIiIiJRFNV1xowxtY0x3xhjfjHGrDTGDAw+X8kY84UxZq0xZo4xpkKu1wwxxvxmjFltjOlUlPZF\nRERESrsi9YwZY6oB1ay1y40xScBSoAfwV2CvtXa4MeYhoKK19mFjTFPgfaAlUBP4EmhorfXnua56\nxkREpMzbs2cPGzdupGLFitSvXz/a5UgIUe0Zs9butNYuDz5OBX4lELKuBiYET5tAIKABdAc+sNZ6\nrLUbgXVAq6LUICIicqrZsGEDXbp0oU7t2nS6/HLOPeccGjduzMyZM6NdmoRBsa0zZow5AzgPWARU\ntdbuCh7aBVQNPq4BbM31sq0EwpuIiIgQCGItWrTgm9mzcWRl4Tl0CDIy2LhmDT179uTDDz+MdolS\nzAraleGkBYcoPwbutdYeMeaPnjprrTXGFDTmmO+xYcOGHX2ckpJCSkpKcZQqIiJSot1/331kHDqE\n0//HDB5D4Be2Lz2dfv360aNHD+Lj46NWY1k3d+5c5s6dW2zXK/LdlMaYGGA6MNNa+5/gc6uBFGvt\nTmNMdeAba21jY8zDANba54LnzQKesNYuynNNzRkTEZEy5+DBg1SvVg1HVhahJiC5kpMZPXYsvXr1\nimhtElq076Y0wDhgVU4QC/oM6Bt83Bf4JNfzvY0xscaYekADYHFRahARETlVbNu2jdjY2JBBDCA7\nI4MNGzZErCYJv6IOU14M9AFWGGOWBZ8bAjwHTDTG3AFsBHoBWGtXGWMmAqsILDg8QF1gIiIiAZUq\nVSI7OxsHhAxkMXFxVK5cOZJlSZhp0VcREZESpHWrVvy0ZEm+vSV+wMbHs3XrVgWyEiSqw5QiIiJS\nvF4cORKn240vz/N+wOl2M3DgQAWxU4zCmIiISAlyySWXMGXKFJJOOw1XcjImPh5XUhLEx/OPe+/l\n2WefjXaJUsw0TCkiIlIC+Xw+5syZw7p166hQoQJXX3015cuXj3ZZkg9tFC4iIiISRZozJiIiIlKK\nKYyJiIiIRJHCmIiIiEgUKYyJiIiIRJHCmIiIiEgUKYyJiIiIRJHCmIiIiEgUKYyJiIiIRJHCmIiI\niEgUKYyJiIiIRJHCmIiIiEgUKYyJiIiIRJEr2gWIiIhI8Tp48CD//e9/+fXXXznttNO46aabaNSo\nUbTLkhCMtTbaNRzHGGNLYl0iIiIl3ZgxY7h34EBcDgdZ6ek4XS5wubiySxfef/994uLiol3iKccY\ng7XWFPr1JTH0KIyJiIj8edOmTaN3797Y9PRj5iFZwJGQwNXXXMN7770XrfJOWQpjIiIiAkDTpk1Z\n/+uv+c5BsoA/Lo61v/1G7dq1I13aKa2oYUwT+EVEREqp9PR0Ro0axZlnnkl8fDyrf/0VZ4hzDeAy\nhk8//TSSJcpJ0AR+ERGRUujw4cNcfNFFbNqwAU96OjndMgV1z3g9HlJTUyNRnvwJCmMiIiKl0MCB\nA9mwbh02KwsngWFIC/gJPewV53bTrFmziNUoJ0dzxkREREqZQ4cOUb1aNcjMPCZ4ZQX/zO9+SR+Q\nVLkyO3buxOVSX0xx0pwxERGRMmbVqlXExcUd90s8lkDoyiLQQwaB3jKvMTjcbiZNnqwgVgIpjImI\niJQysbGx+P3+4543QELwz0wgy+XCExNDxy5d+Pbbb0lJSYlsoXJSNEwpIiJSyng8HqqefjqZBw/m\n26tiAV9sLEt//JH69etrodcw0zCliIhIGRMTE8M/H3oIV2IiebsuLOCIj+fq7t1p1qxZgUFs/fr1\nvPXWW4wbN441a9aEtWYJTT1jIiIipZDf76dfv358+MEH+LOy8Pt8YAyxiYmcd955zJw1C7fbne9r\nDxw4wA033MC8efOIMQaMwQ+0uOACJk+eTNWqVSP7Zko5rcAvIiJShv3000+89tprrF2zhurVq9Ov\nf3/atWuHMflng+zsbBo2bMj2TZuI4Y91ySzgdzqpXrs2P69cSWJiYqTeQqmnMCYiIiIn7eGHH2bE\n888Tz/ELxFqAuDheeOkl7r777sgXV0opjImIiMhJsdaSkJAAWVkhV333Ag2aNePnlSsjWVqppgn8\nIiIiclJ++OEHPNnZBW6Z5AB27toVqZIEhTEREZEyY8eOHTidTo5foewPfqBSxYqRKklQGBMRESkz\nqlevjsvlwgPHLYlB8DkP0OeWWyJbWBmnOWMiIiJlhLWWM+rWZeuWLRgC2yfl9Mr4gWzAGRvLkSNH\niI2NjVqdpY3mjImIiMhJMcYweswY4uLjAcgIfqUH/zROJx9++KGCWISpZ0xERKSMmT17Nv369WP/\nvn0YwOf3U7FiRd4cPZquXbtGu7xSR0tbiIiIyJ9mrWXJkiVs27aN6tWr07p165ALxUrBFMZERETk\nT0tNTcVaS3JycrRLKfU0Z0xEREROirWWDz74gCZNmlCxYkUqVapEg/r1mTBhAuoEiR71jImIiJQR\ngwYNYvSbb+JJS8MZfM4HxCYm0vumm3jzzTc1VFkIGqYUERGRE1q0aBEd2rfHpqfnuyelIzGRz6ZN\n47LLLotGeaWahilFRETkhEaOHIkvMzPfrZAM4ElL44UXXoh0WYLCmIiISJmwfPly8IfeCMkB/Lxi\nReQKkqMUxkRERMqApMTEfLdAymEBt9sdqXIkF4UxERGRMqDvbbcRV0DYciUkcGvfvgVeY//+/bzw\nwgtc1KYNLVu2ZMiQIWzdurW4Sy1zNIFfRESkDDh06BANGjTgyN69OPP8jvUC7ooVWbt2Laeddlq+\nr1+4cCGdr7gC6/ORnZ4OQExcHD6Hg3feeYeePXuG+y2UWLqbUkRERE7K2rVrufzyyzl44AAZR44A\n4E5Oxp2YyJwvvqB58+b5vm7//v3UO+MMso4cwZXnmA9wuN0sXryYZs2ahfcNlFBFDWN5P1MRERE5\nRTVs2JD169cza9YsZs+ejbWWjh070rVrV1yu0JHgrbfewvp8+YYGJ+DPyuKFF15g/PjxYav9VKae\nMRERESnQRW3a8OP334fswfEDyVWqsGv37kiWVWJonTEREREJK6/Pd8JzfAUsmyEFUxgTERGRAnXs\n2JGYuLiQx/3GcPHFF0ewolOLhilFRESkQFu3bqVhw4bYjIyje1rm8BOYwD/niy+46KKLolFe1GmY\nUkRERMKqVq1avPPOOzjcbvxOJ34CIcxrDA63m0cfe6zMBrHioJ4xERGRMNm5cycHDhygZs2alCtX\nLtrlFNmqVasYMWIEn3/+OX6fj4suuoiHHn64zAcxrTMmIiJSwsyfP59BDzzAypUriY2NJdvj4eqr\nr+bFF1+kVq1a0S5PipnCmIiISAkyffp0bujVC19wfpUhsO+j3+kkuWJFfly2TIHsFKMwJiIiUkJ4\nPB5OP/10Mg8ePG6iO4DP6aRrjx5Mnjw54rVJ+GgCv4iISAkxffp0rM+XbxADcPh8zJg+nYMHD0a0\nLinZFMZERESKyW+//UZ2RkbI4waIi4tj69atkSsqivbv38+OHTvwncSisWWZwpiIiEgxqVixIjGx\nsSGPWyArO5sKFSpErqgomD59Oueeey7Vq1fnrLPOokqVKjz++ONkZmZGu7QSSXPGREREismePXuo\nU6cOjsxM8ptA5AUan3suy5cvj3RpEfPqq6/y0EMP4UtPP3oDgx9wxsfT/C9/Ye7cucQVsJp/aaQ5\nYyIiIiVElSpV6N+/Pw63m7xdCj7AmZDAiy++GI3SImL79u0MHjwYm56OC44GUgfgz8xk5YoVvPnm\nm1GssGRSGBMRESlGL774IrffeSf++Hgcbjc+pxNXcjKx5cox4Z136NChQ7RLDJuxY8fiIv9wYQBv\nevopHUYLq8jDlMaYt4CuwG5r7dnB5yoBHwF1gY1AL2vtweCxIcDtBP6RMNBaOyefa2qYUkRESrXd\nu3czZcoUDhw4wFlnnUX37t1PueG5vK655ho+/+QTYkIct0CGMfh8Powp9KheiRP1dcaMMW2BVOCd\nXGFsOLDXWjvcGPMQUNFa+7AxpinwPtASqAl8CTS01vrzXFNhTEREpJS5/fbbeW/8+JBhzA+QkEB6\nenoEqwq/qM8Zs9YuAA7kefpqYELw8QSgR/Bxd+ADa63HWrsRWAe0KmoNIiIiEn233HILcUlJx82X\ny2GdTq677rqI1lQahGvOWFVr7a7g411A1eDjGkDuxVW2EughExERkVIuJSWFho0aQWzscYHMS+CO\nyqFDh0ajtBLNFe4GrLXWGFPQmGO+x4YNG3b0cUpKCikpKcVbmIiIiBQrYwxffPEFV199Nct+/BFv\nZiZ+v5+EpCRiY2L49NNPady4cbTLLLK5c+cyd+7cYrtesawzZow5A5iWa87YaiDFWrvTGFMd+MZa\n29gY8zCAtfa54HmzgCestYvyXE9zxkREREqxZcuW8dlnn5Gens4FF1xAjx49iIkJNZusdIv6BP5g\nEWdwbBgbDuyz1j4fDGAV8kzgb8UfE/jr501eCmMiIiJSWhQ1jBV5mNIY8wHQDjjNGLMFeBx4Dpho\njLmD4NIWANbaVcaYicAqAsPHA5S6REREpCzTdkgiIiIiRRD1pS1EREREpPAUxkRERESiSGFMRERE\nJIoUxkRERESiSGFMREREJIoUxkRERESiSGFMREREAMjOzmbTpk3s3r072qWUKQpjIiIiZVxaWhqD\nBg3itNNOo1nTptSpU4ezzz6badOmRbu0MkGLvoqIiJRh6enptGnTht/XrMGflYUDsIAPcLrdjBgx\nggEDBkS5ypJNi76KiIhIob300kusX7sWGwxiAIbAfok2PZ1BgwaxZ8+eKFZ46lMYExGRYrVu3Toe\nGPh3LmjagAuaNmDw/feyfv36aJclIbw8ahTezEzy69ZxAC5jGD9+fKTLKlMUxkREpNhM/PBD2px/\nDrHzRvNqnXW8Umcd5qvXaX3e2UydMiXa5Uke2dnZ7Nm7t8AwkJ2RwU8//RSxmsoiV7QLEBGRU8Pa\ntWv5e/87+PrSDM6u+Mfzbap46F3LwxV/vYW/nHce9erVi16RcoyYmBhcLhd4PCHPMQ4HlSpVimBV\nZY96xkREpFi8Nuol7joj+5ggluP8ynBrXS9vvPpK5AuTkIwx9OjeHb8j/zhggZiEBG655ZbIFlbG\nKIyJiEixmPvlbK6p6Q15/Jrq2cyd83kEK5KT8cSwYTjj48n7nbOAiYujxQUX0LJly2iUVmYojImI\nSEQU+r7/EsRay48//siHH37IzJkzyczMjHZJRdasWTM+nzmTxEqVcCUnkw34Y2KwCQm0TUlh+vTp\nGHMqfPdKLs0ZExEpxXw+H/PmzWPr1q1UrVqV9u3bExMTE5VaUjpewdT/jeWCyvn3jk3ZEUtKpysj\nXFXxWbp0KTfffDPbtm7F5XCAMfis5fHHH2fQoEGlOrBceuml7Ny5k+nTp7N8+XLcbjfdu3encePG\n0S6tTNCiryIipdS0adO49293UoEMmpaz/J5m2JLp4rkX/kOfW2+NeD1r167lkpbn8VXb9OPmjS3b\nD53+52bx8pWlcgL/ypUradOmDZ7UVJz80cvnJ7Aw6uCHHuLxxx+PYoUSTUVd9FVhTESkFJo1axa3\n3XAtH7XOoF3VP55fug+u/d7NM6Pe4OYoTLp+5JEhvDziOf7WAK6vC9bCxE0weh3c989HeOrpp4u9\nzczMTCZOnMjc2TMASLmiK7169SI+Pr7Y2riyc2e+nj2b/Poc/YCNj2fbtm2667CMUhgTESljrLWc\n2+hMnq+1kStrHn/8h31wzdJKbNi2K7BsQYRs2bKF85s34ZWz01i8D+YF95q+rCq0qQJ/W178PWNL\nly6l+5WdODs5m2uqpAIwdU8SPx+J5dOZc2jRokWR2zh48CBVq1bFlZ0dct6b0+1m+MiR9O/fv8jt\nSelT1DCmOWMiIqXMTz/9RPqBvXRulf/xCypDjVgP33zzDZdffnnE6nrz/17lxtoeeteD3vnkre8O\neHnj1Zd5/sWXiqW9PXv20K1TB15rfohr6vzxfL8GqUzdDF0vb8+K1b9x+umnF6mdffv2ERsTg83O\nDnlOZno6O3fuLFI7UnbpbkoRkVJm9+7d1CvnpKD54mclWXbv3h25ooAvP/+M62uGDiy9ambzxefT\niq29saPfpEvVrGOCWI5r6kDXatmMGzO6yO1UqVIFj9dLQeM18YmJ1KyZTzelyElQGBMRKWVq1arF\n6gMefP4qvK+IAAAgAElEQVT8j1sLvxwKnBdJPp+PmAICossEzikun018nz41Qy8tcUvNTD6d+F6R\n2ylXrhydr7gCX4j06wc8fj/XX399kduSsklhTESklGnatCk165zBpM35H/9mF6S7kmnbtm1E67o4\npQPTdoSe/TJth5NLUtoXW3uZWZmUK2AVj3IxkJmZVSxtjXjhBeKSk/Eac0wPmQ9wuN089dRTlC9f\nvljakrJHYUxEpBQa+doY/rHCzQcbwBvsIfNbmL4VblqcwKg3xuIIscVNuNw98D5Gb4hh9aHjj/12\nGF5fH8uAex8otvbOu6AVX+0O/R6/3O3g/JYhJtb9SQ0aNGDhwoX8pWVLbEICseXL40pOJvm00/jP\nqFE88EDxvS8pe3Q3pYhIKbVw4UIG3dOPzRvW06hiDOsPe6lQpRrPj3qNTp06RaWmdydM4MGBd/OP\ns7K5tqYPY2DqNicvr4vlmRdHcfuddxVbW0uWLOGaTiks7ZBO1YRjj+3KgBZfuZk6Z26xb+Wzbt06\nfvvtN8qXL0/r1q1xOp3Fen0pfbS0hYhIGbd69Wq2bNlC1apVOfvss6O+EvyKFSt4deQLfPPVHKyF\ndpe15+8PDOa8884r9rae/tcwxr8ygmGN0rk2OJF/6hZ4YrWbv/5jMEOfGFbsbYrkpTAmIiJl2owZ\nMxj1/FPMXbgEgJQ2Lbn3oUfp2rVrlCuTskJhTEREhMBiuEDUewal7NGiryIiIiiEhZKdnc33339P\nRkYGzZs313poJZDCmIiIyCnIWsuzzz7L888/j4NAWM3IzOTSdu0YP348NWrUiHaJEqRhShERkVPQ\nwIEDGT9uHL709KPrWFnAOp1UqFKFn1asoEqVKtEs8ZRR1GFKrTMmIiJyivn9998ZO2YM/lxBDMAA\nDp+PQ/v3M3z48GiVJ3kojImISL58Ph+ff/45Tzz+OE8++SQ//PBDVOpYs2YNf+9/J2fVrEqdqpXp\n2a0zc+fOjUotpcW4ceMwPh+humpsdjZjRhd9304pHgpjIiJynCVLllC32mkM7nMV/qlPcvCDx7mm\nw8WkXHhBRDcgnz59Om1bnU/lxROY3mI38y/aT4c9s/nrdV3512NDI1ZHafP777/j9XhCHjfA4SNH\n8Hq9kStKQtKcMREROcbatWtpcXYTRrf0c2O9P573+eHh5fCFvz4//PwrLld47wHbs2cPjc86g1kX\np9PytDzHMuHCbxJ588NP6NixY1jrKI0efPBBXhs1CkeIsOUHnImJHElNjWxhpyjNGRMRkWLV+9oe\n3HrGsUEMwOmA4eeBY+9Gpk2bFvY63ho7hu417XFBDKBKPAypn8bLw58Jex2l0e233w4xMYTs1nC5\n6HvbbRGsSAqiMCYiIkft27ePdWt/5W8N8j9uDNxT38uE0a+FvZbvvv6CbqdnhDzerRYsXLwk7HWU\nRk2bNqVnz5443G78uZ63gM/hIKFcOYYMGRKt8iQPhTERETlqyZIl+C3HbbydW9V42LF1S9hrcbpc\nZPtDH8/2g9OhX2OhjB8/nrv698ckJBBTrhwxycmQkECz885j8eLFWvy1BNF/xSIicpQxhnKxDhbu\nCX3O//ZA9br1Qp9QTK7ofh0TdyWGPD5xs4MrrugU9jpKK6fTyciRI9mxcyfjJ0zg9dGjWfLDD/zw\nww+cddZZ0S5PctEEfhEROergwYPUrHo655TzML8TxOT5J/uuDGj4Gcz4egGXXHJJWGtJTU2lUb06\nvNz0ANfVOfbYqoPQfoGbGV/Np0WLFmGtQ+RENIFfRESKTYUKFbi1z03syjJ0+waW7Q8877cwaztc\nNBsaNG4S9iAGkJSUxLTZX/KPXyrQa5GbqZsDNdy7PJa2cxN48ZU3FMSKibWWefPm0aNHDxo2bEir\nli0ZPXo0aWlp0S6tTFDPmIiIHCMjI4OrOrXntxVLycwOrFWV5YNYp6FyzTNYsnwFSUlJEavn0KFD\n/Pfdd5nx8Yd4srNp3fYy+g24hzp16pz4xUXk8Xj47rvvOHLkCI0bN6Z+/fphbzPS/H4/t99+Ox9P\nnownPR1jLRaIS0ykXMWKfPfdd9SuXTvaZZZoRe0ZUxgTEZHjeL1epk+fzrj/+w8bN26kWrXq9Bv4\nAD169CAmJiba5YWdtZaXX36ZYcOGYf1+HMaQmZ3NOeecwzvvvEPDhg2jXWKxefnllxk6ZAj+9PTj\nVuz3O53Ub9qUn376CWMKnTVOeQpjIiIixWzYsGG8OGLEcZts+40hvnx5fvzxR+rVC/9NDOHm9/up\nWbMmB3fuxJnPcQs4EhP54ssvufDCCyNdXqmhOWMiIiLFaPfu3Tz//PPHBDEIbCHktJbMw4cZOvTU\n2Ipp69atHD58OGQYMIA3M5Ovv/46kmWVOQpjIiIiuXzwwQe4CP0L0uH3M2XKFDIzMyNZVlhYazEQ\nckPxnHMkvBTGREREctm8eTNZBQQtAzgcDg4cOBC5osKkVq1aJCYm4gtx3AKxCQlceumlkSyrzFEY\nExERyaVWrVrExceHPG4JzLWqUKFC5IoKE6fTyYODB+Nyu/Pdx9I6HNSsXZuLL7444rWVJQpjIiIi\nudx44414IeQm2z6Hg6uvuoqEhAL2jCpFHnjgATp36YIzMREP4Ad8gMPtplyVKsyYMUN3UoaZwpiI\niBQLay27d+9m+/bt+P0FbCpZwlWrVo377rsv3022vcYQl5TE0888E63yip3T6WTixIl8OHEibTt0\noHLNmpzZtCn/euop1qxZw5lnnhntEk95WtpCRESKxFrLe//9Ly8+8y82bdlKjNOBOzGJe+4bxH0P\nDMLlckW7xD/NWstzzz3Hs888g9PhwADZXi/169fnvfffp1mzZsXWVkZGBn6/n8TE0PtwSsmmdcZE\nRCSqHn/kYT4e9wovNU+nY3VwGFiyFx5e5abSuSl8OPUznM78VrEq+TIzM5k3bx6HDx+mSZMmNG/e\nvNiuPWXKFP71r3/xyy+/YIzhjLp1eWToUG677TYNC5YyCmMiIhI1P//8M50uac2KThlUyTPnPcsH\nbeclMmjkOG644YboFFhCPfbYY7w0ciTe9PSji636gJjERK7v1Ytx48YpkJUiCmMiIhI1//jbXVRe\nNJ5hzfNfHGHSJnjd04KvF/4Q4cpKrp9++omL2rSBjIzj1vfKWfF+0uTJdO7cORrlSSFoBX4REYma\n1T8v56JKoVapgjanwerf1kWwopLvpZdewp+dne9CqwbITkvjhRdeiHRZEkUKYyIiUmjlKlRkVwEL\n0e/OhHJJmpie249Ll4IvdIB1Ait//jlyBUnUKYyJiEih9br1DsZtSyLUzJJxm+PodfOtkS2qhEtK\nSgq5hhkEhipPlTXM5OQojImISKFdc8017I87nSd+ceHPlTCshfc2wNSdCdz994HRK7AEurVvX+IK\nWMbCGRdHn1tuKbb2rLW8/fbbdO3ala5duzJhwoRiu7YUD03gFxGRItm5cyc9r+rMjg3ruL56BnEO\nP9P3JnHEVZ6Pp8/k7LPPjnaJJUpqaioN6tfn4J49OPz+Y+aOeYH48uVZvXo11apVK3JbixYtIiUl\nhazMzGPu2oyPj2fuvHm0atWqyG2I7qYUEZESwFrL4sWLmT1rFl6vlzYXXcQVV1yBw6EBmPysW7eO\njh07cmDfPjJSUzFAQnIysfHxzJo1i/PPP7/IbezcuZNaNWvi8PuJgaOhz0Jg2yOnk61btxZL6Cvr\nFMZERERKoS1btjB48GDmfvMNxhiu6NyZESNGUKVKlWK5fu/evZn80UeE2vI8E7i+d28++OCDYmmv\nLFMYExERKWUmT55M31tvxfj9eLOyAIhzuzEuF7PnzKF169ZFbsOdkIA/M5NQm1F5AUdCAunp6UVu\nq6xTGBMRESlFfvnlF1q1aoU/1+r7ObxAfLlybNy0iQoVKhSpnRiXC5fPd1wbOXyA1+XC4/EUqR3R\noq8iIiKlyogRI7BZWfmGJBfg93qL5Y7H8hUq4C/guB+oUL58kduRootKGDPGdDbGrDbG/GaMeSga\nNYiIiETD5zNmFLjoa3Z6OpMmTixyO/fffz8eyHdNs5xJ/Pc/8ECR25Gii/gwpTHGCawBOgLbgCXA\njdbaX3Odo2FKERE5JVWuXJmM/ftD9oZ4gXNbtWLRokVFasfv91OrZk127tx59DlH8MsL1KxVi02b\nNumO12JQGocpWwHrrLUbrbUe4EOgexTqEBERibgLL7wQvwn9ezsmLo6OHTsWuZ2ffvqJ9PR0YhwO\n4oB4Ar/0PUDtOnVYt26dglgJEY3vQk1gS66/bw0+JyIicsp7+OGHcSUk5Dufywf4HA4GDBhQpDay\ns7Pp1KkTmYcPE+P34yTwCz8WcAP79+1jypQpRWpDik80wpjGH0VESqF9+/bx4ogR3HhNN/r27smk\nSZPCeife9u3b+fXXXzl8+HDY2oiGtm3b8vCQITjcbrzG4Ccwmd7vdOJ0u5kwYQI1axatj2Lq1Kl4\ngsta2OD1c375GsCTlsZTTz1VpDak+IRafiSctgG1c/29NoHesWMMGzbs6OOUlBRSUlLCXZeIiITw\nydSp3NG3D91qWrpWyiDNC/83eA6P/vMBZn41jzPPPLPY2vrqq68Y9vAgfl29htPcMexM9XDtNT14\nesRIqlevXmztRNOjjz5Ku3bteO6551i4cCFOp5Mrr7ySf/7znzRv3rzI1//iiy9IT03FEpgfZgiE\nMSeB3jEnsHr1arKzs4mNjS1ye2XN3LlzmTt3brFdLxoT+F0EJvB3ALYDi9EEfhGREmv58uV0ancR\nsy7O4PzKxx57da2DV3bVYOVv64mJiSlyW5MnTeIfd/Xl5XMy6FEbYhywJxNeXONi4v7KfLtkWYkN\nZNZavvvuO9555x327t3Lueeey5133kmNGjUiXkuvXr2YNGkSMXB0K6ScYJZNYP5YtsNBZmZmsXzf\nyrpSueirMeZK4D8Ewvk4a+2zeY4rjImIlBB9e19P83VTGNwk/1WrUhYkMWD4OHr16lWkdjIzM6lT\n/XRmtjlCi8rHH//nTy4Ont+b0W+/W6R2wuHIkSN06dKF5cuW4UlPx1pLTFwcPmN46qmnGDRoUETr\nadyoERvWriW/mJUTyM4591yWL18e0bpOVaXxbkqstTOttY2stfXzBjERESlZpn3+OX3qhl4+9OZq\nqUyb/GGR25k6dSrnVbT5BjGAQQ29TJw8mbS0tCK3VRCfz8f06dO5+eab6d69O88++yy7d+8u8DXX\nX389y5YswZ+WhsvaQAjKysJkZvLE44/z8ccfh7Xm3NavX8/mzZtDzkPKWWy2T58+kSpJTkD3tIqI\nSIGysj0kFTCSlRwD2ZkZRW5n3bp1XJAUOmhVTYBK8S527NhR5LZC2bFjB02bNOHmG29k8vvvM+uz\nz3j2ySc5o25d3n03/x651atXM3/ePGxWFnm7RhyANz2doUOHhq3mvH777Tfi4+KOqyWHAeJjY6My\nfCr5UxgTEZECXXBOc+YUkH/m7E3g/DZti9xOxYoV2eGJD3k8ywf7MzyUD9MWPn6/n/bt27Nl/Xq8\nqalH51v5MzIgM5O/9e/P//73v+NeN3z4cDyZmSHDjxPYtGkT27dvD0vdeZUrVw6/v6CNkCAuPp5y\n5cpFpB45MYWxUmLNmjXMnj2bH374Ac2nE5FIGjDoIZ5cm0hqPqtY/HQAPtkKt995V5Hbufbaa5m6\nxc+BrPyPT9wELc//C1WqVClyW/n56quv2L51K8bny7eHy5eRccyd/gCLFy/mvyF6zHIYApt2Z2Zm\n/ql6rLXs2bOH3bt3/6mf+61atSI2Lo5QGy75Aa/fT4cOHf5UPRI+CmMl3NKlS2nbti3t27fnxRdf\npE+fPjRt2lSL9YlIxPTq1YtWV1xL23mJTNkMaV7YlQEvrTZ0WpDAm+PeLpaAVKNGDfr2vY1rv3ez\nP08g+3Y3PLgygcefGVHkdkKZPHkymampBfZwffPNN8f0Og0dOhTr9Z5wQ27gpNcO8/v9/Pvf/6ZG\njRrUrl2bOnXqULduXV577bWTCmVOp5Onn3kGp9t9XF1+wJmYyCOPPEJCQsJJ1SMRYK0tcV+BsuTH\nH3+0VapUsW+//bb1eDzWWmv9fr/9+uuvbc2aNe37778f5QpFpKzw+/32gw8+sJe0ONfGx7psOXe8\nvbnnNXbJkiXF2o7X67X333O3rZAYb/s0ctvBZ7tsu7rJtlql8nbatGnF2lZeffr0sbFgE0N8ucE6\njLHZ2dnWWmszMjKsy+WyCWAN2LgQr4lzOu39999/UjVMmDDBJiYmWgfY+ODr3cHHSW637du3r/X7\n/Sd1rREjRtiE+Hhbzu22MWCTExJsfHy8feSRR076GnJygrml0LknKktbnIiWtgjo1KkTPXv2pF+/\nfscdW7p0Kd26dWPTpk1asE9ETjm7du1i6tSpHDp0iAYNGtCtW7ew/6x7/fXXeXjwYHwh7tb0AdXq\n1mXDxo0AHDhwgOrVquHKzsYHZBKYY+YiMDTpJ7APZMXKldm4aROJiYkFtj98+HCeePxxsrKySAhe\nIzcLOBITmfrJJye9d+XBgweZOHEimzdvpnr16vTq1Stsw7xlWalcZ+xEFMZgy5YtnH/++WzZsoX4\n+PwntLZr145BgwZx9dVXR7g6EZHw2rVrF2++9n9Meu8djqSl0qRRY/rf9yBXX3112Da3PnLkCNWr\nV8eXlnZ0+YccFnC63Tw3YsTRfSP9fj+VK1cm6+BBHPwRvrzB1xggNiaGF0aO5O9//3uBbe/cuZN6\n9erhyczECfmuD0bw2h2uvJIZn39euDcpYVEq1xmTE9u2bRv16tULGcQAmjZtypYtW0IeFxEpjVau\nXMl5zRqzbfIIxjbYxDcX7uNmz7c8cXcfbrvphhPeKVhYycnJTJw4EYfbjc/hwPLHqvXOxETapqTQ\nv3//o+c7HA7uvvtuHHFxgV4rIA5IJLAZdzzgjImhb9++J2z77bffPrqPZN5fzDl1QCDgrfzllyK9\nTyl5FMZKqKpVq7Jp06YCN+Fdt24d1apVi2BVIiLh5fP5uLZrZ4Y3Psib52fS+jSolwR9zoTvU9LY\n8O3n/N+rr4St/S5duvDdd99x1bXX4o+PJ8vppG7Dhrw0ahSfffYZTuexfWaPPPIIZ5x1FiYu7uhk\n+aP7QSYkMHbsWJKTk0/Y7q+//kp28G7LnODlBTKA9FxfXiDpBMOdUvoojJVQ9erVo1GjRkyaNCnf\n47/++ivLly+nS5cuEa5MRCR8Zs+eTXnfYfrUO/5Ygguea5rOKy8OD+sSP+eeey4TJ00iIyMDr9fL\nmjVruOOOO44LYgBJSUl8v2gRAwYOJCY5GX9CAp6YGC5o04YZn3/OjTfeeFJtVqtWDYfTiYtA4PIQ\n2LIohkAvm5tAr5sP2LZ9O16vN+S1pPRRGCvBnn32We677z5mzJhxzA+eFStWcNVVV/HUU0/p1mQR\nOaV8u2A+V1U+EvL4RVVg37597NmzJ4JVFSwpKYnhw4ezb/9+1q9fz549e/j2u+9ISUk56Wvceuut\nOGJjcRIIXDmbeefcDGAILK2RABw5dIjBgwcX+/uQ6NEE/hLum2++4Z577sEYwznnnMPmzZvZsGED\n//73v7nzzjujXZ6ISLF6bOhQmPYMT56b/3G/hYpTYlm/ZTuVK4fYxLKYWGtZuHAhCxYswOFw0KFD\nB84///ywtXfdddcxZ+ZMMjIyMAR6wvLjJXAzQbj36JSTp7spy4CcHwgbN26kcuXKtG/fnpiYAjaK\nExEppebPn0//67uy6vJUTD6/2mZvhyE76rP0l7WY/E4oJuvXr6dbt25s2bwZX1YWxhhMTAxNmjTh\ns2nTqF69erG3mZ2dTb9+/ZgwYQJxEHKjb0tg/ph+T5YcCmMiInLKsNbS6txm9Ixdy0NNjt3QZ28m\npMx38/CLb9KnT5+w1XDw4EEaN2rE4b17MX7/0fW+LGBdLqrVrs2qVasKvNu9KE6rXJkj+/eHXN7C\nD2QaE7a7SuXP09IWIiJyyjDGMGXGbMbvr0Hnb5OYuAm+2QlP/+Lk3C8S6N53ADfffHNYaxgzZgzp\nR47gyBXEIDh3y+tl3549fPTRR2Fr/8abbqKg6fkeoHHjxmFrXyJPPWMiIlLiZGZm8tFHHzHpnXEc\nOXyYJmefS/9/3Md5550X9rYbNWrE5rVrj1v4NYcXaHHRRXz77bdhaT81NZUKFSrg8PmI4diV+HNW\n+v/yyy+PbvS9bds23njjDb7//nuSEhO5uU8funfvruksEaRhShERkWJUo3p1Du7cGXLoyAfUa9KE\nVatWha2GhQsX0u7SS/F5vTgJBDIfgSHK/4waxcCBAwEYPXo09917L05r8WRlYYGE5GQqVq7M/Pnz\nqV27dthqlD9omFJERKQYnVW/PgXNxrLG0LRp0xNex1pb6PXA2rRpQ3pGBv9+6ikaNG1K3fr1+eud\nd7Jv/37+8Y9/MH/+fHr16sU999wDmZnYrCxcBNYl8x45wq4tW2h/2WWaV1ZKqGdMREQkl08++YRb\n+/TBl5YWcrPuz2fOpG3btvm+funSpfxr2DBmzpqFz+ejVq1aDBo0iAEDBhR56HDXrl106tSJDb//\nTmpaGjHkv4+lBVxJSXw0aRKdO3cuUptyYhqmFBERKUZ+v58e3bvzzddf401Px0kg3PgBl9vNdddf\nz/jx4/NdWmPatGn07t0bX0YGzuDvsZzXXdCyJXO++KLQgczn89G8WTM2//471uslg8DK/KESgAfo\ne9ddjB49ulDtycnTMKWIiEgxcjgcTJk6lYeGDMFdqRImMRHjdlO+alWefPpp3nrrrXyDWGpqKjfe\neCP+9HRc1h6zcr4/PZ0flizh5ZdfLnRdM2fOZPv27eD1hgxgeWVmZBS6PYkc9YyJiIiE4PV62bhx\nIw6HgzPOOAOHI3Qfxptvvsk/Bw3CF2JlfB9QqXp1tm7bVqgFa2+44QY+mTjx6LBkBhALIe/6dCYl\n8eJLL2m3lggoas9YqAV+RUSkDEpNTcXj8VChQoWwrnBfWrhcLurXr39S5y5atIjM4Dyu/DiAXbt3\nk5GRgdvt/tO1HD58+JgeMRd/7GGZ9zvlCz53shuVS3RpmFJERPjss8+4tOV5nF65InVrVKPRGTUZ\n9Z+X8Pl8J36xAIENw08mwBZ2zljLli2Jiftjx8qcTcQzCax9ljOvze904nS7mTp1KomJiYVqSyJL\nYUxEpIwbOWI49/31Ru51L+dQTy+Hrsvm7SY7mDryUW68rrsC2Um6/vrriXW7CTXJxgu0a9eu0GGs\nf//+eI05uuxGzmbiMQQm66cDxMfTq08flvzwAx07dixUOxJ5mjMmIlKG/f7771x43tks65hBrTyd\nKFk+uHReIgOHvxn2LYhOBdZaWrRowZqVK8HjOWbo0A8Yt5vZs2dzySWXFLqN1157jX8OHnz0Ls+c\na7vcbi5u25bp06fjcmkGUqTpbkoRESm0Ma//H7ed4T0uiAHEOWFIgzTeeGlE5AvLx7Jly3j33XeZ\nMmUKR44ciXY5xzHGMGfOHBo2bYorKQmPMXgAh9sNCQmMHTu2SEEMYMCAAUyZOpW/tG5NltOJJyaG\nStWr868nn1QQK8XUMyYiUoZd1eFS7vQtoHuIXXP2ZkKj2W72Hc7/DsFIWLlyJXf26c3OLRu4+HQH\n+7INi3d7ueeev/OvZ54r8A7HaPD7/bz++utMnDgRr8dDl65dufvuu6lUqVKxtpORkYHH4yE5OVk3\nW0SZ7qYUEZFCSypXnn07Qx/fmwWJCfGRKyiP9evX0/HSi3mm8RH6drY4g7lraxrc9P7/cf/hQ4x6\n7c2o1ZfX8uXL6XX99ezYsSOwp6TDwbJly9i9ezcjR47E6Qy1EMWfl5CQQEJCQrFdT6KnZP1zQkRE\nIuq6m/syflsSoQYj3t4UQ88borc8wjPDHuNvdVK5/aw/ghhArUSY1iad9959hw0bNkStvsOHD/Pq\nq6/S5sILadK4Ma1atWLzunX409LwpqXhOXIEk5nJW2PHctddd0WtTinZNEwpIlKGeTweWjRvQs/E\nTTzW1Evu0a4ZW+Gvy5JYtGwF9erVO+G1VqxYwf/+9z8cDgft27enYcOGRarN6/VSsVwS67pkUTVE\nB9DAZbGc3msojz7+eJHaKoxffvmFdu3a4cnMJCstDS+BHo7YfM61gI2P5+eVKznrrLMiW6iEnSbw\ni4hIocXExDDrm/l8bhvT9Iskhq2A53+BlAVJ9P+lEp/N+uKEQWzr1q1c1qYlXdq14af/e5AlLz9A\n2wv+wtWd2rNv375C15aamoqxNmQQAzgrIZvdO7YVuo3Cys7OpkP79qTu24cvLQ0ngYVWQy1aYQDj\n8/Hf//73T7e1fft2fv75Z/bv31+EiqUkUxgTESnjatSowcIfVzB68udkXfEgey4dyIDh49iwbScX\nXnhhga89fPgw7S+5kMuzl7GxSzpvnp/BuBYZbO6WQf0d39L5srZkZ2cXqq7k5GScLiebC7h34Je0\neGqdceJeu6Lwer289dZbNG3ShIT4eCpVrEiXLl1IT009buJ1QV0jXo8nsLfkSfr2229p1bIlZ515\nJm0vvpgaNWrQrVs3fv/990K9Dym5NEwpIiKFNuo//+Hb14YysXX6ccesDfSwDRg+lhtuuKFQ1793\nwN9wzh/HyPO8xx3bmQFNZsWx6rcNVK9evVDXPxGPx8OVV17J4u+/JzvYA2YBnzFkW0s8HH0uHUgg\ndC+HiY/n8X//f3t3Hh9Vee9x/PObbCRhU/YlKJaoIG6ouFxQLBcFARGtrZQi7fW2CthapSouLfRy\nW1GsvbZXrFuvQquyKAiKyiIIgrIoWGURUEFBdgUSss7Mc/+YE5hAEiCZzEky3/frlRdnzjOZ85uH\nIflynnOe57+4++67j3ncOXPmMPC66wjl50duBCg5biBAesOGrFix4riXaZLqp2FKERHxzT+f+xu3\nnc/rZugAACAASURBVHJ0EAMwg1uzcvnns3+r9OuP+u1oXv32JMauSSK3+PD+Vd9Cr8UZjPzNvdUW\nxAAeffRRli1dSujgwUPLDwWAFOdIAwqJhCQjMj1BcTmvEyYyA//NN998zGOGQiGGDBlCOD//0DEp\nOUY4TMGBAwy77bYqvS+pWRTGRESk0vZ++x1ZFax53S4T9u7ZVenXb9WqFYuXfchHLb/PKW/U48ol\njTh3fgMGrGzC8N8+zAOjx1T6tY8lHA7z58ceI5ifX+bwY0lQKlksKtXbLoJDSyI5b18gI4MHHniA\nFi1aHPO48+fPp9A7I1aWQDjMe0uWsGNHBXOSSK2iecZERKTSTmt/Kqu/20V2w7LbV31ntO9Qtbsq\ns7KymD57Dtu2bWP9+vVkZmZy4YUXVvts83v27CEnN7fcUASRIcrotSLrEQljeUD9jAySkpJIT0/n\nv8aO5Re/+EWFxyssLGTJkiVMnz6dUHF559gix0lPS2PLli20bNnyRN6S1FAKYyIiUmn/+cu7eGzk\nLQzMOkjyEWMteUH4380ZPPXIHTE5Vps2bWjTpk2VX2fnzp0898zTrF62hHoZmVx74yAGDBhw1ALe\nKSkphEMhAlR8YT6BAKFwGCMSzNIzM7lp0CCGDBlC/fr1Oe+88ypcJcA5x0MPPcTD48YRMKO4uJj8\nggLKu4nUAUXFxTRu3PiE3rfUXLqAX0REKi0YDHLt1f9O2pblPNo5n+81iOxfsw9++a8M2l56DS+8\nNKXGLNfzj4kT+dWI2/hBO8f3Ty7gQDFM2t6Avckn89aCRbRr167U888++2w2fvppmWcuHGDp6QwY\nOJBFixZRVFjI+eefz9333EPPnj0rrCMcDrNy5Ur27t3Lyy+/zKvTphHKyyPAsW8GCALtsrP57LPP\naky/JrqqXsCvMCYiIlVSWFjI73/7AM88/RQtMwKEwo59wSR++eu7uOe++2O6BFBVLF26lBuu6cX8\n7nl0OuKk0qPrk3h+Xzs+Xr+xVL0zZszgJ4MHE/aCUgkHkJJCx3POYcWKFScUiqZMmcKdv/41uTk5\nmBn7c3IOTRZbcuQiIteapVE6kIWIBMCpU6fSt2/f4z6mVC+FMRERqREKCgpYt24dgUCATp06HTXs\n57cb+vWm1563uS277PaLFzbgt0++SL9+/Urtf+SRRxg9ejRJ4TDBoiIcUK9+fdq0bcvCd9+lefPm\nx13DxIkTGTZs2KFwVzJlRZBIAIueKqPY+wp4X2Fvf3JyMtcOGMCzzz6rocoaQmFMRETkGJxz1EtN\nYff1IRqWtV4R8Ph6WNt5CE/938Sj2r788ksmTJjAqlWrOKlxY4b+9Kf06dPnhM76FRYW0rxZM4py\ncsq8KaCYyJmvkmXZHVDg/ZkU9QVgqalktW/Pyg8/JDMz87hrkOqhecZERKRWC4VCTJo0iX/rcjaN\nMtNp3bQxt9/6n2zcuDFmx3DOEQyHyajgtrXMJCgqLCizrX379owfP5558+Yxddo0+vXrd8LDr7Nn\nz8ag3Lszk4mEsZK7M0vOhKUTGa4smUrDAFdUxLavv+bvf//7CdUgNZPCmIiI+CYUCvHjG67jifuG\ncU/DT9nct4DF3fZz0rIXuOzC81m8eHFMjhMIBOjS8XTmbi//OXO+zeTCyy6PyfHKsnXrVkIVLA1V\nMqFsybhQEEpN+nrkc4vz8vjrX/4S6zLFBwpjIiLimycnTGDHR+/w7uUHGZAFJ6XB9xrA2LODvHjR\nQW68rj+FhYUxOdbwkfcy5rNM8o9eWYlle2D+DseQ45ghv7JatmxJUmo5Y6REQliYqKWPqPiXtAE7\ndu6MZYniE4UxERHxhXOOJx57hLFn5pFWxthdr1ZwTqMQ06ZNi8nxhg4dyhnd+9D93UxmfA05xbD1\nIIxbG6D/0gwmvjSFhg3Lmb02Bvr27UswHD40DHmkIJAUCBBOTibf21fecyES2Jo2aRLTGsUfCmMi\nIuKL3Nxctnyzg+4V3IzY+6Rcli+J3VDl8y9O5s7xTzH+wNm0nJHCufMy2dDxh8x/74NqnyoiIyOD\nhx9+mEBGxqEllODw3ZTJ6en8bvRowmakEblOLMjhYcsjJaenM3zEiGqtWeJDM/CLiIgvkpOTCYUd\nxWFILeeq9ryQkVqvXtmNlRAIBBg8eDCDBw+O2WueiBEjRpCcnMyoUaMgHAbnCDlH8yZNeGHiRIqK\niqifkUHR/v04ImdMCokEs5JrxxwQTkqiRfPmx1xiSWoHnRkTERFfpKen061rF179uux25+ClHZn0\nvfa6+BZWzW699VZ27drF5KlTmfDUU8yZO5cvvvySyy+/nOTkZEqmdjIOh7A8ItNcFAD5QHanTixb\ntqxah1UlfjTPmIiI+Oatt97i1h/fwLtX5HFq/cP7nYOxa5N5PXQ6y1Z/mjDL/uTl5dG8eXPCBw8e\nNeN/yPuT1FS++eYbmuh6sRpD84yJiEit1bt3b+4Z8xAXzKvHHatTeeUreGYjdFvUgFfyTmHGm3MT\nJohB5LqyESNGkJSRUepasZL5yVLT0xk8eLCCWB2jM2MiIuK7r776imeenMCnq5aTWb8hNwweSv/+\n/UlOrrmXNm/fvp2nnnqK9957j/T0dAYNGsQNN9xAWlpalV43GAzy4x//mDdnzyaYn48Lh8GMlIwM\nLrn0UmbNmkW9GF5HJ1Wn5ZBERETibNKkSdx6660kOUdxQUFkpvz69anfsCHvLlrE9773vSq9vnOO\nFStW8MQTT/DF55/TNiuLYcOG0b1794Q6U1hbKIyJiIjE0QcffEDPnj1x3mLf0UKBAE1bt+aLL76o\ncQulS/XRNWMiIiJxNHbsWEL5+WX+Ak0Kh8nZv59Zs2bFvS6pvRTGRERETsC8efNIqmD0Jj8nhylT\npsSxIqntFMZEREROQCgUOuZzYrWepiQGhTEREZET0KlTJyqKY/UyMujRo0e8ypE6QGFMRETkBIwa\nNYqUzMwy14wMeV9Dhw6Nc1VSmymMiYiInIBBgwYx8PrrCWRmHlrIOwyEkpIIZGTw8uTJNG7c2Ocq\npTbR1BYiIlLjbNiwgZf++Q/27trJaaefyU+GDKFp06Z+l3WIc45XXnmFcePGsWbNGlJTUujXvz/3\n3XcfnTt39rs8iTPNMyYiInVGcXExt/7sZt6Y+Ro/OaWYrLQgqw6mM/Nrx9g/jOP2O+7wu0SRo1Q1\njNXcdSZERCTh3DniNnYseY0v++aTceg3VD6bz4SeY++nWYsW/Oimm/wsUSTmdGZMRERqhB07dtCx\nQ3u+7FtA49Sj2+dthzu3nMq/NnyhJYGkRtEM/CIiUie8/vrr9GkbKDOIAfRsCfv27mLjxo3xLUyk\nmimMiYhIjXDw4EGapJQ/g5cZNElP5uDBg3GsSqT6VTqMmdmNZrbGzEJm1uWItvvMbKOZrTezq6L2\nX2Bmn3htj1elcBERqVs6d+7M4r0plHeVyq4C2LK/iNNOOy2+hYlUs6qcGfsEGAgsit5pZp2AHwGd\ngN7ABDs8uP8kcItzLhvINrPeVTi+iIjUIVdeeSX5qY2YubXs9nHrU7h+4EAaNWoU38KOU3FxMR9/\n/DGrVq0iPz/f73KkFql0GHPOrXfObSijaQDwknOu2Dm3GdgEXGxmrYAGzrnl3vMmAtdV9vgiIlK3\nBAIBXnh5Gj9fncn4tca33vKOm3Lg1pWpzD7YknGP1bxBlVAoxNixY2nevDmXd+/OlT160Lx5c0aO\nHKk1KuW4VMc1Y62B6P/XbAXalLF/m7dfREQEgEsuuYSFS5fzr+8NJGtmCo1eSeXShfVp1GcYS1as\nolmzZn6XWIpzjkGDBvHIuHEU7ttHKCeH4IEDhHJzefrJJ7n66qsJBoN+lyk1XIXzjJnZXKBlGU33\nO+dmVU9JEWPGjDm03aNHDy26KiKSIDp16sSkKa/w9+JiDh48SIMGDUhKSvK7rDItWrSI2W+8QTAv\n79Di4Ubkl2s4P5+PVq5k2rRp3BQ1N1ooFOKDDz7gwIEDZGdn06FDBz9KlypYuHAhCxcujNnrVXme\nMTNbAIx0zn3kPR4F4Jwb5z1+CxgNbAEWOOc6evsHAVc4524r4zU1z5iIiNR41/bvz+uvvw5EApgR\nWacyCKR6j8/t2pVly5YB8PTTT/PA/fdTXFREIBCgoKiIc845h+eff54zzzzTnzchVVZT5hmLLmAm\ncJOZpZpZeyAbWO6c2wEcMLOLvQv6hwAzYnR8ERGRuFuwYAEBIJ1I+EoB0rzHxUQWEd+8eTMA48eP\n56477yR3716COTkU7d+P5eezevlyLrn4YjZt2uTPmxDfVWVqi4Fm9jVwCfCGmb0J4JxbC0wB1gJv\nAsOjTnMNB54FNgKbnHNvVaV4ERERv6xbt468/HzSKH1GAiK/XFOJBLKTTjqJffv2Mfp3vyOcl0f0\ngKsByc5RkJvLvffeG6fKpaap9NqUzrnpwPRy2v4I/LGM/R8CZ1f2mCIiIjXFrFmzSDU7KoiVSCJy\nZmzQoEFMmTKFlECA8qa0TQqHeeONN8jNzaV+/frVU7DUWFooXERE6qQ9e/Ywffp0vvvuOzp06EC/\nfv1ITS1nraVKKCgoIBwOU96tBQYEzBg4cCBTp04lPy+P8o5uQEpyMrt371YYS0BaDklEROqUcDjM\nqJF3kn1qFgv+9Gt2TXqAv971U05p1ZzXXnstZsc599xzSa8gOIWB9IwMzjzzTFq1akW9jIxyn+uI\nTBrbpEmTmNUntUeV76asDrqbUkREKmvUyDt5b8rTTL8kj2b1Du//YDdc9346L814gyuvvLLKxwkG\ng7Ru1YoDe/YcNczkAEtL47bbb+fRRx9lz549ZGVlYQUFZZ4FCZrx79dcc+jOTKldqno3pcKYiIjU\nGbt37+b09u3Y0KegVBArMXkzTCg8n3eXfxST4y1dupSrr7qKYEEBFgodmtoiOT2dDqefzntLlpCZ\nmQnA6NGjeezRRwnl5R0KZA4IASn167Ns2TI6deoUk7okvmrK1BYiIiK+mz59On3aBsoMYgDXt4M1\n69axbdu2mBzvsssuY8XKldxw002E09LIB05q2ZIHR49mydKlh4IYRCYz/+3o0SQ3aEBKw4akNGhA\nIDOT0zp2ZNGiRQpiCUxnxkREpM54+OGH2fOPBxl/XvlLEHWc24Bp89/nrLPOivnxw+EwgUDF5zkK\nCgpYsGAB+/fv54wzzuD888+PeR0SX1U9M6a7KUVEpM7o0KEDb+emAzlltu8thO05RbRpUz1LI+/c\nuZMZM2Zw4MABzjjjDPr27UtKSkqp59SrV48+ffpUy/GldtIwpYiI1Bn9+/dn3YEAy/aU3f74hiSu\n7dePxo0bx/S4wWCQn//855zWvj33jhzJ7x98kJ/efDMtW7Tg7bffPvS8b775hnvuuYeWLVpQPzOT\nszp14rnnnqO4uDim9UjtomFKERGpU2bMmMFtQ3/M4+fkc307SAlEzog9viGJ53ecxJIVH5GVlRXT\nY/7sZz9j2uTJhPPzS00CGwICGRnMnz+fBg0a0K1bN4rz8ggXFWFee2pmJueefz7z5s0jLS0tpnVJ\nfOhuShERkSO88847/H7Ub1izbh3NMlPYnlPEtf368YdH/xzzIPbVV19xxhlnECgoKBXEwkCh92cJ\nA+pReljKAYH0dG6/4w4eeuihmNYm8aEwJiIiUo5t27axb98+2rRpE/OhyRKPPfYYv7v/figsPLQv\nBBQQWRIphUj4ChNZqzJEJJBFz9wfBlIaNmT37t0xXSVA4kNTW4iIiJSjTZs2nHXWWdUWxAC+/fZb\niqKCGETOiCVzOHSZ92c9b3/hEa8RAFw4zJYtW6qtTqm5FMZERESqIDs7u9SySCEiQ4/lnd9K9dqj\nJ99wQCgUOurOS0kMGqYUERGpgoMHD9KieXNCeXkkcfg6sfQKviefyNmQksv1Q0Cztm3Z8tVXmFV6\ntEt8omFKERERH2VmZvLU008TSE8nSGRI8kROJzggOSOD340erSCWoBTGREREqmjw4MG8On06p599\nNoHUVByl76KMFva+DAgnJ+PS07lt+HBuueWWuNUrNYuGKUVERGJo27ZtXH311axfs4Y0KDXdhSNy\nl2X9hg0555xz6Ny5M7fffnu1LM0k8aOpLURERKqooKCAqVOnsnzJIlJS0+jTfwA9e/Y85jqT5Sks\nLOT07Gy+/vprkjk8tUUQaN2mDRs3biQ9vaKryqQ2URgTERGpgsWLF/PDgddybsMgfZrkkh+Cl3fU\nxxq3Yubb8ys9SaxzjhdffJH/HjuW3bt307RpUx548EF+8pOf6NqwOkZhTEREpJI+//xzLr3gPP5x\nQS5XtT683zkYvz6J579ry+p1GzQRq1RId1OKiIhU0l/+NJ7/PKWgVBADMIN7OoZoEfqW6dOn+1Oc\nJAyFMRERSVjTX5nK0FOC5bbf3DqHV1+cGMeKJBEpjImISMI6mF/AyWnltzdJhbzcnPgVJAlJYUxE\nRBLW2R3PZNGu8tvf/TaVzl26xq8gSUgKYyIikrCG3XUPf9yYSUHo6LYtufDCl0n8YviI+BcmCUVh\nTEREEtaNN95Ix25X03NxJu/siNxFWRiCF7+EKxZlMHrsH2jfvr3fZUodp6ktREQkoYXDYZ55+mn+\n90/j2LhlK2HnuOLiixj54Bh69+591POdcyxevJjJkyeTm5tL165dGTJkCA0bNvSheqkJNM+YiIhI\nDDjnyM/PJzk5udx5xfbs2cNVV13Fpg0bKMzLA+eol5lJ0DkmTZrE9ddfH+eqpSZQGBMREYkD5xxd\nunRhw5o1UFxcas3JEBBIT2fBwoV07aoL/hONJn0VERGJg0WLFvH5pk1HBTGAJCCYn8+YMWN8qExq\nO4UxERGR4zB58mQKDx48KoiVSAbmzJlDOByOZ1lSByiMiYiIHIfcnJzI7ZYVcM4RDJY/o79IWRTG\nREREjsNFXbtSLyOj3PYw0LpVKy0qLidMYUxEROQ43HzzzQSJXKx/JAekZGQw8je/iXNVUhcojImI\niByHRo0a8fzzzxPIyCBIJIA5vDspMzLoctFFjBih2frlxCmMiYiIHKcbb7yR+fPn0+OqqyhMSqIg\nEKBJ69b8fuxY5s6dS0pKit8lSi2kecZEREQqIRQKEQwGSUtL87sU8ZkmfRURERHxkSZ9FREREanF\nFMZEREREfKQwJiIiIuIjhTERERERHymMiYiIiPhIYUxERETERwpjIiIiIj5SGBMRERHxkcKYiIiI\niI8UxkRERER8pDAmIiIi4iOFMREREREfKYyJiEjC2rRpE3ffeQfdupzNFRedxx//eyy7du3yuyxJ\nMOac87uGo5iZq4l1iYhI3THphRe485fD+I9Tg/RtWUxRGKZsT+e1b5J4ZeZsunfv7neJUkuYGc45\nq/T318TQozAmIiLVadWqVfTu8W8svCKfjo1Kt83dDoM/bMD6zzdz8skn+1Og1CpVDWMaphQRkYTz\n1z89wp0dCo8KYgC9WsHVLYL833PPxb8wSUgKYyIiknDmz5vLD7LC5bb/oGU+89+YEceKJJEpjImI\nSMJxzpFUwaBSkkE4XH5YE4klhTEREUk43bp147Wt5aex13bWo3uvPnGsSBKZLuAXEZGE8/777/OD\nPj15//v5tMss3bZsD1yzJIO1G7+gRYsW/hQotYou4BcRETlBl156KaPG/IFL3sng4bUB1uyDj/bC\nqH+l0G9pBhNfmqIgJnGjM2MiIpKwVq5cyRN/Hs/7771HUlKA3v2vY9gv76BDhw5+lya1iOYZExER\nEfGRhilFREREajGFMREREREfKYyJiIiI+EhhTERERMRHlQ5jZjbezNaZ2cdm9qqZNYpqu8/MNprZ\nejO7Kmr/BWb2idf2eFWLFxEREantqnJmbA5wlnPuXGADcB+AmXUCfgR0AnoDE8ys5A6DJ4FbnHPZ\nQLaZ9a7C8UVERERqvUqHMefcXOdcycJdy4C23vYA4CXnXLFzbjOwCbjYzFoBDZxzy73nTQSuq+zx\nRUREROqCWF0z9h/AbG+7NbA1qm0r0KaM/du8/SIiIiIJK7miRjObC7Qso+l+59ws7zkPAEXOuRdj\nWdiYMWMObffo0YMePXrE8uVFREREKmXhwoUsXLgwZq9XpRn4zeynwM+Bns65Am/fKADn3Djv8VvA\naGALsMA519HbPwi4wjl3Wxmvqxn4RUREpFbwbQZ+7+L7u4EBJUHMMxO4ycxSzaw9kA0sd87tAA6Y\n2cXeBf1DgBmVPb6IiIhIXVDhMOUx/BVIBeZ6N0u+75wb7pxba2ZTgLVAEBgedZprOPA8kA7Mds69\nVYXji4iIiNR6WihcREREpAq0ULiIiIhILaYwJiIiIuIjhTERERERHymMiYiIiPhIYUxERETERwpj\nIiIiIj5SGBMRERHxkcKYiIiIiI8UxkRERER8pDAmIiIi4iOFMREREREfKYyJiIiI+EhhTERERMRH\nCmMiIiIiPlIYExEREfGRwpiIiIiIjxTGRERERHykMCYiIiLiI4UxERERER8pjImIiIj4SGFMRERE\nxEcKYyIiIiI+UhgTERER8ZHCmIiIiIiPFMZEREREfKQwJiIiIuIjhTERERERHymMiYiIiPhIYUxE\nRETERwpjIiIiIj5SGBMRERHxkcKYiIiIiI8UxkRERER8pDAmIiIi4iOFMREREREfKYyJiIiI+Ehh\nTERERMRHCmMiIiIiPlIYExEREfGRwpiIiIiIjxTGRERERHykMCYiIiLiI4UxERERER8l+12AiMiJ\n2LZtG8/87Unem/82gUCAXv2v52e33ELTpk39Lk1EpFLMOed3DUcxM1cT6xIRf82YPp1bhg7mpnZh\n+rcoJBiGaTvSmb0jiVdmzqZ79+5+lygiCcjMcM5Zpb+/JoYehTEROdJnn31Gt4u68Fa3PC5oUrpt\n7nYY/GF91mz4gmbNmvlToIgkrKqGMV0zJiK1whP/8xi3nVZ0VBAD6NUK+rYM8fdnn4l/YSIiVaQw\nJiK1wpw3X+fGtsFy23/YKp85M1+NY0UiIrGhMCYitUIoFCK1gp9YqQEIhcoPayIiNZXCmIjUCpd1\n687r35T/I+v1nalc1qNXHCsSEYkNXcAvIrXCihUrGNCrBx98P492maXbPvkOrlyUzoefrOOUU07x\np0ARSVi6gF9EEsJFF13EqNFjuXRBBo+tNzblwPr9MHZNEj0Xp/PEU88piIlIraQzYyJSqyxbtoz/\n/dMjLF68iKRAgF5X9+b2u+6mc+fOfpcmIglK84yJiIiI+EjDlCIiIiK1mMKYiIiIiI8UxkRERER8\npDAmIiIi4iOFMREREREfKYyJiIiI+EhhTERERMRHCmMiIiIiPlIYExEREfGRwpiIiIiIjxTGRERE\nRHykMCYiIiLio0qHMTMba2Yfm9lqM5tvZllRbfeZ2UYzW29mV0Xtv8DMPvHaHq9q8Ylm4cKFfpdQ\n46hPyqZ+KZv6pWzql6OpT8qmfqkeVTkz9ohz7lzn3HnADGA0gJl1An4EdAJ6AxPMrGQl8yeBW5xz\n2UC2mfWuwvETjv4RHE19Ujb1S9nUL2VTvxxNfVI29Uv1qHQYc87lRD2sD+zxtgcALznnip1zm4FN\nwMVm1gpo4Jxb7j1vInBdZY8vIiIiUhckV+WbzewPwBAgH+jq7W4NfBD1tK1AG6DY2y6xzdsvIiIi\nkrDMOVd+o9lcoGUZTfc752ZFPW8UcIZz7mdm9lfgA+fcP722Z4E3gc3AOOdcL29/d+Ae51z/Mo5b\nflEiIiIiNYxzzo79rLJVeGasJDgdhxeB2d72NiArqq0tkTNi27zt6P3byjlupd+QiIiISG1Slbsp\ns6MeDgBWedszgZvMLNXM2gPZwHLn3A7ggJld7F3QP4TIhf8iIiIiCasq14w9ZGZnACHgc2AYgHNu\nrZlNAdYCQWC4OzwWOhx4HkgHZjvn3qrC8UVERERqvQqvGRMRERGR6hX3GfjN7EYzW2NmITO7IGp/\nLzNbaWb/8v68MqqtzMlizSzNzCZ7+z8ws1Pi/X5i5Yh+6XJE2wlNoluX+iWamXU1s+VmtsrMVpjZ\nRVFtCTvRsJn90szWmdmnZvZw1P6E7ZMSZjbSzMJmdnLUvoTtFzMb731WPjazV82sUVRbwvbLkcys\nt9cPG83sXr/riRczyzKzBd7vok/N7Ffe/pPNbK6ZbTCzOWbWOOp7yvzc1EVmluT9/pnlPY5dvzjn\n4voFnAmcDiwAukTtPw9o6W2fBWyNalsOdPW2ZwO9ve3hwARv+0fAy/F+P3Hol07AaiAFOJXIvG0l\nZzTrfL8c0UcLgau97T7Agsr2UV35Aq4E5gIp3uNmid4nUX2TBbwFfAmcrH5xAL2AgLc9jsgd7gnf\nL0f0UZL3/k/1+mM10NHvuuL03lsC53nb9YHPgI7AI0RmPwC49xifm4Df76Ma++cu4J/ATO9xzPol\n7mfGnHPrnXMbyti/2kUu8ofI9WbpZpZiFU8Wey3wgrf9CtCzGkuvVuX1C5WbRLfO9MsRtgMl/5Nv\nzOG7cRN5ouFhwEPOuWIA59xub38i90mJx4B7jtiX0P3inJvrnAt7D5dx+A73hO6XI3QFNjnnNnv/\nrl4m0j91nnNuh3NutbedC6wjMh9o9O+UFzj8GSjrc9OVOsjM2gLXAM8CJTM+xKxfaupC4TcAH3r/\nENpQ/mSxbYCvAZxzQWB/9HBEHdGa0u+/ZBLdI/cnQr+MAv5kZl8B44H7vP2V6aO6Ihu43BuOXmhm\nF3r7E7lPMLMBRM6u/+uIpoTulyP8B4enJFK/HHbo56enpC8SipmdCpxPJLS3cM7t9Jp2Ai287fI+\nN3XRn4G7gXDUvpj1S5Vm4C+PHedkseV871lETp8f7xxntUZV+iVRVNBHDwC/An7lnJtuZjcCf6cO\nfk6OdIw+SQZOcs5d4l1DNwU4LZ71+eUY/XIfEH2dRsLMXXg8P2fM7AGgyDn3YlyLqx0S/q42kp/p\npgAAAnxJREFUM6tPZFTlDudcjtnhfz7OOWcVT8xe5/rPzPoBu5xzq8ysR1nPqWq/VEsYc8c/WWwp\n3mnAV4Ehzrkvvd1lTRa7NaqtHfCNmSUDjZxz31au6upXyX45kUl0a2W/RKuoj8zsH865f/ceTiNy\nuhhiMNFwTXaMPhlG5N8MzrkV3sXqTanjfQLl94uZdQbaAx97v0TaAh+a2cUkcL+UMLOfEhluib58\noc73ywk4si+yKH2Wo04zsxQiQWySc65kLtCdZtbSObfDG7re5e0v63NTFz8flwHXmtk1QD2goZlN\nIob94vcw5aG47d2F8AZwr3Pu/ZL9zrntHD1Z7Gte80xgqLf9A2B+XKquftH/iz+RSXTrer9sMrMr\nvO3vAyXX2CXyRMMziPQFZnY6kOqc20MC94lz7lPnXAvnXHvnXHsiv0i7eMMJCdsvELlLkMhQywDn\nXEFUU0L3yxFWAtlmdqqZpRK5CWqmzzXFhfd3/Byw1jn3P1FN0b9ThnL4M1Dm5yZe9caLc+5+51yW\n9/PkJuAd59wQYtkvPtyNMJDIeHw+sAN409v/IJBLZCb/kq+mXtsFwCdELoL7S9RrpREZltlIZHHy\nU+P9fqq7X7y2+733vh7vbsJE6Zcj+uhCItcvrAbeB86vbB/VlS8id+tM8t7jh0CPRO+TMvroC7y7\nKRO9X7yfCVuifsZOUL+U2U99iNxJuAm4z+964vi+uxG5Jmp11GekN3AyMI/If4DnAI2P9bmpq1/A\nFRy+mzJm/aJJX0VERER85PcwpYiIiEhCUxgTERER8ZHCmIiIiIiPFMZEREREfKQwJiIiIuIjhTER\nERERHymMiYiIiPjo/wF4OZMLaWbBrgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(reduced_data_2[:, 0], reduced_data_2[:, 1], c=pred_2, s=75, cmap= 'hot')\n", + "plt.title('Serving size by cups')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a lot less variance here. Let's see what we can explain." + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_3 = data_1.drop('shelf',1)" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "data_3['normweight'] = data_3.weight.apply(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_3p1 = data_3.multiply(data_3.normweight, axis =0)" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_3p2 = data_3p1.drop(['weight', 'normweight'], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pca_3 = PCA()\n", + "pca_3.fit(data_3p2)\n", + "reduced_data_3 = pca_3.transform(data_3p2)" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "kmeans_3 = KMeans(7)\n", + "pred_3 = kmeans_3.fit_predict(reduced_data_3)" + ] + }, + { + "cell_type": "code", + "execution_count": 392, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 392, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHpCAYAAAAhyVBgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCCEM8v/d9TzrvjpnjwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(reduced_data_3[:, 0], reduced_data_3[:, 1], c=pred_3, s=75, cmap= 'hot')\n", + "plt.title('Serving size by weight')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Because there is a bit more variance on weight, I will proceed with data normalized on cup size." + ] + }, + { + "cell_type": "code", + "execution_count": 370, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "index_2 = data_2.index\n", + "predilections_2 = list(pred_2)\n", + "zip_1 = list(zip(index_2, predilections_2))" + ] + }, + { + "cell_type": "code", + "execution_count": 371, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "new_data_2 = pd.DataFrame(zip_1, columns=['name', 'cluster'])" + ] + }, + { + "cell_type": "code", + "execution_count": 372, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "new_data_2.set_index('name', inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 373, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_2p3 = data_2.drop(['cups', 'normcup'], axis =1)" + ] + }, + { + "cell_type": "code", + "execution_count": 374, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "new_data_2 = data_2p2.join(new_data_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###This function generates plots comparing the nutrient means between clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 376, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def nutrient(name, group):\n", + " elle = []\n", + " c = random.choice(['k', 'm', 'c', 'b', 'r'])\n", + " n = random.random()\n", + " for i,e in group:\n", + " #e.drop('cluster', inplace =True, axis=1)\n", + " elle.append(e[name].mean())\n", + " return (plt.bar(range(len(elle)), elle, alpha=n, color=c), \n", + " plt.title(name.title()), plt.xlabel('Clusters'), plt.ylabel('Amount'))" + ] + }, + { + "cell_type": "code", + "execution_count": 398, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "group_2 = list(new_data_2.groupby('cluster'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###Categories by cluster:\n", + " 1: Generally Unhealthy\n", + " 2: Generally more Healthy\n", + " 3: Hippy Crap (The major outliers on the 'cup' graph above)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 395, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "plt.rcParams['figure.figsize'] = 8, 6" + ] + }, + { + "cell_type": "code", + "execution_count": 396, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " ,\n", + " ,\n", + " )" + ] + }, + "execution_count": 396, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAGJCAYAAABxdLHSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA8DA/j/lbo3W+ZmCLgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nutrient('fiber', group_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 397, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " ,\n", + " ,\n", + " )" + ] + }, + "execution_count": 397, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAGJCAYAAABxdLHSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nyCVJatj/B3mRUA8R5hhmAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nutrient('sugars', group_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 402, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " ,\n", + " ,\n", + " )" + ] + }, + "execution_count": 402, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfgAAAGJCAYAAABmViEbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nutrient('sodium', group_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 403, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " ,\n", + " ,\n", + " )" + ] + }, + "execution_count": 403, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfEAAAGJCAYAAACaQwrRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nutrient('protein', group_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#####It seems my hypothesis has both some Truthiness and so Falsiness to it. In truth, the primary clusters have fewer good ingredients, but, in a fog of deception, the latter clusters also have more bad ingredients. I blame this confusion of the sample size, if there were more hippy cereals, then I believe the amount of bad ingredients in the last cluster would go down." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}