diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e818050..03d81c1 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -43,12 +43,12 @@ repos: # hooks: # - id: isort # name: "[py - format] isort" - - repo: https://github.com/PyCQA/docformatter - rev: v1.4 - hooks: - - id: docformatter - name: "[py - format] docformatter" - args: [ -i, --wrap-summaries, "0" ] +# - repo: https://github.com/PyCQA/docformatter +# rev: v1.4 +# hooks: +# - id: docformatter +# name: "[py - format] docformatter" +# args: [ -i, --wrap-summaries, "0" ] - repo: https://github.com/PyCQA/pydocstyle rev: 6.1.1 @@ -57,12 +57,12 @@ repos: name: "[py - check] pydocstyle" files: ^Hapi/ - - repo: https://gitlab.com/pycqa/flake8 - rev: 4.0.1 + - repo: https://github.com/PyCQA/flake8 + rev: 6.0.0 hooks: - id: flake8 name: "[py - check] flake8" - language_version: python3.9 +# language_version: python3.9 exclude: ^(examples/|tests/) #- repo: https://github.com/psf/black @@ -74,7 +74,7 @@ repos: hooks: - id: black name: "[py - format] black" - language_version: python3.9 +# language_version: python3.9 - repo: https://github.com/lovesegfault/beautysh rev: v6.2.1 hooks: @@ -108,7 +108,7 @@ repos: hooks: - id: pytest-check name: pytest-check - entry: pytest -vvv --cov=Hapi + entry: pytest -vvv --cov=statista language: system pass_filenames: false always_run: true diff --git a/HISTORY.rst b/HISTORY.rst index 1fbc66c..22b0e90 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -24,3 +24,13 @@ History * add eva (Extreme value analysis) module * fix bug in obtaining distribution parameters using optimization method + + +0.3.0 (2023-02-19) +------------------ + +* add documentations for both GEV and gumbel distributions. +* add lmoment parameter estimation method for all distributions. +* add exponential and normal distributions +* modify the pdf, cdf, and probability plot plots +* create separate plot and confidence_interval modules. diff --git a/README.md b/README.md index 8df2f9f..f251a31 100644 --- a/README.md +++ b/README.md @@ -26,15 +26,19 @@ statista Main Features ------------- - - Statistical Distributions (GEV/GUMBL) - - Parameter estimation Lmoments/ML/MOM + - Statistical Distributions + - GEV + - GUMBL + - Normal + - Exponential + - Parameter estimation methods + - Lmoments + - ML + - MOM - One-at-time (O-A-T) Sensitivity analysis. - Sobol visualization - - Statistical Metrics - -Future work -------------- - - More distributions + - Statistical descriptors + - Extreme value analysis Installing statista @@ -61,7 +65,7 @@ pip install git+https://github.com/MAfarrag/statista ## pip to install the last release you can easly use pip ``` -pip install statista==0.2.0 +pip install statista==0.3.0 ``` Quick start diff --git a/docs/conf.py b/docs/conf.py index 6bfcb71..2afda7d 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -8,18 +8,18 @@ # # All configuration values have a default; values that are commented out # serve to show the default. + import os import sys # import sphinx_rtd_theme # General information about the project. -project = "pyramids" +project = "statista" author = "Mostafa Farrag" # copyright = u"2013-2019, " - html_theme = "sphinxdoc" # html_theme = "agogo" html_theme_path = ["."] @@ -28,7 +28,7 @@ # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. -sys.path.insert(0, os.path.abspath("../pyramids")) +sys.path.insert(0, os.path.abspath("../statista")) sys.path.insert(0, os.path.abspath("..")) sys.path.insert(0, os.path.abspath("../examples")) @@ -37,7 +37,7 @@ # os.path.abspath to make it absolute, like shown here. sys.path.append(os.path.abspath("sphinxext")) -# import pyramids +# import statista # -- General configuration ----------------------------------------------------- @@ -48,13 +48,19 @@ # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = [ - "matplotlib.sphinxext.plot_directive", - "sphinx.ext.todo", - "sphinx.ext.mathjax", "sphinx.ext.autodoc", - "sphinx.ext.graphviz", - "sphinx.ext.doctest", - "sphinx.ext.autosectionlabel", + "sphinx.ext.coverage", + "sphinx.ext.viewcode", + "sphinx.ext.imgmath", + "easydev.copybutton", + # "matplotlib.sphinxext.plot_directive", + # "sphinx.ext.todo", + # "sphinx.ext.mathjax", + # "sphinx.ext.graphviz", + # "sphinx.ext.doctest", + # "sphinx.ext.autosectionlabel", + "numpydoc", + "nbsphinx", ] autosectionlabel_prefix_document = True @@ -117,7 +123,9 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -html_theme = "sphinx_rtd_theme" +# html_theme = "sphinx_rtd_theme" +html_theme = "pydata_sphinx_theme" + # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -137,7 +145,7 @@ # The name of an image file (relative to this directory) to place at the top # of the sidebar. """ -html_logo = "images/pyramids.png" +html_logo = "images/statista.png" """ # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 @@ -164,7 +172,13 @@ # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. -# html_sidebars = {} +html_sidebars = { + "**": [ + "globaltoc.html", + "relations.html", # needs 'show_related': True theme option to display + "searchbox.html", + ] +} # Additional templates that should be rendered to pages, maps page names to # template names. @@ -197,16 +211,20 @@ html_file_suffix = ".html" # Output file base name for HTML help builder. -htmlhelp_basename = "pyramidsdoc" +htmlhelp_basename = "statistadoc" # -- Options for LaTeX output -------------------------------------------------- - - # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ - ("index", "pyramids.tex", "pyramids Documentation", "Mostafa Farrag", "report") + ( + "index", + "statista.tex", + "statista Documentation", + "Mostafa Farrag", + "report", + ) ] # The name of an image file (relative to this directory) to place at the top of @@ -234,7 +252,7 @@ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [("index", "pyramids", "pyramids Documentation", [author], 1)] +man_pages = [("index", "statista", "statista Documentation", [author], 1)] # If true, show URL addresses after external links. # man_show_urls = False @@ -248,10 +266,9 @@ texinfo_documents = [ ( "index", - "pyramids", - "pyramids Documentation", + "statista", + "statista Documentation", "Mostafa Farrag", - "pyramids", "One line description of project.", "Miscellaneous", ) @@ -277,5 +294,5 @@ # "netCDF4_utils", # "netcdftime", # "pyproj", - # "pyramids.version", + # "statista.version", ] diff --git a/docs/distributions.rst b/docs/distributions.rst new file mode 100644 index 0000000..f820f14 --- /dev/null +++ b/docs/distributions.rst @@ -0,0 +1,56 @@ +############# +Distributions +############# + +******************************************** +Generalized extreme value distribution (GEV) +******************************************** + +- The generalised extreme value (or generalized extreme value) distribution characterises the behaviour of ‘block + maxima’ + +probability density function (pdf) +================================== + +.. math:: + f(x) = \frac{1}{\sigma}\ast{Q(x)}^{\xi+1}\ast e^{-Q(x)} + + +.. math:: + Q(x) = + \begin{cases} + {(1+\xi(\frac{x-\mu}{\delta}))}^\frac{-1}{\xi} & \quad \text{if } \xi \text{ \neq 0}\\ + e^{-(\frac{x-\mu}{\delta})} & \quad \text{if } \xi \text{ = 0} + \end{cases} + +- where + - :math: `\sigma` is the scale parameter + - :math: `\mu` is the location parameter + - :math: `\delta` is the scale parameter + + +Cumulative distribution function (cdf) +====================================== + +.. math:: + F(x)=e^{-Q(x)} + +******************* +Gumbel Distribution +******************* + +- The Gumbel distribution is a special case of the `Generalized extreme value distribution (GEV)`_ when the shape + parameter :math: `\sigma` equals zero. + +probability density function (pdf) +================================== + +.. math:: + f(x) = \frac{1}{\sigma} \ast { {e}^{-(\frac{x-\mu}{\delta}) - {e}^{- (\frac{x-\mu}{\delta})} }} + + +Cumulative distribution function (cdf) +====================================== + +.. math:: + F(x) = {e}^{- {e}^{- (\frac{x-\mu}{\delta})} } diff --git a/docs/environment.yml b/docs/environment.yml index c90376d..0098310 100644 --- a/docs/environment.yml +++ b/docs/environment.yml @@ -1,10 +1,13 @@ channels: - conda-forge dependencies: - - python >=3.9.0 - - pip >=21.3.1 - - matplotlib >=3.4.2,<3.6.0 -# - pandas >=1.3.2,<1.4.3 -# - pip: -# - geoplot >=0.5.1 -# - loguru >=0.5.3 + - python >=3.9,<3.11 + - pip >=22.3.1 + - pandas + - numpy==1.20.* + - numpydoc==1.1.0 + - typing-extensions==3.10.* + - pip: + - pydata-sphinx-theme + - nbsphinx + - easydev diff --git a/docs/images/sensitivityAnalysis1.png b/docs/images/sensitivityAnalysis1.png new file mode 100644 index 0000000..797e400 Binary files /dev/null and b/docs/images/sensitivityAnalysis1.png differ diff --git a/docs/images/sensitivityAnalysis2.png b/docs/images/sensitivityAnalysis2.png new file mode 100644 index 0000000..6c3a5b4 Binary files /dev/null and b/docs/images/sensitivityAnalysis2.png differ diff --git a/docs/images/sensitivityAnalysis3.png b/docs/images/sensitivityAnalysis3.png new file mode 100644 index 0000000..a4d07d5 Binary files /dev/null and b/docs/images/sensitivityAnalysis3.png differ diff --git a/docs/index.rst b/docs/index.rst index c9634dc..b9d3960 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -6,7 +6,7 @@ Current release info :target: https://pypi.org/project/statista/0.1.2/ -.. image:: https://img.shields.io/conda/v/conda-forge/hapi?label=conda-forge +.. image:: https://img.shields.io/conda/v/conda-forge/statista?label=conda-forge :target: https://pypi.org/project/statista/0.1.2/ @@ -14,14 +14,14 @@ Current release info :target: https://pypi.org/project/statista/0.1.2/ -.. image:: https://img.shields.io/github/forks/mafarrag/hapi?style=social :alt: GitHub forks +.. image:: https://img.shields.io/github/forks/mafarrag/statista?style=social :alt: GitHub forks -.. image:: https://anaconda.org/conda-forge/hapi/badges/downloads.svg - :target: https://anaconda.org/conda-forge/hapi +.. image:: https://anaconda.org/conda-forge/statista/badges/downloads.svg + :target: https://anaconda.org/conda-forge/statista -.. image:: https://img.shields.io/conda/vn/conda-forge/hapi :alt: Conda (channel only) +.. image:: https://img.shields.io/conda/vn/conda-forge/statista :alt: Conda (channel only) :target: https://pypi.org/project/statista/0.1.2/ @@ -37,8 +37,8 @@ Current release info :alt: PyPI -.. image:: https://anaconda.org/conda-forge/hapi/badges/platforms.svg - :target: https://anaconda.org/conda-forge/hapi +.. image:: https://anaconda.org/conda-forge/statista/badges/platforms.svg + :target: https://anaconda.org/conda-forge/statista .. image:: https://static.pepy.tech/personalized-badge/statista?period=total&units=international_system&left_color=grey&right_color=blue&left_text=Downloads @@ -81,6 +81,6 @@ Main Features :hidden: :maxdepth: 1 - Installation <00Installation.rst> - Tutorial <03tutorial.rst> - GIS <05GIS.rst> + Installation + Distributions + Sensitivity analysis diff --git a/docs/installation.rst b/docs/installation.rst new file mode 100644 index 0000000..99efcf0 --- /dev/null +++ b/docs/installation.rst @@ -0,0 +1,164 @@ +.. highlight:: shell + +============ +Installation +============ + + + +Stable release +-------------- + +Please install ``statista`` in a Virtual environment so that its requirements don't tamper with your system's python. + +conda +----- +the easiest way to install ``statista`` is using ``conda`` package manager. ``statista`` is available in the +`conda-forge `_ channel. To install +you can use the following command: + ++ ``conda install -c conda-forge statista`` + +If this works it will install Hapi with all dependencies including Python and gdal, +and you skip the rest of the installation instructions. + + +Installing Python and gdal dependencies +--------------------------------------- + +The main dependencies for statista are an installation of Python 3.9+, and gdal + +Installing Python +----------------- + +For Python we recommend using the Anaconda Distribution for Python 3, which is available +for download from https://www.anaconda.com/download/. The installer gives the option to +add ``python`` to your ``PATH`` environment variable. We will assume in the instructions +below that it is available in the path, such that ``python``, ``pip``, and ``conda`` are +all available from the command line. + +Note that there is no hard requirement specifically for Anaconda's Python, but often it +makes installation of required dependencies easier using the conda package manager. + +Install as a conda environment +------------------------------ + +The easiest and most robust way to install Hapi is by installing it in a separate +conda environment. In the root repository directory there is an ``environment.yml`` file. +This file lists all dependencies. Either use the ``environment.yml`` file from the master branch +(please note that the master branch can change rapidly and break functionality without warning), +or from one of the releases {release}. + +Run this command to start installing all Hapi dependencies: + ++ ``conda env create -f environment.yml`` + +This creates a new environment with the name ``statista``. To activate this environment in +a session, run: + ++ ``conda activate statista`` + +For the installation of Hapi there are two options (from the Python Package Index (PyPI) +or from Github). To install a release of Hapi from the PyPI (available from release 2018.1): + ++ ``pip install statista=={release}`` + + +From sources +------------ + + +The sources for HapiSM can be downloaded from the `Github repo`_. + +You can either clone the public repository: + +.. code-block:: console + + $ git clone git://github.com/MAfarrag/statista + +Or download the `tarball`_: + +.. code-block:: console + + $ curl -OJL https://github.com/MAfarrag/statista/tarball/main + +Once you have a copy of the source, you can install it with: + +.. code-block:: console + + $ python setup.py install + + +.. _Github repo: https://github.com/MAfarrag/statista +.. _tarball: https://github.com/MAfarrag/statista/tarball/master + + +To install directly from GitHub (from the HEAD of the master branch): + ++ ``pip install git+https://github.com/MAfarrag/statista.git`` + +or from Github from a specific release: + ++ ``pip install git+https://github.com/MAfarrag/statista.git@{release}`` + +Now you should be able to start this environment's Python with ``python``, try +``import statista`` to see if the package is installed. + + +More details on how to work with conda environments can be found here: +https://conda.io/docs/user-guide/tasks/manage-environments.html + + +If you are planning to make changes and contribute to the development of Hapi, it is +best to make a git clone of the repository, and do a editable install in the location +of you clone. This will not move a copy to your Python installation directory, but +instead create a link in your Python installation pointing to the folder you installed +it from, such that any changes you make there are directly reflected in your install. + ++ ``git clone https://github.com/MAfarrag/statista.git`` ++ ``cd statista`` ++ ``activate statista`` ++ ``pip install -e .`` + +Alternatively, if you want to avoid using ``git`` and simply want to test the latest +version from the ``master`` branch, you can replace the first line with downloading +a zip archive from GitHub: https://github.com/MAfarrag/statista/archive/master.zip +`libraries.io `_. + +Install using pip +----------------- + +Besides the recommended conda environment setup described above, you can also install +Hapi with ``pip``. For the more difficult to install Python dependencies, it is best to +use the conda package manager: + ++ ``conda install numpy scipy gdal netcdf4 pyproj`` + + +you can check `libraries.io `_. to check versions of the libraries + + +Then install a release {release} of statista (available from release 2018.1) with pip: + ++ ``pip install statista=={release}`` + + +Check if the installation is successful +--------------------------------------- + +To check it the install is successful, go to the examples directory and run the following command: + ++ ``python -m statista.*******`` + +This should run without errors. + + +.. note:: + + This documentation was generated on |today| + + Documentation for the development version: + https://statista.readthedocs.org/en/latest/ + + Documentation for the stable version: + https://statista.readthedocs.org/en/stable/ diff --git a/docs/Sensitivity_Analysis.rst b/docs/sensitivity_analysis.rst similarity index 97% rename from docs/Sensitivity_Analysis.rst rename to docs/sensitivity_analysis.rst index 7a0ed67..1e90326 100644 --- a/docs/Sensitivity_Analysis.rst +++ b/docs/sensitivity_analysis.rst @@ -25,6 +25,7 @@ Steps: * Run the OAT method :ref:`4` * Display the result with the SOBOL plot :ref:`5` + .. _1: Run the model @@ -184,11 +185,12 @@ Display the result with the SOBOL plot - Type 1 with one parameter -.. image:: /img/sensitivityAnalysis1.png +.. image:: images/sensitivityAnalysis1.png :width: 400pt + :align: center - Type 1 with all parameters -.. image:: /img/sensitivityAnalysis3.png +.. image:: images/sensitivityAnalysis3.png :width: 400pt :align: center @@ -218,5 +220,6 @@ The second type - Type 2 -.. image:: /img/sensitivityAnalysis2.png +.. image:: images/sensitivityAnalysis2.png :width: 400pt + :align: center diff --git a/docs/static/default.css b/docs/static/default.css new file mode 100644 index 0000000..7aa01b7 --- /dev/null +++ b/docs/static/default.css @@ -0,0 +1,507 @@ +/** + * Alternate Sphinx design + * Originally created by Armin Ronacher for Werkzeug, adapted by Georg Brandl. + */ + +body { + font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva', 'Verdana', sans-serif; + font-size: 14px; + letter-spacing: -0.01em; + line-height: 150%; + text-align: center; + /*background-color: #AFC1C4; */ + background-color: #BFD1D4; + color: black; + padding: 0; + border: 1px solid #aaa; + + margin: 0px 80px 0px 80px; + min-width: 740px; +} + +a { + color: #CA7900; + text-decoration: none; +} + +a:hover { + color: #2491CF; +} + +pre { + font-family: 'Consolas', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace; + font-size: 0.95em; + letter-spacing: 0.015em; + padding: 0.5em; + border: 1px solid #ccc; + background-color: #f8f8f8; +} + +td.linenos pre { + padding: 0.5em 0; + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + margin-left: 0.5em; +} + +table.highlighttable td { + padding: 0 0.5em 0 0.5em; +} + +cite, code, tt { + font-family: 'Consolas', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace; + font-size: 0.95em; + letter-spacing: 0.01em; +} + +hr { + border: 1px solid #abc; + margin: 2em; +} + +tt { + background-color: #f2f2f2; + border-bottom: 1px solid #ddd; + color: #333; +} + +tt.descname { + background-color: transparent; + font-weight: bold; + font-size: 1.2em; + border: 0; +} + +tt.descclassname { + background-color: transparent; + border: 0; +} + +tt.xref { + background-color: transparent; + font-weight: bold; + border: 0; +} + +a tt { + background-color: transparent; + font-weight: bold; + border: 0; + color: #CA7900; +} + +a tt:hover { + color: #2491CF; +} + +dl { + margin-bottom: 15px; +} + +dd p { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.refcount { + color: #060; +} + +dt:target, +.highlight { + background-color: #fbe54e; +} + +dl.class, dl.function { + border-top: 2px solid #888; +} + +dl.method, dl.attribute { + border-top: 1px solid #aaa; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +pre { + line-height: 120%; +} + +pre a { + color: inherit; + text-decoration: underline; +} + +.first { + margin-top: 0 !important; +} + +div.document { + background-color: white; + text-align: left; + background-image: url(contents.png); + background-repeat: repeat-x; +} + +/* +div.documentwrapper { + width: 100%; +} +*/ + +div.clearer { + clear: both; +} + +div.related h3 { + display: none; +} + +div.related ul { + background-image: url(navigation.png); + height: 2em; + list-style: none; + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 0; + padding-left: 10px; +} + +div.related ul li { + margin: 0; + padding: 0; + height: 2em; + float: left; +} + +div.related ul li.right { + float: right; + margin-right: 5px; +} + +div.related ul li a { + margin: 0; + padding: 0 5px 0 5px; + line-height: 1.75em; + color: #EE9816; +} + +div.related ul li a:hover { + color: #3CA8E7; +} + +div.body { + margin: 0; + padding: 0.5em 20px 20px 20px; +} + +div.bodywrapper { + margin: 0 240px 0 0; + border-right: 1px solid #ccc; +} + +div.body a { + text-decoration: underline; +} + +div.sphinxsidebar { + margin: 0; + padding: 0.5em 15px 15px 0; + width: 210px; + float: right; + text-align: left; +/* margin-left: -100%; */ +} + +div.sphinxsidebar h4, div.sphinxsidebar h3 { + margin: 1em 0 0.5em 0; + font-size: 0.9em; + padding: 0.1em 0 0.1em 0.5em; + color: white; + border: 1px solid #86989B; + background-color: #AFC1C4; +} + +div.sphinxsidebar ul { + padding-left: 1.5em; + margin-top: 7px; + list-style: none; + padding: 0; + line-height: 130%; +} + +div.sphinxsidebar ul ul { + list-style: square; + margin-left: 20px; +} + +p { + margin: 0.8em 0 0.5em 0; +} + +p.rubric { + font-weight: bold; +} + +h1 { + margin: 0; + padding: 0.7em 0 0.3em 0; + font-size: 1.5em; + color: #11557C; +} + +h2 { + margin: 1.3em 0 0.2em 0; + font-size: 1.35em; + padding: 0; +} + +h3 { + margin: 1em 0 -0.3em 0; + font-size: 1.2em; +} + +h1 a, h2 a, h3 a, h4 a, h5 a, h6 a { + color: black!important; +} + +h1 a.anchor, h2 a.anchor, h3 a.anchor, h4 a.anchor, h5 a.anchor, h6 a.anchor { + display: none; + margin: 0 0 0 0.3em; + padding: 0 0.2em 0 0.2em; + color: #aaa!important; +} + +h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor, +h5:hover a.anchor, h6:hover a.anchor { + display: inline; +} + +h1 a.anchor:hover, h2 a.anchor:hover, h3 a.anchor:hover, h4 a.anchor:hover, +h5 a.anchor:hover, h6 a.anchor:hover { + color: #777; + background-color: #eee; +} + +table { + border-collapse: collapse; + margin: 0 -0.5em 0 -0.5em; +} + +table td, table th { + padding: 0.2em 0.5em 0.2em 0.5em; +} + +div.footer { + background-color: #E3EFF1; + color: #86989B; + padding: 3px 8px 3px 0; + clear: both; + font-size: 0.8em; + text-align: right; +} + +div.footer a { + color: #86989B; + text-decoration: underline; +} + +div.pagination { + margin-top: 2em; + padding-top: 0.5em; + border-top: 1px solid black; + text-align: center; +} + +div.sphinxsidebar ul.toc { + margin: 1em 0 1em 0; + padding: 0 0 0 0.5em; + list-style: none; +} + +div.sphinxsidebar ul.toc li { + margin: 0.5em 0 0.5em 0; + font-size: 0.9em; + line-height: 130%; +} + +div.sphinxsidebar ul.toc li p { + margin: 0; + padding: 0; +} + +div.sphinxsidebar ul.toc ul { + margin: 0.2em 0 0.2em 0; + padding: 0 0 0 1.8em; +} + +div.sphinxsidebar ul.toc ul li { + padding: 0; +} + +div.admonition, div.warning { + font-size: 0.9em; + margin: 1em 0 0 0; + border: 1px solid #86989B; + background-color: #f7f7f7; +} + +div.admonition p, div.warning p { + margin: 0.5em 1em 0.5em 1em; + padding: 0; +} + +div.admonition pre, div.warning pre { + margin: 0.4em 1em 0.4em 1em; +} + +div.admonition p.admonition-title, +div.warning p.admonition-title { + margin: 0; + padding: 0.1em 0 0.1em 0.5em; + color: white; + border-bottom: 1px solid #86989B; + font-weight: bold; + background-color: #AFC1C4; +} + +div.warning { + border: 1px solid #940000; +} + +div.warning p.admonition-title { + background-color: #CF0000; + border-bottom-color: #940000; +} + +div.admonition ul, div.admonition ol, +div.warning ul, div.warning ol { + margin: 0.1em 0.5em 0.5em 3em; + padding: 0; +} + +div.versioninfo { + margin: 1em 0 0 0; + border: 1px solid #ccc; + background-color: #DDEAF0; + padding: 8px; + line-height: 1.3em; + font-size: 0.9em; +} + + +a.headerlink { + color: #c60f0f!important; + font-size: 1em; + margin-left: 6px; + padding: 0 4px 0 4px; + text-decoration: none!important; + visibility: hidden; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink { + visibility: visible; +} + +a.headerlink:hover { + background-color: #ccc; + color: white!important; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable dl, table.indextable dd { + margin-top: 0; + margin-bottom: 0; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +img.inheritance { + border: 0px +} + +form.pfform { + margin: 10px 0 20px 0; +} + +table.contentstable { + width: 90%; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li div.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} diff --git a/docs/static/theme_overrides.css b/docs/static/theme_overrides.css new file mode 100644 index 0000000..63ee6cc --- /dev/null +++ b/docs/static/theme_overrides.css @@ -0,0 +1,13 @@ +/* override table width restrictions */ +@media screen and (min-width: 767px) { + + .wy-table-responsive table td { + /* !important prevents the common CSS stylesheets from overriding + this as on RTD they are loaded after this stylesheet */ + white-space: normal !important; + } + + .wy-table-responsive { + overflow: visible !important; + } +} diff --git a/examples/Extreme value statistics.py b/examples/Extreme value statistics.py index 1e7c7d3..78443d8 100644 --- a/examples/Extreme value statistics.py +++ b/examples/Extreme value statistics.py @@ -2,45 +2,33 @@ @author: mofarrag """ -import os - -os.chdir(r"C:\MyComputer\01Algorithms\Statistics\statista") import matplotlib matplotlib.use("TkAgg") -# import scipy.optimize as so -# import matplotlib.pyplot as plt -# import numpy as np -# from matplotlib import gridspec -# from scipy import stats as stats -# from scipy.stats import genextreme, gumbel_r, norm import pandas as pd - from statista.distributions import GEV, ConfidenceInterval, Gumbel, PlottingPosition -# from statista.tools import Tools as st - time_series1 = pd.read_csv("examples/data/time_series1.txt", header=None)[0].tolist() time_series2 = pd.read_csv("examples/data/time_series2.txt", header=None)[0].tolist() #%% Gdist = Gumbel(time_series1) # defult parameter estimation method is maximum liklihood method -Param_dist = Gdist.estimateParameter() +Param_mle = Gdist.estimateParameter(method="mle") Gdist.ks() Gdist.chisquare() -print(Param_dist) -loc = Param_dist[0] -scale = Param_dist[1] +print(Param_mle) +loc = Param_mle[0] +scale = Param_mle[1] # calculate and plot the pdf pdf = Gdist.pdf(loc, scale, plot_figure=True) cdf, _, _ = Gdist.cdf(loc, scale, plot_figure=True) #%% lmoments -Param_dist = Gdist.estimateParameter(method="lmoments") +Param_lmoments = Gdist.estimateParameter(method="lmoments") Gdist.ks() Gdist.chisquare() -print(Param_dist) -loc = Param_dist[0] -scale = Param_dist[1] +print(Param_lmoments) +loc = Param_lmoments[0] +scale = Param_lmoments[1] # calculate and plot the pdf pdf = Gdist.pdf(loc, scale, plot_figure=True) cdf, _, _ = Gdist.cdf(loc, scale, plot_figure=True) @@ -109,7 +97,7 @@ # TheporeticalEstimate method calculates the theoretical values based on the Gumbel distribution Qth = Gevdist.theporeticalEstimate(shape, loc, scale, cdf_Weibul) -func = ConfidenceInterval.GEVfunc +func = GEV.ci_func upper, lower = Gevdist.confidenceInterval( shape, loc, diff --git a/examples/Note books/Extreme value analysis.ipynb b/examples/Note books/Extreme value analysis.ipynb new file mode 100644 index 0000000..e971206 --- /dev/null +++ b/examples/Note books/Extreme value analysis.ipynb @@ -0,0 +1,608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Extreme Value Analysis" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "import matplotlib\n", + "%matplotlib inline\n", + "import pandas as pd\n", + "from statista.distributions import GEV, ConfidenceInterval, Gumbel, PlottingPosition" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(r\"C:\\gdrive\\01Algorithms\\Statistics\\statista\")\n", + "time_series1 = pd.read_csv(\"examples/data/time_series1.txt\", header=None)[0].tolist()\n", + "time_series2 = pd.read_csv(\"examples/data/time_series2.txt\", header=None)[0].tolist()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "# Gumbel Distribution" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----KS Test--------\n", + "Statistic = 0.18518518518518517\n", + "Accept Hypothesis\n", + "P value = 0.7536974563793281\n", + "-----chisquare Test-----\n", + "Statistic = -1.7297426599910237\n", + "P value = 1.0\n", + "-----KS Test--------\n", + "Statistic = 0.18518518518518517\n", + "Accept Hypothesis\n", + "P value = 0.7536974563793281\n", + "-----chisquare Test-----\n", + "Statistic = -1.7297426599910237\n", + "P value = 1.0\n", + "[16.470245610977667, 0.724486313118949]\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Gdist = Gumbel(time_series1)\n", + "# defult parameter estimation method is maximum liklihood method\n", + "Param_mle = Gdist.estimateParameter(method=\"mle\")\n", + "Gdist.ks()\n", + "Gdist.chisquare()\n", + "print(Param_mle)\n", + "loc = Param_mle[0]\n", + "scale = Param_mle[1]\n", + "# calculate and plot the pdf\n", + "pdf = Gdist.pdf(loc, scale, plot_figure=True)\n", + "cdf, _, _ = Gdist.cdf(loc, scale, plot_figure=True)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fit distribution using lmoments" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----KS Test--------\n", + "Statistic = 0.14814814814814814\n", + "Accept Hypothesis\n", + "P value = 0.9356622290518453\n", + "-----chisquare Test-----\n", + "Statistic = -1.7297426599910917\n", + "P value = 1.0\n", + "-----KS Test--------\n", + "Statistic = 0.14814814814814814\n", + "Accept Hypothesis\n", + "P value = 0.9356622290518453\n", + "-----chisquare Test-----\n", + "Statistic = -1.7297426599910917\n", + "P value = 1.0\n", + "[16.44841695242862, 0.8328854157603985]\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Param_lmoments = Gdist.estimateParameter(method=\"lmoments\")\n", + "Gdist.ks()\n", + "Gdist.chisquare()\n", + "print(Param_lmoments)\n", + "loc = Param_lmoments[0]\n", + "scale = Param_lmoments[1]\n", + "# calculate and plot the pdf\n", + "pdf = Gdist.pdf(loc, scale, plot_figure=True)\n", + "cdf, _, _ = Gdist.cdf(loc, scale, plot_figure=True)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# calculate the CDF(Non Exceedance probability) using weibul plotting position\n", + "time_series1.sort()\n", + "# calculate the F (Non Exceedence probability based on weibul)\n", + "cdf_Weibul = PlottingPosition.weibul(time_series1)\n", + "# TheporeticalEstimate method calculates the theoretical values based on the Gumbel distribution\n", + "Qth = Gdist.theporeticalEstimate(loc, scale, cdf_Weibul)\n", + "# test = stats.chisquare(st.Standardize(Qth), st.Standardize(time_series1),ddof=5)\n", + "# calculate the confidence interval\n", + "upper, lower = Gdist.confidenceInterval(loc, scale, cdf_Weibul, alpha=0.1)\n", + "# ProbapilityPlot can estimate the Qth and the lower and upper confidence interval in the process of plotting\n", + "fig, ax = Gdist.probapilityPlot(loc, scale, cdf_Weibul, alpha=0.1)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fit distribution by focuing on part of the data" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "if you want to focus only on high values, you can use a threshold to make the code focus on what is higher\n", + "this threshold." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.000000\n", + " Iterations: 25\n", + " Function evaluations: 94\n", + "-----KS Test--------\n", + "Statistic = 0.25925925925925924\n", + "reject Hypothesis\n", + "P value = 0.3290078898658627\n", + "-----chisquare Test-----\n", + "Statistic = -1.7297426599910737\n", + "P value = 1.0\n", + "[16.653248339988547, 0.7969349444308436]\n" + ] + }, + { + "data": { + "text/plain": "([
,
],\n [,\n ])" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "threshold = 17\n", + "Param_dist = Gdist.estimateParameter(\n", + " method=\"optimization\", ObjFunc=Gumbel.ObjectiveFn, threshold=threshold\n", + ")\n", + "print(Param_dist)\n", + "loc = Param_dist[0]\n", + "scale = Param_dist[1]\n", + "Gdist.probapilityPlot(loc, scale, cdf_Weibul, alpha=0.1)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.000000\n", + " Iterations: 26\n", + " Function evaluations: 96\n", + "-----KS Test--------\n", + "Statistic = 0.2222222222222222\n", + "Accept Hypothesis\n", + "P value = 0.5256377612776422\n", + "For each axis slice, the sum of the observed frequencies must agree with the sum of the expected frequencies to a relative tolerance of 1e-08, but the percent differences are:\n", + "56.0\n", + "[16.607497657735827, 0.8351717220676762]\n" + ] + }, + { + "data": { + "text/plain": "([
,
],\n [,\n ])" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "threshold = 18\n", + "Param_dist = Gdist.estimateParameter(\n", + " method=\"optimization\", ObjFunc=Gumbel.ObjectiveFn, threshold=threshold\n", + ")\n", + "print(Param_dist)\n", + "loc = Param_dist[0]\n", + "scale = Param_dist[1]\n", + "Gdist.probapilityPlot(loc, scale, cdf_Weibul, alpha=0.1)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "# Generalized Extreme Value (GEV)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----KS Test--------\n", + "Statistic = 0.07407407407407407\n", + "Accept Hypothesis\n", + "P value = 0.9987375782247235\n", + "-----chisquare Test-----\n", + "Statistic = -0.3032646471545644\n", + "P value = 1.0\n", + "-----KS Test--------\n", + "Statistic = 0.07407407407407407\n", + "Accept Hypothesis\n", + "P value = 0.9987375782247235\n", + "-----chisquare Test-----\n", + "Statistic = -0.3032646471545644\n", + "P value = 1.0\n", + "[0.005714016754089981, 466.7783159128223, 214.7439840776729]\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Gevdist = GEV(time_series2)\n", + "# default parameter estimation method is maximum liklihood method\n", + "Param_dist = Gevdist.estimateParameter()\n", + "Gevdist.ks()\n", + "Gevdist.chisquare()\n", + "\n", + "print(Param_dist)\n", + "shape = Param_dist[0]\n", + "loc = Param_dist[1]\n", + "scale = Param_dist[2]\n", + "# calculate and plot the pdf\n", + "pdf, fig, ax = Gevdist.pdf(shape, loc, scale, plot_figure=True)\n", + "cdf, _, _ = Gevdist.cdf(shape, loc, scale, plot_figure=True)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fitting distribution using L moments method" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----KS Test--------\n", + "Statistic = 0.07407407407407407\n", + "Accept Hypothesis\n", + "P value = 0.9987375782247235\n", + "-----chisquare Test-----\n", + "Statistic = -0.3202644847766967\n", + "P value = 1.0\n", + "[0.010122582419885787, 464.8250207300632, 222.12098731051674]\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Param_dist = Gevdist.estimateParameter(method=\"lmoments\")\n", + "print(Param_dist)\n", + "shape = Param_dist[0]\n", + "loc = Param_dist[1]\n", + "scale = Param_dist[2]\n", + "# calculate and plot the pdf\n", + "pdf, fig, ax = Gevdist.pdf(shape, loc, scale, plot_figure=True)\n", + "cdf, _, _ = Gevdist.cdf(shape, loc, scale, plot_figure=True)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-02-19 19:49:45.311 | DEBUG | statista.confidence_interval:BootStrap:97 - Some values used top 10 low/high samples; results may be unstable.\n" + ] + } + ], + "source": [ + "time_series1.sort()\n", + "# calculate the F (Non Exceedence probability based on weibul)\n", + "cdf_Weibul = PlottingPosition.weibul(time_series1)\n", + "T = PlottingPosition.weibul(time_series1, option=2)\n", + "# TheporeticalEstimate method calculates the theoretical values based on the Gumbel distribution\n", + "Qth = Gevdist.theporeticalEstimate(shape, loc, scale, cdf_Weibul)\n", + "\n", + "func = GEV.ci_func\n", + "upper, lower = Gevdist.confidenceInterval(\n", + " shape,\n", + " loc,\n", + " scale,\n", + " F=cdf_Weibul,\n", + " alpha=0.1,\n", + " statfunction=func,\n", + " n_samples=len(time_series1),\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-02-19 19:50:02.989 | DEBUG | statista.confidence_interval:BootStrap:97 - Some values used top 10 low/high samples; results may be unstable.\n" + ] + } + ], + "source": [ + "CI = ConfidenceInterval.BootStrap(\n", + " time_series1,\n", + " statfunction=func,\n", + " gevfit=Param_dist,\n", + " n_samples=len(time_series1),\n", + " F=cdf_Weibul,\n", + ")\n", + "LB = CI[\"LB\"]\n", + "UB = CI[\"UB\"]" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-02-19 19:50:13.909 | DEBUG | statista.confidence_interval:BootStrap:97 - Some values used top 10 low/high samples; results may be unstable.\n" + ] + }, + { + "ename": "ValueError", + "evalue": "x and y must be the same size", + "output_type": "error", + "traceback": [ + "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[1;31mValueError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[1;32mIn[15], line 1\u001B[0m\n\u001B[1;32m----> 1\u001B[0m fig, ax \u001B[38;5;241m=\u001B[39m \u001B[43mGevdist\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mprobapilityPlot\u001B[49m\u001B[43m(\u001B[49m\n\u001B[0;32m 2\u001B[0m \u001B[43m \u001B[49m\u001B[43mshape\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mloc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mscale\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcdf_Weibul\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfunc\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mn_samples\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mlen\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mtime_series1\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 3\u001B[0m \u001B[43m)\u001B[49m\n", + "File \u001B[1;32mC:\\gdrive\\01Algorithms\\Statistics\\statista\\statista\\distributions.py:1102\u001B[0m, in \u001B[0;36mGEV.probapilityPlot\u001B[1;34m(self, shape, loc, scale, F, alpha, func, n_samples, fig1size, fig2size, xlabel, ylabel, fontsize)\u001B[0m\n\u001B[0;32m 1099\u001B[0m pdf_fitted \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpdf(shape, loc, scale, actualdata\u001B[38;5;241m=\u001B[39mQx)\n\u001B[0;32m 1100\u001B[0m cdf_fitted \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcdf(shape, loc, scale, actualdata\u001B[38;5;241m=\u001B[39mQx)\n\u001B[1;32m-> 1102\u001B[0m fig, ax \u001B[38;5;241m=\u001B[39m \u001B[43mPlot\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdetails\u001B[49m\u001B[43m(\u001B[49m\n\u001B[0;32m 1103\u001B[0m \u001B[43m \u001B[49m\u001B[43mQx\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1104\u001B[0m \u001B[43m \u001B[49m\u001B[43mQth\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1105\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdata\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1106\u001B[0m \u001B[43m \u001B[49m\u001B[43mpdf_fitted\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1107\u001B[0m \u001B[43m \u001B[49m\u001B[43mcdf_fitted\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1108\u001B[0m \u001B[43m \u001B[49m\u001B[43mF\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1109\u001B[0m \u001B[43m \u001B[49m\u001B[43mQlower\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1110\u001B[0m \u001B[43m \u001B[49m\u001B[43mQupper\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1111\u001B[0m \u001B[43m \u001B[49m\u001B[43malpha\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1112\u001B[0m \u001B[43m \u001B[49m\u001B[43mfig1size\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfig1size\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1113\u001B[0m \u001B[43m \u001B[49m\u001B[43mfig2size\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfig2size\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1114\u001B[0m \u001B[43m \u001B[49m\u001B[43mxlabel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mxlabel\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1115\u001B[0m \u001B[43m \u001B[49m\u001B[43mylabel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mylabel\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1116\u001B[0m \u001B[43m \u001B[49m\u001B[43mfontsize\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfontsize\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 1117\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 1119\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m fig, ax\n", + "File \u001B[1;32mC:\\gdrive\\01Algorithms\\Statistics\\statista\\statista\\plot.py:155\u001B[0m, in \u001B[0;36mPlot.details\u001B[1;34m(Qx, Qth, Qact, pdf, cdf_fitted, F, Qlower, Qupper, alpha, fig1size, fig2size, xlabel, ylabel, fontsize)\u001B[0m\n\u001B[0;32m 152\u001B[0m ax2\u001B[38;5;241m.\u001B[39mplot(Qx, cdf_fitted, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m-\u001B[39m\u001B[38;5;124m\"\u001B[39m, color\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m#27408B\u001B[39m\u001B[38;5;124m\"\u001B[39m, linewidth\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m2\u001B[39m)\n\u001B[0;32m 154\u001B[0m Qact\u001B[38;5;241m.\u001B[39msort()\n\u001B[1;32m--> 155\u001B[0m \u001B[43max2\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mscatter\u001B[49m\u001B[43m(\u001B[49m\u001B[43mQact\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mF\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcolor\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43m#DC143C\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfacecolors\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mnone\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[0;32m 156\u001B[0m ax2\u001B[38;5;241m.\u001B[39mset_xlabel(xlabel, fontsize\u001B[38;5;241m=\u001B[39mfontsize)\n\u001B[0;32m 157\u001B[0m ax2\u001B[38;5;241m.\u001B[39mset_ylabel(ylabel, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m15\u001B[39m)\n", + "File \u001B[1;32mC:\\Miniconda3\\envs\\algorithms\\lib\\site-packages\\matplotlib\\__init__.py:1423\u001B[0m, in \u001B[0;36m_preprocess_data..inner\u001B[1;34m(ax, data, *args, **kwargs)\u001B[0m\n\u001B[0;32m 1420\u001B[0m \u001B[38;5;129m@functools\u001B[39m\u001B[38;5;241m.\u001B[39mwraps(func)\n\u001B[0;32m 1421\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21minner\u001B[39m(ax, \u001B[38;5;241m*\u001B[39margs, data\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[0;32m 1422\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m data \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m-> 1423\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m func(ax, \u001B[38;5;241m*\u001B[39m\u001B[38;5;28mmap\u001B[39m(sanitize_sequence, args), \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m 1425\u001B[0m bound \u001B[38;5;241m=\u001B[39m new_sig\u001B[38;5;241m.\u001B[39mbind(ax, \u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m 1426\u001B[0m auto_label \u001B[38;5;241m=\u001B[39m (bound\u001B[38;5;241m.\u001B[39marguments\u001B[38;5;241m.\u001B[39mget(label_namer)\n\u001B[0;32m 1427\u001B[0m \u001B[38;5;129;01mor\u001B[39;00m bound\u001B[38;5;241m.\u001B[39mkwargs\u001B[38;5;241m.\u001B[39mget(label_namer))\n", + "File \u001B[1;32mC:\\Miniconda3\\envs\\algorithms\\lib\\site-packages\\matplotlib\\axes\\_axes.py:4520\u001B[0m, in \u001B[0;36mAxes.scatter\u001B[1;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, **kwargs)\u001B[0m\n\u001B[0;32m 4518\u001B[0m y \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39mma\u001B[38;5;241m.\u001B[39mravel(y)\n\u001B[0;32m 4519\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m x\u001B[38;5;241m.\u001B[39msize \u001B[38;5;241m!=\u001B[39m y\u001B[38;5;241m.\u001B[39msize:\n\u001B[1;32m-> 4520\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mx and y must be the same size\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m 4522\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m s \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m 4523\u001B[0m s \u001B[38;5;241m=\u001B[39m (\u001B[38;5;241m20\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m mpl\u001B[38;5;241m.\u001B[39mrcParams[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m_internal.classic_mode\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;28;01melse\u001B[39;00m\n\u001B[0;32m 4524\u001B[0m mpl\u001B[38;5;241m.\u001B[39mrcParams[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mlines.markersize\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2.0\u001B[39m)\n", + "\u001B[1;31mValueError\u001B[0m: x and y must be the same size" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3cAAAHGCAYAAADXOnLvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACaOElEQVR4nOzdeVyVZf7/8ddhFxVQUBZFxa1UzAXKRHEXlzJtGWlqrL6Zk9NMpeZMWVmT0+RYU1m/0mrSnMpRp8yywhI1d3IUl9wXRHEBEVQ22Tm/P44cObEICtwHeD8fj/Pwvu9z3ff94ajnnA/XdX0uk9lsNiMiIiIiIiJ1moPRAYiIiIiIiMiNU3InIiIiIiJSDyi5ExERERERqQeU3ImIiIiIiNQDSu5ERERERETqASV3IiIiIiIi9YCSOxERERERkXpAyZ2IiIiIiEg94GR0AFK2oqIizp49S9OmTTGZTEaHIyLSYJjNZjIyMggICMDBQb8DLUmfTSIixqjsZ5OSOzt19uxZAgMDjQ5DRKTBOnXqFK1btzY6DLuizyYREWNd67NJyZ2datq0KWD5C/Tw8DA4GhGRhiM9PZ3AwEDr+7Bcpc8mERFjVPazScmdnSoe7uLh4aEPUBERA2jYYWn6bBIRMda1Pps0mUBERERERKQeUHInIiIiIiJSDyi5ExERERERqQeU3ImIiIiIiNQDSu5ERERERETqASV3IiIiIiIi9YCSOxERERERkXpAyZ2IiIiIiEg9oORORERERESkHlByJyIiUsds3LiRMWPGEBAQgMlk4uuvv77mORs2bCAkJAQ3Nzfat2/PBx98UPOBiohIrVJyJyIiUsdkZWXRo0cP3nvvvUq1j4+PZ/To0YSHh7Nr1y6ef/55nnrqKZYvX17DkYqISG1yMjoAERERqZpRo0YxatSoSrf/4IMPaNOmDXPnzgWgS5cu7Nixg3/+85/ce++9NRSliIjUNiV3IiIi9VxMTAwRERE2x0aMGMGCBQvIz8/H2dnZoMhEROq2oiIzBYVFFF55FFj/NFuPFRaZrc+18vOkibtLjcVjt8ndvHnzeOONN0hMTKRbt27MnTuX8PDwcttv2LCBadOmsX//fgICAvjLX/7C5MmTbdosX76cmTNnEhcXR4cOHfj73//O3XffbX1+9uzZfPXVVxw6dIhGjRoRFhbGnDlzuOmmm6xtzGYzr7zyCh999BEXL16kT58+vP/++3Tr1s3aJjc3l+nTp7NkyRKys7MZOnQo8+bNo3Xr1tX4ComIiFROUlISvr6+Nsd8fX0pKCggJSUFf3//Ms/Lzc0lNzfXup+enl6jcYqIXEtRkZncvAJycgvIyc0nJ7eA3NwCcvIKyMm5cizvyrESj9zcfHLzCskvKCQ/v5D8gqIrf17ZLigkP7+oxPMl9st4rqDAkqyZzVWLf+E/f0NYSNuaeXGw0+Ru2bJlTJkyhXnz5tGvXz8+/PBDRo0axYEDB2jTpk2p9sVzCSZNmsTnn3/Oli1beOKJJ2jRooV1uElMTAyRkZH87W9/4+6772bFihWMHz+ezZs306dPH8CSIP7xj3/k1ltvpaCggBdeeIGIiAgOHDhA48aNAXj99dd56623WLRoEZ07d+bVV19l+PDhHD58mKZNmwIwZcoUvv32W5YuXYq3tzfPPPMMd955J7GxsTg6OtbSqygiInKVyWSy2Tdf+Uby6+MlzZ49m1deeaVG4xKRhqGgsIj0jBwupeeQnplDWnoO6Zm5ZF3OIys7z/Ln5Twul9jOys4vsW35Mye3wOgf5YYUFhbV6PVNZnNV882a16dPH3r37s38+fOtx7p06cK4ceOYPXt2qfbPPvssK1eu5ODBg9ZjkydPZs+ePcTExAAQGRlJeno6q1atsrYZOXIkzZo1Y8mSJWXGcf78eVq2bMmGDRsYMGAAZrOZgIAApkyZwrPPPgtYfqvp6+vLnDlzePzxx0lLS6NFixZ89tlnREZGAnD27FkCAwOJiopixIgRlXoN0tPT8fT0JC0tDQ8Pj0qdIxDXovze3evV4fymar+miNivuvb+azKZWLFiBePGjSu3zYABA+jVqxfvvPOO9VjxLzkvX75c7rDMsnruAgMD68xrIyI1w2w2cyk9h9SLWaRcvMyFi5dJuXiZ1ItZXEzLJi0jh/SMHNKuJHNpGTlkXc4zOuwqcXQw4ezsiLOTI87ODlf+tOw7OTng7OSAo6Pl4eTogKOjqcT2lT8dbI85Ojrwu3t6cVP7FlWOp7KfTXbXc5eXl0dsbCzPPfeczfGIiAi2bt1a5jmVmUsQExPD1KlTS7UpnlxelrS0NACaN28OWHoIk5KSbO7l6urKwIED2bp1K48//jixsbHk5+fbtAkICCA4OJitW7eWm9xp6IuIiNSUvn378u2339ocW716NaGhoRXOt3N1dcXV1bWmwxMRO5KVnUdScgaJyRmWP8+nk5ScQXJqJqlXkrgLFy9TUMM9UMWcnR1p3MiFxu7ONHZ3oZGbM26uTri5OOHm5oybixOurk64uV75s8Rx6zFXJ1xdLA8Xl7ITNpcS+8XJWF1kd8ldSkoKhYWFZc4NSEpKKvOcyswlKK9Nedc0m81MmzaN/v37ExwcbL1P8Xm/vs7JkyetbVxcXGjWrFml7wUa+iIiIpWXmZnJsWPHrPvx8fHs3r2b5s2b06ZNG2bMmMGZM2f49NNPActolvfee49p06YxadIkYmJiWLBgQbkjV0Sk/srNK+B0Yhonz1zi1NlLJJy9xOmzlzh7JZnLyMq99kUqycnRAU8PNzyauOHp4YZn0xIPDzc8GrvS2N3l6qNR8bazdd/Fxe7SFbtmt69WWXMDKpoXUJm5BFW55p/+9Cd++eUXNm/efMOxVabNjBkzmDZtmnW/eOiLiIjIr+3YsYPBgwdb94s/Px5++GEWLVpEYmIiCQkJ1ueDgoKIiopi6tSpvP/++wQEBPDuu+9qGQSRespsNpN0PoNjJ1I5diKV4wmp1mQu6XxGlYuAFHNydKB5M3d8mrnT3Msd72bu+DRrjHdzy5/Nvdxp7tUIL49GeDR1o3Ej52t+R5bqZXfJnY+PD46OjqV6uZKTk0v1mBXz8/Mrs72TkxPe3t4Vtinrmk8++SQrV65k48aNNhUu/fz8AEvvXMnKYiWv4+fnR15eHhcvXrTpvUtOTiYsLKzcn1tDX0REpLIGDRpERVPmFy1aVOrYwIED2blzZw1GJSJGSMvI4cCRcxw+fp5jJ1I5eiKFuJOpZGZVbY6bi7Mjfi2a4teyKf4tmuLboin+LUvuN8GzaSMcHJSs2TO7S+5cXFwICQkhOjraZpmC6Ohoxo4dW+Y5lZlL0LdvX6Kjo23m3a1evdom4TKbzTz55JOsWLGC9evXExQUZHPNoKAg/Pz8iI6OplevXoBljuCGDRuYM2cOACEhITg7OxMdHc348eMBSExMZN++fbz++uvX+7KIiIiISAOXlpHD/iPn2H8kif2Hz7H/6DlOnU2r9PleHo1o28qLwAAv2rTyos2VPwMDvPBp5q5etnrA7pI7sAwvmTBhAqGhofTt25ePPvqIhIQE67p11zOX4Omnn2bAgAHMmTOHsWPH8s0337BmzRqbYZd//OMf+c9//sM333xD06ZNrT19np6eNGrUCJPJxJQpU3jttdfo1KkTnTp14rXXXsPd3Z0HHnjA2nbixIk888wzeHt707x5c6ZPn0737t0ZNmxYbb2EIiIiIlKHmc1mTp65ROze0+zad5bYvWeIP3WhUucG+HrQqZ03Hdp507GdDx3betMusBkeTdxqOGoxml0md5GRkaSmpjJr1iwSExMJDg4mKiqKtm0tC/5dz1yCsLAwli5dyosvvsjMmTPp0KEDy5Yts65xB1iXXhg0aJBNPJ988gmPPPIIAH/5y1/Izs7miSeesC5ivnr1ausadwBvv/02Tk5OjB8/3rqI+aJFi7TGnYiIiIiUyWw2E3cyla07TrL9l9Ps3HeG1IuXKzzHzdWJmzu2pFtnX7p2bEmnIB/at/WmibtLLUUt9sYu17mTurfOkr3QOncicqP0/ls+vTYi1SvlQhYxsSfZEnuSrbEnSU7JLLets5MDXTv50v1mP7p19qXbTb60b+ONUx0t2S9VU2fXuRMRERERqY/MZjNHjqewdssx1mw+xoGj58pt27SxK72DA+gV3IqQ7q3ofrMfbq7lr0spAkruRERERERqTGFhEbF7z7B2yzHWbjnG6cSyC6C4uTpxa4/WhIW0IyykLZ2CfFSZUqpMyZ2IiIiISDUym83sP3KO79YeJOqnw+UOt+zaqSX9bw0iLLQtvbsFaMFuuWH6FyQiIiIiUg1OJ17i69UH+G7tQU6culjqeSdHB27rGciQfh0YEtaRAF/NXZXqpeROREREROQ65RcUsm5LHF98/wtbdpzg16UKnZ0cCL8tiFGDbmJg3/ZajkBqlJI7EREREZEqOpOUxrJvf+GrVXtJ+dWSBSYT3NojkDuHdiFiQCe8PBoZFKU0NEruREREREQq6ZeDiXzy3x38uPEIRUW23XSt/T25b3R3xo3ohl+LpuVcQaTmKLkTEREREalAYWER67bG8cl/d7Bz3xmb55wcHRjavyPj77yFvr3bqsKlGErJnYiIiIhIGQoLi/hxwxHmfRrDsZOpNs95N3PnwXG9GH/nLfg0b2xQhCK2lNyJiIiIiJRQUVLXqZ03j/wmlDuHdcFVSxeIndG/SBERERERLOvTbfj5OG9+tJGjJ2yTut7BrfjDhNvpf2s7TCYNvRT7pORORERERBq8A0fP8fr8Dfy8K8HmeO/gVvzpkTD69m6jpE7snpI7EREREWmwzp3P4K2PN7Ey+oDNGnU9uvrz9KP9ldRJnaLkTkREREQanILCIj7/aifvfrKFy9n51uOBAZ488/sBjBjQWUmd1DlK7kRERESkQdm1/yyvvB3Nobjz1mOeHm48MaEvvx3bExdnRwOjE7l+Su5EREREpEHIvJzHPz/cwNKVe6zHTCYYf2cPpj7WHy+PRgZGJ3LjlNyJiIiISL33864EXnj9B84kpVuPdenYkpenDqNn1wADIxOpPkruRERERKTeupydx1v/2sTnK3ZZj7m7OTNlYn8euLsXTo4OBkYnUr2U3ImIiIhIvbT/yDmm/e07Tp6+aD12a4/WvPaXkQQGeBkXmEgNUXInIiIiIvWK2Wzm8xW7eP2DDeTnFwLg5urEtMfC+d09vXFwUBVMqZ+U3ImIiIhIvZGWkcMLr//Ams3HrMe63+zH68+PJiiwuYGRidQ8JXciIiIiUi/sP3KOJ1/6hrPnrhZNeeQ3IUybNEDLG0iDoOROREREROq879cd4oXXfyAntwCwrFs3+9lRDAnrYHBkIrVHyZ2IiIiI1FmFhUXMXbiZf/3nf9ZjPbr6M/flMfi39DAwMpHap+ROREREROqkzKxcnvnbd2zYFm89du+oYF6eMgwXF33NlYZH/+pFREREpM45l5LJ488t51DceQAcHUzM+NNgHhzXC5NJ1TClYVJyJyIiIiJ1yrETKfz+ueWcPZcBWObXvfPyXdzeu43BkYkYS8mdiIiIiNQZO345zRMvrCA9MxeAVn4e/GvOfbRvo2UORJTciYiIiEid8FNMHE+/vJK8KwuTd+3Ukg//cS8tmjc2ODIR++BgdAAiIiIiItfyw4bDPDnzG2ti1//Wdnw6934ldiIlqOdOREREROzat9EHePYfqygqMgMwesjNzJkxCmcnLUwuUpKSOxERERGxW19+v5eZb/6I2ZLXcffIbrw6fQSOjhqAJvJrSu5ERERExC6t+GEfL/7zR+v+b+/qwcynh+HgoKUORMqi5E5ERERE7M6qnw7xwhtXE7uH7wvhuScGaQ07kQrYbX/2vHnzCAoKws3NjZCQEDZt2lRh+w0bNhASEoKbmxvt27fngw8+KNVm+fLldO3aFVdXV7p27cqKFStsnt+4cSNjxowhICAAk8nE119/XeoaJpOpzMcbb7xhbTNo0KBSz99///3X90KIiIiINDA/xcTx579HWefYTbintxI7kUqwy+Ru2bJlTJkyhRdeeIFdu3YRHh7OqFGjSEhIKLN9fHw8o0ePJjw8nF27dvH888/z1FNPsXz5cmubmJgYIiMjmTBhAnv27GHChAmMHz+ebdu2WdtkZWXRo0cP3nvvvXJjS0xMtHksXLgQk8nEvffea9Nu0qRJNu0+/PDDG3xVREREROq/mNiTPP3ySgoKiwC4b3R3ZvxxsBI7kUowmc3F01PtR58+fejduzfz58+3HuvSpQvjxo1j9uzZpdo/++yzrFy5koMHD1qPTZ48mT179hATEwNAZGQk6enprFq1ytpm5MiRNGvWjCVLlpS6pslkYsWKFYwbN67CWMeNG0dGRgZr1661Hhs0aBA9e/Zk7ty5lf2RS0lPT8fT05O0tDQ8PDyu+zoNTVyL8Gq/ZofzFfcai0j9ovff8um1kZq2/8g5Jjy9lMs5+QDcMeRmXn9+tIqnSINX2fdfu/ufkpeXR2xsLBERETbHIyIi2Lp1a5nnxMTElGo/YsQIduzYQX5+foVtyrtmZZw7d47vv/+eiRMnlnpu8eLF+Pj40K1bN6ZPn05GRkaF18rNzSU9Pd3mISIiItJQnE5K4/HnllsTu6H9OvKPGaOU2IlUgd0VVElJSaGwsBBfX1+b476+viQlJZV5TlJSUpntCwoKSElJwd/fv9w25V2zMv7973/TtGlT7rnnHpvjDz74IEFBQfj5+bFv3z5mzJjBnj17iI6OLvdas2fP5pVXXrnuWERERETqqkvp2Uz6y3JSLl4GoHdwK9566U6tYydSRXaX3BX79bhqs9lc4Vjrstr/+nhVr3ktCxcu5MEHH8TNzc3m+KRJk6zbwcHBdOrUidDQUHbu3Env3r3LvNaMGTOYNm2adT89PZ3AwMDrjk1ERESkLsjNK+CJF74m/tQFAIICm/P+q+NwdbHbr6kidsvu/tf4+Pjg6OhYqkctOTm5VM9bMT8/vzLbOzk54e3tXWGb8q55LZs2beLw4cMsW7bsmm179+6Ns7MzR48eLTe5c3V1xdXV9bpiEREREamLzGYzM+b8wM59ZwDwaebOv+bcQzPPRgZHJlI32d0gZhcXF0JCQkoNYYyOjiYsLKzMc/r27Vuq/erVqwkNDcXZ2bnCNuVd81oWLFhASEgIPXr0uGbb/fv3k5+fj7+//3XdS0RERKQ++nDxNqLWHQLA3c2Z+bPvobW/l7FBidRhdtdzBzBt2jQmTJhAaGgoffv25aOPPiIhIYHJkycDliGMZ86c4dNPPwUslTHfe+89pk2bxqRJk4iJiWHBggU2VTCffvppBgwYwJw5cxg7dizffPMNa9asYfPmzdY2mZmZHDt2zLofHx/P7t27ad68OW3atLEeT09P54svvuDNN98sFXtcXByLFy9m9OjR+Pj4cODAAZ555hl69epFv379qv21EhEREamL1m2N452FV7+HvfHCHXS/yc/AiETqPrtM7iIjI0lNTWXWrFkkJiYSHBxMVFQUbdu2BSxrzZVc8y4oKIioqCimTp3K+++/T0BAAO+++67N2nNhYWEsXbqUF198kZkzZ9KhQweWLVtGnz59rG127NjB4MGDrfvFc+AefvhhFi1aZD2+dOlSzGYzv/3tb0vF7uLiwtq1a3nnnXfIzMwkMDCQO+64g5dffhlHR00KFhERETl2IoU///17ihfkevrRfgzt39HYoETqAbtc5060ltD10jp3InKj9P5bPr02Uh3SMnIY/4fPOXnmEgAjB3bm7ZfHaJFykQrU2XXuRERERKR+Kioy8+zsKGti16VjS157dqQSO5FqouRORERERGrFwmXbWR9zHAAvj0a897exuDdyMTgqkfpDyZ2IiIiI1LjYvad5+2PLVAeTCd54YTSt/DwNjkqkflFyJyIiIiI16sKly0yd9R2FRZZSD5N/dzvhtwUZHJVI/aPkTkRERERqTFGRmT//PYrklEwAbusZyJ8evr51hkWkYkruRERERKTGfPLf7WzZcQIAn2bu/PPFO3B01FdQkZqg/1kiIiIiUiMOHUtm7gLLQuUmE/zzxTtp6d3E4KhE6i8ldyIiIiJS7XLzCvjz378nv6AIgEfH38rtvdsYHJVI/abkTkRERESq3Vv/2sTRE6kA3NyhBU8/2s/giETqPyejAxC5XkfjU/gyai87fjlNcmomjVydCQy8lf5pZ+ibkYiz2Wx0iCIiIg3S1tiT/PvLWABcnB1544U7cHHR106Rmqb/ZVLnZGblMmf+Br74/pdSzyV4BrDFMwD/3Ez+kPgLIZnnDYhQRESk4UrPzGHGP1ZZ96f/fgCdgnwMjEik4dCwTKlTTielcf8f/2OT2JlM4OvTBHc3Z+uxRNcmvNQujM9a3kyREYGKiIg0UG98sIFzV5Y9CAtpy+/u6W1wRCINh5I7qTPOnc/goSlLOXbSMn6/sbsLf358AD9/8yc2fDGZ7d89yWvxW+iWlWI9Z2nLm3inVS8leCJSL82bN4+goCDc3NwICQlh06ZNFbZfvHgxPXr0wN3dHX9/f/7v//6P1NTUWopWGoKY2JN88f1eANwbOfPqn0fg4GAyOCqRhkPJndQJWdl5PPbscs6eywCgXWAzvvpoAhPvvw3Ppm4AODo60CMrhTnxW3gscR8OV+bcrWnWhvcDeqAZeCJSnyxbtowpU6bwwgsvsGvXLsLDwxk1ahQJCQlltt+8eTMPPfQQEydOZP/+/XzxxRds376dxx57rJYjl/rqcnYeM99cbd3/8+MDCfD1MDAikYZHyZ3UCa++u5aj8ZYeudb+nnz6diRtWzUrs60JuDs1judObcfBbOmz+6F5O1Z6t6+tcEVEatxbb73FxIkTeeyxx+jSpQtz584lMDCQ+fPnl9n+559/pl27djz11FMEBQXRv39/Hn/8cXbs2FHLkUt9NXfBZk4npgEQektrIsf0MDgikYZHyZ3Yvah1h1jxw37AMsTjo3/cW6kFUPulJ/LM6Z3W/Y/9urGnsSZ0i0jdl5eXR2xsLBERETbHIyIi2Lp1a5nnhIWFcfr0aaKiojCbzZw7d44vv/ySO+64o9z75Obmkp6ebvMQKcvOvWf47CvLZ66ri5OGY4oYRMmd2LWMzFxee2+ddf/lKcNo36Z5pc8flHaG8eePAFBkcuCt1r3JdFCRWBGp21JSUigsLMTX19fmuK+vL0lJSWWeExYWxuLFi4mMjMTFxQU/Pz+8vLz4f//v/5V7n9mzZ+Pp6Wl9BAYGVuvPIfVDXn4hL725muIViJ56tB/tWpc9ukZEapaSO7Fr7/17KykXLwMwtF9HxkZ0q/I1fnfuID2uLImQ4tyIDwJuqdYYRUSMYjLZ9oyYzeZSx4odOHCAp556ipdeeonY2Fh++OEH4uPjmTx5crnXnzFjBmlpadbHqVOnqjV+qR8+/TLWWuws+CZfHr4vxOCIRBoudWGI3Tpx+iKflxjiMeNPg6/rOo7AlDO7+GPHwVx2dOYnr0AGXTpNaGZyNUYrIlJ7fHx8cHR0LNVLl5ycXKo3r9js2bPp168ff/7znwG45ZZbaNy4MeHh4bz66qv4+/uXOsfV1RVXV9fq/wGk3khMTuf9Ty1DgR0cTPx16nCcHNV3IGIU/e8TuzX/0xgKiyxjPCY9cBut/Tyv+1ot87N5PHGvdf9D/+7km/TPX0TqJhcXF0JCQoiOjrY5Hh0dTVhYWJnnXL58GQcH2/c9R0dHwNLjJ3I9XnvvJ7JzCgC4/64eBN/kZ3BEIg2bvt2KXYo/dYFv1x4EwNPDjUeqYYjH0EunrGvgnXVtwnKfjjd8TRERo0ybNo2PP/6YhQsXcvDgQaZOnUpCQoJ1mOWMGTN46KGHrO3HjBnDV199xfz58zl+/Dhbtmzhqaee4rbbbiMgIMCoH0PqsI3bjhO96SgA3s3cmTKxv8ERiYiGZYpd+nDxNoqu9Nr9329CadL4xocFmYAnzv7Ckx0HUWRy4L8tOhFx8STNC3Jv+NoiIrUtMjKS1NRUZs2aRWJiIsHBwURFRdG2bVsAEhMTbda8e+SRR8jIyOC9997jmWeewcvLiyFDhjBnzhyjfgSpw3Jy8/nbu2ut+8/+YRAeTdwMjEhEAExmjcWwS+np6Xh6epKWloaHR8NaAPT8hSyGRH5IfkERnk3dWLv09zRxd6nUuXEtwq/Z5kO/YFb6dADgjtR4nkj8pcL2Hc5vqtS9RaR+aMjvv9ei10aKvf/vrfy/RZa5drf2aM2nb0eWW8xHRG5cZd9/NSxT7M6yb/eQX2BZfHz8nbdUOrGrrPvPH6FRoWV+wA/N25Lo4l6t1xcREanPzp3P4OOl/wPAydGBl54epsROxE4ouRO7kpdfyNJvdgOWqlu/Hduz2u/hWZjH3anHACg0OfB5y5ur/R4iIiL11Vsfb7IWUfnt2J50CvIxOCIRKabkTuzKjxuOWNe1G9a/IwG+NTPs5+6UODyuzLXb4Nma0y5NauQ+IiIi9cnew0l8s/oAAJ5N3fjjw30NjkhESlJyJ3ZlxQ/7rNsP3t2rxu7jXlTAvSmW3juzycSXLVQ5U0REpCJms5l/vP+Tdf+PD/XFy6ORgRGJyK8puRO7kZicTszOkwAEBnhyW4/AGr3f6AsnaFyYB8BPnoGkOKnKl4iISHl+3HiE2L1nAGgX2IzfjutpbEAiUoqSO7EbK6MPUly7dWxEtxqfnO1eVMCdqfEAFDg48JXWvRMRESlTbl4B//xwo3X/L5MH4ezkaGBEIlIWJXdiF8xmMyt+vDokc1xE11q579jU47gWXa2cme7oXCv3FRERqUsWf72L04lpAPTt3YbBfdsbHJGIlEXJndiFvYeSOHHqImBZL6e1v1et3NezMI/hFy2L/OY6OPFDs3a1cl8REZG6IiMzlw8XbwPAZLIsWK6lD0Tsk5I7sQs/bDhs3R47vFut3nts6nFMV8aDRjVvRyH6wBIRESn2yX+3k5aeA8CYYV25uWNLgyMSkfIouRPDmc1mVm88CoCjg4mh/Wt37ltAXha3ZpwD4LyLOz97+NXq/UVEROxVyoUsFn0RC4CzkwNPPhJmcEQiUhEld2K4g8eSreP4+/RqQzPP2i+rPObCcev2Sm/NIxAREQH4cPE2LufkAzB+TA8CA7yMDUhEKqTkTgxX3GsHEDGgkyEx9Mo8T+ucDAD2NfbhuFvNLJ4uIiJSV5xOSmPpyt0ANHJz4g+/u93YgETkmuw2uZs3bx5BQUG4ubkREhLCpk2bKmy/YcMGQkJCcHNzo3379nzwwQel2ixfvpyuXbvi6upK165dWbFihc3zGzduZMyYMQQEBGAymfj6669LXeORRx7BZDLZPG6/3fbNLjc3lyeffBIfHx8aN27MXXfdxenTp6v+IjQAZrOZHzccASyTtIf2Nya5M2Hbe/dd8yBD4hAREbEX/++TLeQXFAHw8H2h+DRvbHBEInItdpncLVu2jClTpvDCCy+wa9cuwsPDGTVqFAkJCWW2j4+PZ/To0YSHh7Nr1y6ef/55nnrqKZYvX25tExMTQ2RkJBMmTGDPnj1MmDCB8ePHs23bNmubrKwsevTowXvvvVdhfCNHjiQxMdH6iIqKsnl+ypQprFixgqVLl7J582YyMzO58847KSwsvIFXpX6KO5lK/KkLAIR0b00LAz84hl46RaNCy9CTDZ6tuezgZFgsIiIiRjp2IoWV0QcA8PRwY2LkrQZHJCKVYZffXt966y0mTpzIY489BsDcuXP58ccfmT9/PrNnzy7V/oMPPqBNmzbMnTsXgC5durBjxw7++c9/cu+991qvMXz4cGbMmAHAjBkz2LBhA3PnzmXJkiUAjBo1ilGjRl0zPldXV/z8yi66kZaWxoIFC/jss88YNmwYAJ9//jmBgYGsWbOGESNGVO3FqOc2/Hy1t2x4uDG9dsUaFRUyMO0MPzRvR46jE5s8AxhxsexfKIiIiNRn8z77mSuFpPn9b2+jaRNXYwMSkUqxu+QuLy+P2NhYnnvuOZvjERERbN26tcxzYmJiiIiIsDk2YsQIFixYQH5+Ps7OzsTExDB16tRSbYoTwqpYv349LVu2xMvLi4EDB/L3v/+dli0tZYFjY2PJz8+3iScgIIDg4GC2bt1abnKXm5tLbm6udT89Pb3KcdVFP765HJq0ACDo6ReI+0OWofGMvHCSH5q3A+DHZm2V3ImISIMTdzKVVT8dAqC5VyN+O7ansQGJSKXZ3bDMlJQUCgsL8fX1tTnu6+tLUlJSmeckJSWV2b6goICUlJQK25R3zfKMGjWKxYsXs27dOt588022b9/OkCFDrIlZUlISLi4uNGvWrEr3mj17Np6entZHYGBgleKqizKzctnf2BsA/9xMAvKMTewAOuZcIijbUrnzsHtzTrg2NTgiERGR2jW/RK/dxMhbcW/kYmxAIlJpdpfcFTOZbBeSNpvNpY5dq/2vj1f1mmWJjIzkjjvuIDg4mDFjxrBq1SqOHDnC999/X+F517rXjBkzSEtLsz5OnTpVpbjqoq2xJyk0Wf4JhmYm28XS4SZgxMWT1v3VzdoaF4yIiEgtO55wgagrvXbNPNVrJ1LX2F1y5+Pjg6OjY6leruTk5FI9b8X8/PzKbO/k5IS3t3eFbcq7ZmX5+/vTtm1bjh49ar1PXl4eFy9erNK9XF1d8fDwsHnUd5v+F2/dDr2yiLg9GHTpNC5FluI367wCyc0rMDgiERGR2vHB5z9TVGT5BfmjkaHqtROpY+wuuXNxcSEkJITo6Gib49HR0YSFhZV5Tt++fUu1X716NaGhoTg7O1fYprxrVlZqaiqnTp3C398fgJCQEJydnW3ulZiYyL59+274XvWJ2Wxm4zZLcudSVEj3rBSDI7qqaVE+/dLPApDh5MKazccMjkhERKTmxZ+6wHdrDwLg5dGIB8b1MjgiEakqu0vuAKZNm8bHH3/MwoULOXjwIFOnTiUhIYHJkycDliGMDz30kLX95MmTOXnyJNOmTePgwYMsXLiQBQsWMH36dGubp59+mtWrVzNnzhwOHTrEnDlzWLNmDVOmTLG2yczMZPfu3ezevRuwLLGwe/du6xIMmZmZTJ8+nZiYGE6cOMH69esZM2YMPj4+3H333QB4enoyceJEnnnmGdauXcuuXbv43e9+R/fu3a3VMwWOHE/hXEomALdkncfVXGRwRLYiSgzNXLl6v4GRiIiI1I4PPrvaa/d/40NprF47kTrH7qplgmVeW2pqKrNmzSIxMZHg4GCioqJo29Yy/ykxMdFmzbugoCCioqKYOnUq77//PgEBAbz77rvWZRAAwsLCWLp0KS+++CIzZ86kQ4cOLFu2jD59+ljb7Nixg8GDB1v3p02bBsDDDz/MokWLcHR0ZO/evXz66adcunQJf39/Bg8ezLJly2ja9GrhjbfffhsnJyfGjx9PdnY2Q4cOtZ4vFltiT1i3QzKSjQukHMFZqbTIu8x5F3c2bz9ByoUsLd4qIiL1VsKZS3x7pdfO08ONB+9Wr51IXWQyF1ceEbuSnp6Op6cnaWlp9XL+3eMzvrKucTf/6Dra5GYYHFFp//btwn9bdAZgxh8H8/B9IQZHJCK1ob6//94IvTb111/fjmbpyj0APP1oP/4woa/BEYlISZV9/7XLYZlSv+UXFLJ9j6UaqFd+DoF2mNgBDL50tWLpN6sPGBiJiIhIzUm5kMVXq/YB4N7IWXPtROowJXdS6/YfOcfl7HwAemSl2MUSCGVpk5tJx+xLABw4eo5jJ+yn6IuIiEh1+eyrneTlW6pER47pgWdTN4MjEpHrpeROat22XVd7xG6xoyqZZRlSsvcuWr13IiJSv2RezmPJN7sBcHZy4BFNQRCp05TcSa3btutqMZweWecNjOTaBl46jaODpW/xuzUHrVXERERE6oP/freH9MxcAMYM64pvi6bXOENE7JmSO6lVeXkFxO49A0CAb1P88i4bHFHFvArz6H9rOwASkzP4355TFZ8gIiJSR+TlFbDoi1jr/sT7bzUwGhGpDkrupFbtPpBIbl4BALf1bGO38+1Kuiuim3X7+ytlokVEROq6b9ccJPnKmrND+3WkQ1tvgyMSkRul5E5q1bbdV4dk3t6rjYGRVN7gvu1xd3MGYPWmo+QXFBockYiIyI0pKjKzYNl26/6kB24zMBoRqS5K7qRW7bwyJBPg1h6tDYyk8twbuTAorAMAaek5xMSeNDgiERGRG7Nx23GOJ1wAIPSW1vTsGmBwRCJSHZTcSa0pKCxiz4FEAPxaNKWVn6fBEVXe6ME3WbejfjpsYCQiIiI37tPlO63bj44PNTASEalOSu6k1hw6lszlHMv6dr2D69ZvCMNvC6JJYxcA1mw+ap03KCIiUtcciT/P1iujUNoEeDGobweDIxKR6qLkTmrNzn1nrdu9glsZGEnVubo4MTSsIwCZWXls/t8JYwMSERG5Tp+V6LWbcG9vHBzqQnkzEakMJXdSa3btuzrfLqR73UruAEYPudm6HfXTIQMjERERuT4XLl3mm9UHAGjS2IW7RwYbHJGIVCcld1IrzGYzsVeSO/dGznRu38LgiKqub0hbPJu6AfDT1jiyrwwxFRERqSv++90v5OVbqj7fN7o7TdxdDI5IRKqTkjupFWfOpVvX0unZNQAnx7r3T8/F2ZHh4Z0AuJyTz4Ztxw2OSEREpPLy8gtZ/PUuABwcTPzu7l4GRyQi1a3ufcOWOmlXiSUQetWxYioljSpRNXOVqmaKiEgd8sP6w5xPzQIsi5a39vcyNiARqXZK7qRW7LSZb1c31rcrS59ebWju1QiA9THHybycZ3BEIiIi12Y2m1n0Rax1/+H7QgyMRkRqipI7qRXFlTIdHEzc0sXf4Giun5OjAyMGdAYgN6+AjT9raKaIiNi/XfvPcuDoOQC6dvKtk4XNROTalNxJjcu8nMeR+PMA3NyhRZ2fvB1xJbkDiN501MBIREREKmfJN7ut2xPu6YXJpOUPROojJXdS4/YfScJstmz3qMO9dsVu7RmIl4dlaOaGn4+Tk6uqmSIiYr8uXLrMDxuOAODp4WaztI+I1C9K7qTG7T2YZN0OvtnPwEiqh5OjA0P7dQAsVTO3bD9pcEQiIiLlW75qL/lXlj+4d1Qwri5OBkckIjVFyZ3UuF8OJVq3b7m57vfcge3QzNUbjxgYiYiISPkKC4tY9u0v1v37x/Q0LhgRqXFK7qTG7Tts6blzb+RM+zbNDY6mevTt3YYmjS1zB3+KibMuCCsiImJPNm8/wenENAD639qONq28jA1IRGqUkjupUecvZHH2XAYAwTf54VgHFy8vi4uLE4NutwzNTM/MZduuBIMjEhERKW3Jyt3W7QfG9jQsDhGpHfXjm7bYrb2Hrs63u6UezLcrKWJAJ+v26o2qmikiIvbldFIaG64s2ePfsikDb29vcEQiUtOU3EmN2ltivl19KKZSUvhtQTRys0xKX7vlKIWFRQZHJCIictV/v/3FWq06ckyPejN6RkTKp//lUqN+OViy565+FFMp1sjNmfDbggC4cCmb2L1nDI5IRETEIi+vgC+jLIVUnBwduHd0d4MjEpHaoOROaozZbLb23Pk0c8e/ZVODI6p+w8NVNVNEROzP6k1HuXApG7BMI2jRvLHBEYlIbVByJzXm5JlLpGfmAtC9iz8mk8ngiKrf4L7tcXZ2BCB601GKiswGRyQiIgJffr/Xun3/XT2NC0REapWSO6kx9bmYSrEmjV0JC2kLwLmUTJufWURExAgJZy7x85Uqzm1bN+PWHq0NjkhEaouSO6kxNsVUbqqfyR38umqmhmaKiIixlq+62mt33+jgejlyRkTKpuROasz+I+es2/U5uRsS1hFHB8sHZ/Smo5jNGpopIiLGKCgsYsWP+wFwdDAxbkSwwRGJSG1Scic1oqjIzMFjyQAE+HrQzLORwRHVnGaejbi1RyAACWcvcexEqsERiYhIQ7Xpf/Ekp2QCMDisgwqpiDQwSu6kRpw8c5HL2fkAdO3U0uBoat7Q/h2t22u3HDMwEhERachKFlLR8gciDY+SO6kRB48mW7e7dvI1MJLaMbTf1eRuzeajBkYiIiIN1fkLWayPiQOgpU8T61qsItJw2G1yN2/ePIKCgnBzcyMkJIRNmzZV2H7Dhg2EhITg5uZG+/bt+eCDD0q1Wb58OV27dsXV1ZWuXbuyYsUKm+c3btzImDFjCAgIwGQy8fXXX9s8n5+fz7PPPkv37t1p3LgxAQEBPPTQQ5w9e9am3aBBgzCZTDaP+++///peiDrqwNGr8+26NICeuwBfD2sP5b7D50g6n2FwRCIi0tB8/eM+Cq8syXPPyGCcHO32a56I1BC7/F+/bNkypkyZwgsvvMCuXbsIDw9n1KhRJCQklNk+Pj6e0aNHEx4ezq5du3j++ed56qmnWL58ubVNTEwMkZGRTJgwgT179jBhwgTGjx/Ptm3brG2ysrLo0aMH7733Xpn3uXz5Mjt37mTmzJns3LmTr776iiNHjnDXXXeVajtp0iQSExOtjw8//PAGX5W65cCxEj13Het/cge2vXfrNDRTRERqkdls5suofdb9e0epkIpIQ2Qy22Fpvz59+tC7d2/mz59vPdalSxfGjRvH7NmzS7V/9tlnWblyJQcPHrQemzx5Mnv27CEmJgaAyMhI0tPTWbVqlbXNyJEjadasGUuWLCl1TZPJxIoVKxg3blyFsW7fvp3bbruNkydP0qZNG8DSc9ezZ0/mzp1blR/bRnp6Op6enqSlpeHh4XHd1zGC2Wym77h5XErPxruZO5uX/6HcMsxxLcJrObqq63C+4l7jYofjzjP2sX8DEBbaloVv/KYmwxKRGlKX339rml4b+7V9zykmTFkGwO292rDorfEGRyQi1amy779213OXl5dHbGwsERERNscjIiLYunVrmefExMSUaj9ixAh27NhBfn5+hW3Ku2ZlpaWlYTKZ8PLysjm+ePFifHx86NatG9OnTycjo+EM00s6n8Gl9GwAunRs2WDW1+nc3ofW/p4A/G/XKdIzcwyOSETqu6pOYcjNzeWFF16gbdu2uLq60qFDBxYuXFhL0UpNKllI5b47VEhFpKFyMjqAX0tJSaGwsBBfX9siHL6+viQlJZV5TlJSUpntCwoKSElJwd/fv9w25V2zMnJycnjuued44IEHbDLoBx98kKCgIPz8/Ni3bx8zZsxgz549REdHl3ut3NxccnNzrfvp6enXHZfRGloxlWImk4mh/Try7y9jKSgsYsPP8YwZ1sXosESkniqewjBv3jz69evHhx9+yKhRozhw4IB1JMmvjR8/nnPnzrFgwQI6duxIcnIyBQUFtRy5VLfMy3n8uPEIAJ5N3Rge3sngiETEKHaX3BX7dW+P2WyusAeorPa/Pl7Va1YkPz+f+++/n6KiIubNm2fz3KRJk6zbwcHBdOrUidDQUHbu3Env3r3LvN7s2bN55ZVXrisWe7O/RDGVhrAMQknFyR1Y5t0puRORmvLWW28xceJEHnvsMQDmzp3Ljz/+yPz588ucwvDDDz+wYcMGjh8/TvPmzQFo165dbYYsNeTHDYfJybUk6XcMuRlXF7v9eiciNczuhmX6+Pjg6OhYqkctOTm5VM9bMT8/vzLbOzk54e3tXWGb8q5Zkfz8fMaPH098fDzR0dHXnHfQu3dvnJ2dOXq0/BL5M2bMIC0tzfo4depUleOyFw215w6gd/dWeHlYFmzfsO04eXn6jbiIVL/rmcKwcuVKQkNDef3112nVqhWdO3dm+vTpZGdnl3uf3Nxc0tPTbR5if75ZfcC6PTaim4GRiIjR7C65c3FxISQkpNQQxujoaMLCwso8p2/fvqXar169mtDQUJydnStsU941y1Oc2B09epQ1a9ZYk8eK7N+/n/z8fPz9/ctt4+rqioeHh82jrjpwJblr0tjFOgetoXBydGBwWHsALmfn8/Ousiu8iojciOuZwnD8+HE2b97Mvn37WLFiBXPnzuXLL7/kj3/8Y7n3mT17Np6entZHYGBgtf4ccuPOJKXxv92WXwi3C2zGLV38DI5IRIxkd8kdwLRp0/j4449ZuHAhBw8eZOrUqSQkJDB58mTA0sv10EMPWdtPnjyZkydPMm3aNA4ePMjChQtZsGAB06dPt7Z5+umnWb16NXPmzOHQoUPMmTOHNWvWMGXKFGubzMxMdu/eze7duwHLEgu7d++2LsFQUFDAfffdx44dO1i8eDGFhYUkJSWRlJREXl4eAHFxccyaNYsdO3Zw4sQJoqKi+M1vfkOvXr3o169fDb9yxruYdtm6xtvNHVri4NAwiqmUNKzf1bkOazZrSQQRqTlVmW5QVFSEyWRi8eLF3HbbbYwePZq33nqLRYsWldt7V59GldRXK6Ov9tqNi+jWYIqYiUjZ7HJQdmRkJKmpqcyaNYvExESCg4OJioqibdu2ACQmJtqseRcUFERUVBRTp07l/fffJyAggHfffZd7773X2iYsLIylS5fy4osvMnPmTDp06MCyZcvo06ePtc2OHTsYPHiwdX/atGkAPPzwwyxatIjTp0+zcuVKAHr27GkT808//cSgQYNwcXFh7dq1vPPOO2RmZhIYGMgdd9zByy+/jKOjY7W/VvbmQIkhmd06N6whmcXCQtvi5upETm4BP22No2iquUEmuSJSc65nCoO/vz+tWrXC0/PqiIouXbpgNps5ffo0nTqVLsLh6uqKq6tr9QYv1cZsNvN1iSGZdw3vamA0ImIP7DK5A3jiiSd44oknynxu0aJFpY4NHDiQnTt3VnjN++67j/vuu6/c5wcNGkRFy/61a9euwucBAgMD2bBhQ4Vt6rMDJYqpdGkgi5f/WiM3Z/qFtmPtlmOcv5DFL4cS6dk1wOiwRKQeKTmF4e6777Yej46OZuzYsWWe069fP7744gsyMzNp0qQJAEeOHMHBwYHWrVvXStxSvfYcTOTk6YsA9OkVSIBv3Z3SISLVwy6HZUrdVbKYSpcGVimzpKH9O1q312popojUgKpOYXjggQfw9vbm//7v/zhw4AAbN27kz3/+M48++iiNGjUy6seQG/D1j/ut2+NUSEVEUHIn1ezw8fMAODs70r5Nc4OjMc7gvu2tQzE1705EakJkZCRz585l1qxZ9OzZk40bN1Y4haFJkyZER0dz6dIlQkNDefDBBxkzZgzvvvuuUT+C3IC8vAKi1h0CoJGbE8MHdDY4IhGxB3Y7LFPqnty8Ak6csgwP6djWG2en+j/HsDzNPN0J6d6K7XtOE3/qAscTUmnf5tqVVUVEqqKqUxhuvvnmUpWjpW76KeY46Zm5AAwP70wTdxeDIxIRe6CeO6k2cSdTKSyyzEns3N7H4GiMN7Tf1aGZ6r0TEZHq9M3qEkMyR2hIpohYKLmTanM47rx1+6YOLQyMxD6UTO7WblFyJyIi1ePCpcts3BYPgK9PE/r01PqDImKh5E6qTfF8O4DOQUruAgO8uKm95XXYcyCR5NRMgyMSEZH64Lu1hygoLAIsyx84OurrnIhY6N1Aqs2R4ynWbfXcWZSsmrluS5yBkYiISH3x/dqD1m2tbSciJSm5k2pz5ErPXXOvRvg0czc4GvtgOzTzqIGRiIhIfZBw5hJ7DiYCcHOHFnQK0hx3EblK1TKl0uJahJf73EVHV1K6jAQg8HQCx1sOqK2walxFP/e1uAItOg/nvIs7MT/Hsdd3MN3P/VR9wYmISIMS9dMh6/adQ7sYGImI2CP13Em1OOHmYd1ul5NuYCT2xQTcnpEEQIGDIzuaNNyF3UVE5MaYzWa+XXPAuj96yM0GRiMi9kjJnVSLksldkJI7G33TE63bMR7+BkYiIiJ12eG488SdvABASPdWBPh6XOMMEWlolNxJtYi36blLMzAS+9MtK5UmBXkAbG/qS15egcERiYhIXfRdiUIqGpIpImVRcifVorjnzsFspk1uhsHR2BcnzPS5MjQz29GZbbtPGRyRiIjUNUVFZr5fZ5lv5+TowMhBnQ2OSETskZI7uWGFmEhwbQpAQG4mruYigyOyP7enJ1m3taC5iIhU1a79Z0hMtvzyNCy0Lc08VZVaREqrUnKXkJDAhQsXaioWqaPOuDYm38ERgHa5mm9Xlt6ZybgUFQKW5K6oyGxwRCIiUpd8t0ZDMkXk2qqU3AUFBfHnP//Zuv/oo4+ycOHCag9K6pYTriqmci1u5kJ6ZSYDcD41i18OJV7jDBEREYv8gkJWrT8CgJurE0NKrKEqIlJSlZI7s9lMUdHVIXeLFi1i8+bN1R6U1C3xbp7WbS2DUL6+JYdmbtbQTBERqZytO05yKT0bgCFhHWji7mJwRCJir6qU3Hl6enLqlIpBiC3bZRBUKbM8t2Uk4WC2DMdco+ROREQqqbiQCsAdQzQkU0TK51SVxrfeeivr1q3j//7v/wgKCgJg9+7dzJo165rnmkwmZs6ceX1Ril0rTu4aFebTMj/b4Gjsl2dhHl0vp7KvsQ/xpy5wPCGV9m28jQ5LRETsWHZOPms2HQXAo4kr4be1MzYgEbFrVUru/vGPfzBmzBj+/e9/W4/t3r2b3bt3X/NcJXf1U5aDE8kulopd7XLSMRkcj73rm57IvsY+AERvOsbjDyq5ExGR8v20NY7LOfkAjBjYGReXKn11E5EGpkrvEL179+bw4cNs376dU6dO8cgjj9C/f38mTpxYU/GJnSs5JFOVMq/t9vQk/uXfHYC1m4/y+IN9DI5IRETs2ar1h63bGpIpItdS5V//NGnShMGDBwPwyCOP0LFjRx5++OFqD0zqhuL17QDa5Wjx8mvxy7/MzR1acCjuPL8cSuLc+Qx8WzS99okiItLgZF7OY8PPxwHwaebOrT1aGxyRiNi7G+rbj4+Pp0mTJtUVi9RBJZO7Nuq5q5Sh/TtyKO48AOu2xvHbsT2NDUhEROzS+pg48vIta6RGDOiMo2OV6uCJSAN0Q+8Sbdu2xdtbc4YaspMlhmW2Uc9dpQzr38m6raqZIiJSnh9KDMkcOegmAyMRkbqiSj13lamKWR4VVKmfinvuPApy8SrMMziauuHmDi0I8PXg7Ll0tu1KID0zB48mbkaHJSIidiQzK5eN2+IBy5DMkO6tDI5IROqCKiV3f/3rXzGZTJivrNVVzGS6WiOx+LlfH1NyV/9kODpz0dmSlLTJVa9dZZlMJob178iny3dSUFjEhp/jGTNMk+RFROSqn2KOXx2SOVBDMkWkcqqU3H3yySeljm3dupV//etftGnThvvuu482bdoAkJCQwPLlyzl58iSTJk0iLCyseiIWu2Ez305DMqtkWP9OfLp8J2CpmqnkTkRESrIZkjlQQzJFpHKqlNz9uirmzz//zOOPP87MmTN56aWXcHR0tHl+zpw5/O1vf+Mf//gHjzzyyA0HK/alZHLXVj13VdK7eyu8PBpxKT2bjf+LJzevAFetXSQiIliGZG76n2VIZovmjTUkU0Qq7Yb6+F966SVuuukmXnnllVKJHYCjoyN//etfuemmm3j55Zdv5FZih0omd4FK7qrEydGBwWHtAbicnc/POxMMjkhEROzFT1vjNCRTRK7LDb1b/O9//yM4OPia7YKDg/nf//53I7cSO1SyUmbbHC2DUFXD+pWsmnnUwEhERMSerLIZktnZwEhEpK654V8FHTp0qFraSN1zSpUyb0hYaFvcXC1DMddtjaOwsMjgiERExGiZWbls2n4CgBbejekdrCGZIlJ5N5Tc9e/fn927d/PGG2+U2+af//wnu3bton///jdyK7EzGQ7OXFClzBvSyM2Z/re2AyD14mX2HEg0NiARETHcuq1x5F8ZkjlCC5eLSBXdUAWH1157jfXr1/Pcc8/xySefWKtlmkwmTp48yfLlyzl06BDu7u689tpr1RWz2IEEN1XKrA5D+3W0LmS+ZstRemvSvIhIg6aFy0XkRtxQcnfLLbewdu1aHnnkEQ4dOsSrr75qXd+ueL27zp07s2jRIm655ZYbj1bshs0yCOq5u26D+nbA0cFEYZGZNZuO8efHB9qsESkiIg1HRqaGZIrIjbnh2ut9+vThwIED/PTTT2zZsoWzZ89iNpsJCAigf//+DB48WF9W6yEld9WjmWcjQnu0ZtuuUyScvcTREyl0DmphdFgiImKAdVuPWYdkjhx4Ew4O+v4kIlVTLQO5TSYTQ4YMYebMmbz++uu88cYbvPTSSwwZMuS6E7t58+YRFBSEm5sbISEhbNq0qcL2GzZsICQkBDc3N9q3b88HH3xQqs3y5cvp2rUrrq6udO3alRUrVtg8v3HjRsaMGUNAQAAmk4mvv/661DXMZjN//etfCQgIoFGjRgwaNIj9+/fbtMnNzeXJJ5/Ex8eHxo0bc9ddd3H69Omqvwh2rOSwTFXKvDFDS1TNXHtliKaIiDQ8P2w4Yt0eOUhVMkWk6qolufvuu+8YNWoUnp6eeHl54eXlhYeHB6NGjeLbb7+t8vWWLVvGlClTeOGFF9i1axfh4eGMGjWKhISy1wKLj49n9OjRhIeHs2vXLp5//nmeeuopli9fbm0TExNDZGQkEyZMYM+ePUyYMIHx48ezbds2a5usrCx69OjBe++9V25sr7/+Om+99Rbvvfce27dvx8/Pj+HDh5ORcbX3asqUKaxYsYKlS5eyefNmMjMzufPOOyksLKzya2GvElwtyyB4FOTiqUqZN2Rovw7W7TVK7kREGqSMzFw2XxmS2dKnCb26aUimiFSdyVw8Oe46mM1mHnvsMRYtWmSdY+fl5YXZbCYtLc1yA5OJCRMm8Mknn1S6F69Pnz707t2b+fPnW4916dKFcePGMXv27FLtn332WVauXMnBgwetxyZPnsyePXuIiYkBIDIykvT0dFatWmVtM3LkSJo1a8aSJUtKXdNkMrFixQrGjRtn8/MGBAQwZcoUnn32WcDSS+fr68ucOXN4/PHHSUtLo0WLFnz22WdERkYCcPbsWQIDA4mKimLEiBGVeg3S09Px9PQkLS0NDw+Pa59QC+JahAOWSpn3dx0NQHBWCnPitxgZVp3T4XzpXuh7fv8pB44mA/DTst/j39I+/s5FGiJ7fP+1F3ptas7K6AP85bUoACbc05sXnhxicEQiYk8q+/57Qz1377zzDp988gn+/v7Mnz+ftLQ0Lly4wMWLF0lLS2P+/Pn4+/vz2Wef8c4771Tqmnl5ecTGxhIREWFzPCIigq1bt5Z5TkxMTKn2I0aMYMeOHeTn51fYprxrliU+Pp6kpCSb67i6ujJw4EDrdWJjY8nPz7dpExAQQHBwcIX3ys3NJT093eZhr06pUma1G9qvo3V77Rb13omINDTRm45atyMGdKqgpYhI+W4oufvoo49wd3dn06ZNPP744zRtevVLf9OmTXn88cfZtGkTjRo14qOPPqrUNVNSUigsLMTX19fmuK+vL0lJSWWek5SUVGb7goICUlJSKmxT3jXLu0/xeeVdJykpCRcXF5o1a1ale82ePRtPT0/rIzAwsNJx1baTKqZS7Yb1v/pBXvIDXkRE6r+c3Hw2b48HoLlXI1XJFJHrdkPJXXx8PEOHDiUoKKjcNkFBQQwdOpT4+PgqXfvXQzjNZnOFwzrLav/r41W9ZnXFVpk2M2bMIC0tzfo4depUleOqLaqUWf06t/chMMATgO17TnPh0mWDIxIRkdqyZftJsnMKAMtIDi1cLiLX64bePVq0aIGLi8s127m4uODj41Opa/r4+ODo6Fiqlys5OblUj1kxPz+/Mts7OTnh7e1dYZvyrlnefYAKr+Pn50deXh4XL16s0r1cXV3x8PCwedgrLWBe/UwmEyMGWCqjFRWZNTRTRKQBWb3papXMkiM5RESq6oaSu7vvvpt169aVSmRKunDhAuvWrbMpTFIRFxcXQkJCiI6OtjkeHR1NWFhYmef07du3VPvVq1cTGhqKs7NzhW3Ku2ZZgoKC8PPzs7lOXl4eGzZssF4nJCQEZ2dnmzaJiYns27evSveyZyUrZXoV5hocTf0xYuDVstc/liiHLSIi9Vd+QSHrY44D0Njdhb692xgckYjUZTeU3L366qu0b9+eIUOGsG7dulLPr1u3juHDh9O+fXtee+21Sl932rRpfPzxxyxcuJCDBw8ydepUEhISmDx5MmAZwvjQQw9Z20+ePJmTJ08ybdo0Dh48yMKFC1mwYAHTp0+3tnn66adZvXo1c+bM4dChQ8yZM4c1a9YwZcoUa5vMzEx2797N7t27Acuw0927d1uXYDCZTEyZMoXXXnuNFStWsG/fPh555BHc3d154IEHAPD09GTixIk888wzrF27ll27dvG73/2O7t27M2zYsEq/BvYqw8GZC85ugGVIppZXrT7BN/kR4GvpFf15ZwJpGTkGRyQiIjVtx57T1vf7gbe3x8XFyeCIRKQuu6F3kLFjx+Li4kJsbCzDhw+nefPmtG3bFoCEhARSU1MBuP322xk7dqzNuSaTibVr15Z53cjISFJTU5k1axaJiYkEBwcTFRVlvXZiYqLNmndBQUFERUUxdepU3n//fQICAnj33Xe59957rW3CwsJYunQpL774IjNnzqRDhw4sW7aMPn36WNvs2LGDwYMHW/enTZsGwMMPP8yiRYsA+Mtf/kJ2djZPPPEEFy9epE+fPqxevdqmmMzbb7+Nk5MT48ePJzs7m6FDh7Jo0SIcHR2r/BrbG1XKrDkmk4nh4Z3595exFBQWsW7LMe4eGWx0WCIiUoNKFtEa3r9jBS1FRK7thta5c3C4/o4/k8lUrxb1rm72uJZQXItwVjVry3utegIw+ewvjLlQtUI5UvY6d8V27jvDA09a1l0c1Lc9H7x2T22FJSJX2OP7r73Qa1O9iorMDIr8kOSUTFycHdn69R9p4n7tWgYi0vBU9v33hnruqloBU+q+U6qUWaN6dg2gpU8TklMy2bLjJJlZuTRp7Gp0WCIiUgP2HkoiOSUTgL4hbZXYicgNu6HkrniYpDQcJzUss0Y5OJiICO/E5yt2kZ9fyE8xxxkzrIvRYYmISA1Ys7nEwuXhqpIpIjdOC6lIlahSZs2LGHC1aubqjaqaKSJSH5nNZlZfmW/n4GBicFgHgyMSkfpAyZ1UWslKmYGqlFljQrq3wruZOwAbt8WTlZ1ncEQiIlLdjp1I5eRpy1JSId1b0dzL3eCIRKQ+UHInlVayUmZbDcmsMY6ODgy/MjwnN6+AjT8fNzgiERGpbiWHZA4P71xBSxGRylNyJ5WWUKKYSqCKqdSoETZDM49W0FJEROqikksgDNMSCCJSTZTcSaWVTO7aKrmrUbf2DMTLoxEAG34+TnZOvsERiYhIdTmdlMaBo8kAdOvsS4CvlpUQkeqh5E4qTZUya4+To4P1N7mXc/LZvP2EsQGJiEi1Wbv5mHV7uKpkikg1UnInlVa8xl3TgjxVyqwFIwaqaqaISH1UckimkjsRqU5K7qRS0jNzSHW2DBNsk5uuSpm1oE+vNng0sSxgvm5rHHl5BQZHJCIiNyr1Yhaxe08DEBTYnA5tvQ2OSETqEyV3UinH4lOt26qUWTtcnB2t6x5lXc5j846TBkckIiI3at3WOMxmy/awcBVSEZHqpeROKuXYyavJnSpl1p6Rg26ybv+w/rCBkYiISHVYU3JIZn8NyRSR6qXkTirl2IkU67YqZdaefqHtrEMz12w+Sk6uqmaKiNRVmVm5bN2ZAIBfi6YE3+RncEQiUt8ouZNKUc+dMVycHa2T7S9n57Ph53iDIxIRkeu1YVs8+fmFAAzt3xEHB81gF5HqpeROKuXYCUty17Qgj2YFqpRZm0YPudm6HfXTIQMjERGRG6EhmSJS05TcyTWlZ+aQnJIJqFKmEfr0akNzL0ul0vUxx8m8nGdwRCIiUlW5eQVs2HYcAE8PN0J7tDY4IhGpj5TcyTUV99oBtNGQzFrn5OjAyIGWwiq5eQX8tOXYNc4QERF7szX2JJezLfOmh4R1wMlRX8FEpPrpnUWuySa50zIIhig5NPN7Dc0UkSvmzZtHUFAQbm5uhISEsGnTpkqdt2XLFpycnOjZs2fNBihWGpIpIrVByZ1cU8lKmeq5M0bv4Fb4+jQBYMv2E6Rl5BgckYgYbdmyZUyZMoUXXniBXbt2ER4ezqhRo0hISKjwvLS0NB566CGGDh1aS5FKQWER67bGAeDu5kxYaFuDIxKR+krJnVxTyUqZSu6M4eBgsq55l19QZPMbYBFpmN566y0mTpzIY489RpcuXZg7dy6BgYHMnz+/wvMef/xxHnjgAfr27VtLkcrOvWe4mJYNQHifINxcnQ2OSETqKyV3ck2qlGkf7tDQTBG5Ii8vj9jYWCIiImyOR0REsHXr1nLP++STT4iLi+Pll1+u1H1yc3NJT0+3eUjVRZf4hdwwDckUkRqk5E4qZFspM0OVMg3U/WY/Wvt7AvDzzgRSL2YZHJGIGCUlJYXCwkJ8fX1tjvv6+pKUlFTmOUePHuW5555j8eLFODk5Veo+s2fPxtPT0/oIDAy84dgbGrPZzNotluTO2cmBQbe3NzgiEanPlNxJhWwrZeo3tkYymUyMHmzpvSsqMvPjhiMGRyQiRjOZbH/lZjabSx0DKCws5IEHHuCVV16hc+fOlb7+jBkzSEtLsz5OnTp1wzE3NPuPnOPsOcuUhtt7t6FpE1eDIxKR+qxyv7qTBkuVMqtfXIvw6z73FlcP6DQYgOWvLaPPpKcA6HC+chXyRKR+8PHxwdHRsVQvXXJycqnePICMjAx27NjBrl27+NOf/gRAUVERZrMZJycnVq9ezZAhQ0qd5+rqiqurkpEboSGZIlKb1HMnFYpTMRW70i43ncArSfb+xj6cd3YzOCIRMYKLiwshISFER0fbHI+OjiYsLKxUew8PD/bu3cvu3butj8mTJ3PTTTexe/du+vTpU1uhNzhrNluSO5MJhvbraHA0IlLfqedOKnRUyyDYFRMwIO00i926ALDRszX3pmhRc5GGaNq0aUyYMIHQ0FD69u3LRx99REJCApMnTwYsQyrPnDnDp59+ioODA8HBwTbnt2zZEjc3t1LHpfocT7hA3MkLAPTq1gqf5o0NjkhE6jsld1Kh4mGZnk3dVCnTTgxKO8NiX0tyt85LyZ1IQxUZGUlqaiqzZs0iMTGR4OBgoqKiaNvWsoZaYmLiNde8k5pV3GsHMDxcQzJFpOZpWKaUq2SlzI7tvFUp004E5GVx82XLb4JPuHkS7+phcEQiYpQnnniCEydOkJubS2xsLAMGDLA+t2jRItavX1/uuX/961/ZvXt3zQfZgJWcbzc8XEMyRaTmKbmTcpUsptKxnY+BkcivDb50tWLdOq/WBkYiIiJlSTqfwd5DloI3N3doQWt/L2MDEpEGQcmdlKtkctehrbeBkcivDUg7g6O5CIANXq0pLCwyOCIRESmp5JDMYRqSKSK1RMmdlKtkpcxO7ZTc2ROPwnxCM84BkOrciG27tfaUiIg9sR2SqeRORGqHkjspV8lKmR2DNCzT3gwpMTRzZfQBAyMREZGSLqZls2PPaQDaBHjRWZ+hIlJLlNxJuayVMj3c8GnmbnA08mu3ZZyjcWE+AKs3HiE7J9/giEREBOCnmDgKi8wADAvviMmkkmQiUjuU3EmZbCpltvXWB5MdcjEX0T/tDACXs/NZu0VLIoiI2IM1NkMyOxsYiYg0NErupEyqlFk3DLl02rqtoZkiIsbLys5j8/YTALTwbkyPLv7GBiQiDYrdJnfz5s0jKCgINzc3QkJC2LRpU4XtN2zYQEhICG5ubrRv354PPvigVJvly5fTtWtXXF1d6dq1KytWrKjyfU0mU5mPN954w9pm0KBBpZ6///77r/OVMIZtcqdiKvaq6+VUWuRdBmDL9hOkXMgyOCIRkYZt0//iycsvBGBov444OGjki4jUHrtM7pYtW8aUKVN44YUX2LVrF+Hh4YwaNYqEhIQy28fHxzN69GjCw8PZtWsXzz//PE899RTLly+3tomJiSEyMpIJEyawZ88eJkyYwPjx49m2bVuV7puYmGjzWLhwISaTiXvvvdcmpkmTJtm0+/DDD6v5VapZx0oUU+mknju75QAMvtJ7V1hkJmrdIWMDEhFp4NZsujpEflh/VckUkdplMpvNZqOD+LU+ffrQu3dv5s+fbz3WpUsXxo0bx+zZs0u1f/bZZ1m5ciUHDx60Hps8eTJ79uwhJiYGgMjISNLT01m1apW1zciRI2nWrBlLliy5rvsCjBs3joyMDNauXWs9NmjQIHr27MncuXOv7wUA0tPT8fT0JC0tDQ8Pj+u+zvV6dPoXbI09CcDm5X/Ap3lj4lqE13occm0Jrk34Q6ehAHTt1JKvPnrI4IhE6jaj33/tmV6biuXlFxJ29/tkZuXh0cSVzV89gYuzo9FhiUg9UNn3X7vrucvLyyM2NpaIiAib4xEREWzdurXMc2JiYkq1HzFiBDt27CA/P7/CNsXXvJ77njt3ju+//56JEyeWem7x4sX4+PjQrVs3pk+fTkZGRgU/NeTm5pKenm7zMNKxk1crZXqrUqZda5ObSfeb/QA4cDSZg8eSDY5IRKRh2rYrgcysPAAG9e2gxE5Eap3dJXcpKSkUFhbi6+trc9zX15ekpKQyz0lKSiqzfUFBASkpKRW2Kb7m9dz33//+N02bNuWee+6xOf7ggw+yZMkS1q9fz8yZM1m+fHmpNr82e/ZsPD09rY/AwMAK29ekkpUyO7XzUaXMOuDeUcHW7a9W7TMwEhGRhqvkwuXD+nc0MBIRaajsLrkr9uuEwmw2V5hklNX+18crc82q3HfhwoU8+OCDuLm52RyfNGkSw4YNIzg4mPvvv58vv/ySNWvWsHPnznLjnzFjBmlpadbHqVOnym1b047Fq5hKXTN6yM24ujgBsHLNAfLyCgyOSESkYSksLGLdlSVpXF2c6H9rO2MDEpEGye6SOx8fHxwdHUv1liUnJ5fqVSvm5+dXZnsnJye8vb0rbFN8zared9OmTRw+fJjHHnvsmj9T7969cXZ25ujRo+W2cXV1xcPDw+ZhlKMliqkouasbPJq4ETHAMnE/LT2HdVvjDI5IRKRh2X3gLCkXLdWLw29rh3sjF4MjEpGGyO6SOxcXF0JCQoiOjrY5Hh0dTVhYWJnn9O3bt1T71atXExoairOzc4Vtiq9Z1fsuWLCAkJAQevTocc2faf/+/eTn5+PvXzfWuok7WaLnrq0qZdYV947qbt1evmqvgZGIiDQ8tkMyVSVTRIzhZHQAZZk2bRoTJkwgNDSUvn378tFHH5GQkMDkyZMByxDGM2fO8OmnnwKWypjvvfce06ZNY9KkScTExLBgwQJrFUyAp59+mgEDBjBnzhzGjh3LN998w5o1a9i8eXOl71ssPT2dL774gjfffLNU7HFxcSxevJjRo0fj4+PDgQMHeOaZZ+jVqxf9+vWriZer2mmNu7rptp6BtPLz4ExSOpu3nyAxOR3/lqpmJyJS08xmM2s2W4ZkOjqYGNS3vcERiUhDZZfJXWRkJKmpqcyaNYvExESCg4OJioqibdu2gGWtuZJrzwUFBREVFcXUqVN5//33CQgI4N1337VZey4sLIylS5fy4osvMnPmTDp06MCyZcvo06dPpe9bbOnSpZjNZn7729+Wit3FxYW1a9fyzjvvkJmZSWBgIHfccQcvv/wyjo51o2pW8bBML49GqpRZhzg4mLhnZDD/b9FWzGb4ZvUBJv/udqPDEhGp9w7Fned0Yhpg+UWbl0cjgyMSkYbKLte5E+PWEkrLyKHPXe8BEHpLaz5/537rc1rnzn51OL8JgDNJaQx74F+YzRAY4MmPnz2Gg4OqnYpUhdZyK59em7K9u3Az8z77GYCXpwzjt2N7GhuQiNQ7dXadOzFWnIZk1mmt/DzpG2LpaT51No0dv5w2OCIRkfov+sqQTIAh/bQEgogYR8md2FClzLpPhVVERGpP/KkLHI23fHb27BaAr08TgyMSkYZMyZ3YsC2mokqZddGw/h3xaOIKwI8bjpCemWNwRCIi9deazVerZA4PV5VMETGWkjuxcaxEz10n9dzVSa4uTowZ3hWAnNwCvll9wOCIRETqr+iNJZI7LYEgIgZTcic2jl1Z487LoxHNvVQps66KHHOLdfu/3+5BdZNERKpf0vkMfjmUBMDNHVrQppWXsQGJSIOn5E6s0jJyOJ+aBVjm25lMqrJYV3UOakFI91YAHD2Rys59ZwyOSESk/ik5JHOYhmSKiB1QcidWGpJZv9w/pod1e+nKPQZGIiJSP0Vv0nw7EbEvdrmIuRjjaLyKqdQnEQM78/f3fuJSejY/bDjC838aTDPP+jPUtibWXSxeL1BE5Foupl1m+x7LcjNtW3nROUifmyJiPCV39VhVv/zu9AsGnw4ANJo6i7jfp1zjDLFnri5O3D2yG5/8dwf5+YV89cN+JkbeanRYIiL1wrqtcRQVWeYzDw/vpKkMImIXNCxTrE66XV3tvm1OuoGRSHUZf6dtYZXiLyIiInJjSg7J1Hw7EbEXSu7E6qRrUwA8CnLxKswzOBqpDkGBzenbuw0AJ89cYtuuBIMjEhGp+zIv57Flx0kAWvo04Zab/Q2OSETEQsmdAJDm6MIlZzcA2qnXrl6JvKtEYZVvVVhFRORGbfz5OPn5hQAM698RBwcNyRQR+6DkTgA4UWJIppK7+mVov460aN4YgLWbj3EuJdPgiERE6raSSyBEhHc2MBIREVtK7gT4VXKXq+SuPnF2cuTe0d0BKCgsYunK3cYGJCJSh+XmFbD+5+MAeHq4EdqjtcERiYhcpeROADjhWrKYSoaBkUhN+O1dPXBytPx3X/btHnLzCgyOSESkbtoae5LL2fkADAnrYH1vFRGxB3pHEsC2566teu7qHd8WTYkYaBk6dOFSNt+vO2RwRCIidVP0xpILl2tIpojYFyV3QhGQcKVSpl9eFo2KCo0NSGrEhHt6W7c//2onZrOWRRARqYqCwiLWbY0DwN3NmX6hbQ2OSETElpI74ZyLOzmOlvXsVUyl/urZ1Z/uN/sBcOBoMrF7zxgckYhI3bLjl9NcSs8GYECfIFxdnAyOSETElpI7sZlvp+Su/jKZTDa9d58ujzUwGhGRumf1hiPWbS1cLiL2SMmdaBmEBmTkoJusyyKs2XyMs+f09y0iUhmFhUWs3mhJ7lycHRnUt4PBEYmIlKbkTlRMpQFxcXa0LmpeVGTmP1/vMjgiEZG6IXbvGVIuXgYsQzKbuLsYHJGISGlK7sQ6LNO5qJBWuVkGRyM17f4xPXB2svzX/+L7vVzOzjM4IhER+/fDhsPW7REDbzIwEhGR8im5a+DyTA6cdbUM0wvMzcARVVCs73yaN2b04JsBSMvIYfmqfQZHJCJi3woLi6xLILg4OzI4TEMyRcQ+Kblr4E65NqXIZPln0E6LlzcYj0beat1e9MUOCgqLDIxGRMS+7dx3hvMXLCNbwm/TkEwRsV9K7ho4m2Iqmm/XYNzUoQXht7UD4ExSOj+WqAAnIiK2Sr5HjhyohctFxH4puWvgTlxZvBygrSplNigTI2+zbi9Yul2LmouIlKGoyMzqTZYhmc6qkikidk7JXQOnZRAarj69AunW2ReAA0fP8fPOBIMjEhGxP7v2nyE5JROA/re2o2kTV4MjEhEpn5K7Bu7kleSuSUEe3gU5BkcjtclkMvHY/Vfn3n28dLuB0YiI2Kcf1mtIpojUHUruGrAMR2dSnRsBlvl2JoPjkdo3fEBnAgM8Adiy4wSHjiUbHJGIiP0oKjLz45WFy52dHRkS1tHgiEREKqbkrgErXt8ONCSzoXJydOCR+0Kt++q9ExG5avf+s9Yhmf1C22pIpojYPSV3DdjxRp7W7SAldw3WPaOC8fKw9OCu+ukQCWcuGRuQiIidKLlw+UgtXC4idYCSuwbsuNvV5K59TpqBkYiRGrk58/B9vQEoLDLz0X+2GRyRiIjxiorMrL6ycLmzkwND+qlKpojYPyV3DdjxK8VUHMxmLYPQwP3u7t40bWwZbvT1j/s5naRkX0Qatj0HE0k6nwFAWGg7PJq4GRyRiMi1KblroPJNJhKuzLlrnZuBq7nI4IjESE2buDLhXkvvXUFhEf/6z/8MjkhExFjfrz1o3VaVTBGpK+w2uZs3bx5BQUG4ubkREhLCpk2bKmy/YcMGQkJCcHNzo3379nzwwQel2ixfvpyuXbvi6upK165dWbFiRZXv+8gjj2AymWwet99+u02b3NxcnnzySXx8fGjcuDF33XUXp0+fvo5Xoeaccm1KgYPlr19DMgXgoXt709jdBYCvVu0lMVm9uSLSMBUUFvHDest8OxdnR4b172RwRCIilWOXyd2yZcuYMmUKL7zwArt27SI8PJxRo0aRkFD2Isvx8fGMHj2a8PBwdu3axfPPP89TTz3F8uXLrW1iYmKIjIxkwoQJ7NmzhwkTJjB+/Hi2bbs6v6iy9x05ciSJiYnWR1RUlM3zU6ZMYcWKFSxdupTNmzeTmZnJnXfeSWFhYTW+SjfGdr6dvsQLeHk04nd39wIgv6BIlTNFpMH63+5TpFy8DMDA29urSqaI1Bl2mdy99dZbTJw4kccee4wuXbowd+5cAgMDmT9/fpntP/jgA9q0acPcuXPp0qULjz32GI8++ij//Oc/rW3mzp3L8OHDmTFjBjfffDMzZsxg6NChzJ07t8r3dXV1xc/Pz/po3ry59bm0tDQWLFjAm2++ybBhw+jVqxeff/45e/fuZc2aNdX7Qt0Am+QuWz13YvHIb0Jwd3MG4IvvfiE5NdPgiEREal/JIZl3DL3ZwEhERKrG7pK7vLw8YmNjiYiIsDkeERHB1q1byzwnJiamVPsRI0awY8cO8vPzK2xTfM2q3Hf9+vW0bNmSzp07M2nSJJKTry78HBsbS35+vs11AgICCA4OLjd+sAzlTE9Pt3nUpOJiKqBhmXJVM093fju2JwB5+YUsUO+diDQweXkF1iqZjd1dGHR7e4MjEhGpPCejA/i1lJQUCgsL8fX1tTnu6+tLUlJSmeckJSWV2b6goICUlBT8/f3LbVN8zcred9SoUfzmN7+hbdu2xMfHM3PmTIYMGUJsbCyurq4kJSXh4uJCs2bNKh0/wOzZs3nllVfKfb46mbm6xp13fjaehXm1cl+pOXEtwqvtWoMdXVnc805ycgtY8s1uHvlNCP4tPa59oohIPbDpfyfIyMoFYFi/jri5OhsckYhI5dldz10xk8lks282m0sdu1b7Xx+vzDWv1SYyMpI77riD4OBgxowZw6pVqzhy5Ajff/99hT/PteKfMWMGaWlp1sepU6cqvN6NOO/ciCxHS+EMDcmUX2tWmGude5eXX8i8T382OCIRkdrz/ToNyRSRusvukjsfHx8cHR1L9XIlJyeX6lUr5ufnV2Z7JycnvL29K2xTfM3ruS+Av78/bdu25ejRo9b75OXlcfHixSpdx9XVFQ8PD5tHTYnT4uVyDRPvv40mja9Wzow/dcHgiEREal5Wdh7rtsYBliJTfUPaGhyRiEjV2F1y5+LiQkhICNHR0TbHo6OjCQsLK/Ocvn37lmq/evVqQkNDcXZ2rrBN8TWv574AqampnDp1Cn9/fwBCQkJwdna2uU5iYiL79u2r8Dq1KV7JnVxDM89GPDr+VgAKi8z8v0XlzxcVEakv1m0+Rk5uAQAjB3XG2cnR4IhERKrG7pI7gGnTpvHxxx+zcOFCDh48yNSpU0lISGDy5MmAZQjjQw89ZG0/efJkTp48ybRp0zh48CALFy5kwYIFTJ8+3drm6aefZvXq1cyZM4dDhw4xZ84c1qxZw5QpUyp938zMTKZPn05MTAwnTpxg/fr1jBkzBh8fH+6++24APD09mThxIs888wxr165l165d/O53v6N79+4MGzasFl69ayuebwdaBkHK99B9ITT3agRA1LpDHDyWfI0zRKS2VWVN2K+++orhw4fTokULPDw86Nu3Lz/++GMtRmv/vlt3yLp9xxANyRSRuscuk7vIyEjmzp3LrFmz6NmzJxs3biQqKoq2bS3DIxITE23WngsKCiIqKor169fTs2dP/va3v/Huu+9y7733WtuEhYWxdOlSPvnkE2655RYWLVrEsmXL6NOnT6Xv6+joyN69exk7diydO3fm4YcfpnPnzsTExNC0aVPrdd5++23GjRvH+PHj6devH+7u7nz77bc4OtrHbwCLK2U2KizALy/L4GjEXjVxd+HxB2+37s9dsNnAaETk16q6JuzGjRsZPnw4UVFRxMbGMnjwYMaMGcOuXbtqOXL7dDEtmy3bTwDg16IpId1bGxuQiMh1MJmLK4+IXUlPT8fT05O0tLTrnn9XVgXFTAcnIrveAUDXrFTeiNcXdimtw3nLb/9z8woYOWEBickZACx+9367+cJTnRVCixX/3NKwVcf7b23o06cPvXv3tlmLtUuXLowbN47Zs2dX6hrdunUjMjKSl156qVLt68prcz2WfbuHl9+yTKl4NDKUv0weZGxAIiIlVPb91y577qTmxDXysm5rvp1ci6uLE3986Opc0dc/2IB+HyRivOtZE/bXioqKyMjIoHnz5uW2qe01WI30zeoD1u07hnQxMBIRkeun5K6BOVaimErH7EvGBSJ1xriR3ejY1lJ1ds+BRFb9dNjgiETketaE/bU333yTrKwsxo8fX26b2bNn4+npaX0EBgbeUNz2KuHMJXbuOwNAp3bedO3U0uCIRESuj5K7BuZYiZ67TkrupBKcHB34yx8GWvf/+dFGcvMKDIxIRIpVdU3YYkuWLOGvf/0ry5Yto2XL8hOZ2lyD1UjfRO+3bo+N6Fap11BExB4puWtgjl5J7lyLCgjMzTQ2GKkzwm8Lol9oOwDOnkvn0+WxxgYk0sBd79qsYCnEMnHiRP773/9es4pzba7BapSiIrN1SKaDg4kxw7saHJGIyPVTcteAZDg4k+jaBID22Wk4orlTUjkmk4m//GEgDg6W32Z/8Pk2Ui+q0qqIUa53bdYlS5bwyCOP8J///Ic77rijpsOsE3buO8PpRMsc9L692+Lr08TgiERErp+SuwZEQzLlRtzUvgX3je4OQNblPC1sLmKwqq4Ju2TJEh566CHefPNNbr/9dpKSkkhKSiItrWEX1/r6x6tDMsdFqNdOROo2JXcNyNGSyV3OJcPikLrrqf/rh3sjZwD++90vHI47b3BEIg1XVdeE/fDDDykoKOCPf/wj/v7+1sfTTz9t1I9guJzcfFattxSJcm/kzLDwTgZHJCJyY5yMDkBqT8meu47ZDfs3tXJ9fJo35vEHb+ftjzdRVGRm1jtr+Pyd+1V8QMQgTzzxBE888USZzy1atMhmf/369TUfUB2zdkscWZfzABg58CYauTkbHJGIyI1Rz10DUtxz51ZYQKvcDGODkTrrkd+E0LaVFwCxe8/YrA0lIlKXfP3jPuv22BEakikidZ+SuwYizdGFZBd3ADrkXMLR4Hik7nJ1ceLFp4Za99/4cAPpmTkGRiQiUnXJqZls2XESgABfD269pX6u4SciDYuSuwbiqIqpSDUKvy2I4VfmpqRevMw7C7cYHJGISNWs+GE/RUWWqtFjI7paqwGLiNRlSu4aCFXKlOr2/J8G08jNMm13yTe72X/knMERiYhUTlGRmeVRe63794wMNjAaEZHqo+SugVAxFalu/i09eOKhvoDli9KsuWsoLCwyOCoRkWv73+5TJJy9BEBYSFsCA7wMjUdEpLoouWsAzMCRK8ldo8J8AvIyDY1H6o+H7wulfZvmAOw5mMjir3cbG5CISCV88f0v1u3i9TtFROoDJXcNwHnnRqQ6NwLgpuyL+kuXauPi7Mgr04Zb99/+eCOnk9QzLCL262JaNqs3HQXAy6MRw/p3NDgiEZHqo+/5DcDhRs2s2zdfvmhgJFIf3dojkN/e1QOA7JwCXnpzNWaz2eCoRETKtjL6APn5hQCMG9EVFxct+Ssi9YeSuwbgoHtz6/bNly8YGInUV8/8fgB+LZoCsHXHSVb8uN/giERESjObzXxZYkjmb+64xcBoRESqn5K7BuCw+9Weu5uy1XMn1a9JY1f+OnWYdf8f7//E+QtZBkYkIlLa7gOJHD2RCkDv4FZ0aOttcEQiItVLyV09l29y4JibJwCtcjPxKMw3OCKprwb17cCYYV0ASM/M5WUNzxQRO/Pf7/ZYt++7Q4VURKT+UXJXz8W5eVLg4AhoSKbUvOf/NJjmXpbiPeu2xvFliXWkRESMdDHtMt+vPQSARxNXRg7sbHBEIiLVT8ldPXdIQzKlFjXzdOfV6SOs+7Pf+4mTZ/TvTkSM92XUXvKuFFK5Z1Qw7o1cDI5IRKT6Kbmr5w6pmIrUsiH9OvKbK8OdLufk8+zsVRRocXMRMVBhYRFLvtlt3f/t2J6GxSIiUpOU3NVzh64sg+BWWEC7nAyDo5GG4rk/DqZNgBcAu/ef5V//2WZsQCLSoK2POc7Zc5bPwAF9gmjbqtk1zhARqZuU3NVjqU5unHdxB6BT9kUcUXELqR2NG7kw5/nRODiYAHj/3zHsOZBocFQi0lAt/nqXdfvBcb0MjEREpGZp5c567EDJIZmabydVENci/Iav4QGMb3kzS1veREFhEVNnreSrjx7Cy6PRjQcoIlJJcSdT2Rp7EoDAAE/CbwsyOCIRkZqjnrt6bF/jq+v3BGelGhiJNFS/TT5M1yv/9s6ey2DGnB+0PIKI1Kr/lJhr98DYXtYRBSIi9ZGSu3psv7sluXMwm+miYipiACfMPHtqBx4FuQD8tDWOT77YYXBUItJQXErP5qtVliVZ3FyduGdUsMERiYjULCV39VRaRg4n3DwACMpJo3FRgcERSUPlU5DDM6d3Wvff+mgTu/afNTAiEWkolq7cQ3aO5fPvnlHBeDZ1MzgiEZGapeSuntq57wxmk2XoiYZkitFCM5P5/QN9ACzz7175lpQLWQZHJSL1WW5eAZ9/ZfnFkoODiUfuCzU4IhGRmqfkrp7asee0dVvJndiDpx7tR+gtrQFIOp/BUy+vtC4oLCJS3VZGHyDl4mUAhod3ok0rL2MDEhGpBUru6qkdv1xN7rpdVnInxnNydOCtl+7E16cJYOld/ts7a1VgRUSqXVGRmYXLrs7vfXT8rQZGIyJSe5Tc1UNZ2XnsP3IOgDY56XgW5hkckYhFS+8mvPe3sbg4OwLwxfe/sHTlHoOjEpH6Zv3Px4k/ZSkkFnpLa3p09Tc4IhGR2qHkrh7acyCRgsIiQEMyxf50v9mfV/88wrr/9/+3jm27EwyMSETqE7PZzEf/2WbdfzRSvXYi0nAouauHduw5Zd3WkEyxR3cN78qjkZbiBgWFRTz10kriTurfqojcuJidCey+UpG3Y1tvBt3e3uCIRERqj5K7eqixuwttArwA9dyJ/Xpm0gAG9AkCLEt3THp2OedVQVNEboDZbOb9f2+17v/hob5atFxEGhS7Te7mzZtHUFAQbm5uhISEsGnTpgrbb9iwgZCQENzc3Gjfvj0ffPBBqTbLly+na9euuLq60rVrV1asWFGl++bn5/Pss8/SvXt3GjduTEBAAA899BBnz9qu2TVo0CBMJpPN4/7777/OV6LqJt5/G6sXP8Znh37ApyCn1u4rUhWOjg689dIYunZqCcDZc+k8/txXZGVrjqiIXJ9tu04Ru/cMAO3bNGfkwM4GRyQiUrvsMrlbtmwZU6ZM4YUXXmDXrl2Eh4czatQoEhLKnpcTHx/P6NGjCQ8PZ9euXTz//PM89dRTLF++3NomJiaGyMhIJkyYwJ49e5gwYQLjx49n27ar4/Kvdd/Lly+zc+dOZs6cyc6dO/nqq684cuQId911V6mYJk2aRGJiovXx4YcfVvOrdG3NC3Jr/Z4iVdHE3YUPZt9DgG9TAA4cPceUv64kv0BLJIhI1b3/aYleuwl9cXS0y685IiI1xmS2wzrkffr0oXfv3syfP996rEuXLowbN47Zs2eXav/ss8+ycuVKDh48aD02efJk9uzZQ0xMDACRkZGkp6ezatUqa5uRI0fSrFkzlixZcl33Bdi+fTu33XYbJ0+epE2bNoCl565nz57MnTv3ul+D9PR0PD09SUtLw8PD47quEdci/LrvL1LdOpwvv/c97mQqv/3Tf0jPtPxCYsywLsyZMbrC4VQ18e+7ohil4aiO99/6yp5fm//tPsVDU5cB0C6wGd9/8n9K7kSk3qjs+6/dvevl5eURGxtLRESEzfGIiAi2bt1a5jkxMTGl2o8YMYIdO3aQn59fYZvia17PfQHS0tIwmUx4eXnZHF+8eDE+Pj5069aN6dOnk5GRUf4PDeTm5pKenm7zEGkoOrT15v1Xx+F8ZYmEb9cc5K9vR2sNPBGpFLPZzJv/2mjd/8PvbldiJyINkt2986WkpFBYWIivr6/NcV9fX5KSkso8Jykpqcz2BQUFpKSkVNim+JrXc9+cnByee+45HnjgAZsM+sEHH2TJkiWsX7+emTNnsnz5cu65554Kf+7Zs2fj6elpfQQGBlbYXqS+ubVHIO+8PAbHK711//3uF/4xb70SPBG5pjWbj7HnQCJgqZB5x9AuBkckImIMu0vuiplMtsOxzGZzqWPXav/r45W5ZmXvm5+fz/33309RURHz5s2zeW7SpEkMGzaM4OBg7r//fr788kvWrFnDzp07y41/xowZpKWlWR+nTp0qt61IfTWkX0def+EOiv/L/fvLWP7fJ1uMDUpE7FpBYRFv/evqkOppk8JxUq+diDRQdvfu5+Pjg6OjY6nesuTk5FK9asX8/PzKbO/k5IS3t3eFbYqvWZX75ufnM378eOLj44mOjr7mvIPevXvj7OzM0aNHy23j6uqKh4eHzUOkIbpjyM28Ov3qIufzPvuZdxZuVg+eiJRpedRe4k9dACCkeysGh3UwOCIREePYXXLn4uJCSEgI0dHRNsejo6MJCwsr85y+ffuWar969WpCQ0NxdnausE3xNSt73+LE7ujRo6xZs8aaPFZk//795Ofn4+/vf822IgL3ju7OC08Ose7P/+xnXv9ggxI8EbGRlZ3HeyXWtXvm9wMqHOUjIlLfORkdQFmmTZvGhAkTCA0NpW/fvnz00UckJCQwefJkwDKE8cyZM3z66aeApTLme++9x7Rp05g0aRIxMTEsWLDAWgUT4Omnn2bAgAHMmTOHsWPH8s0337BmzRo2b95c6fsWFBRw3333sXPnTr777jsKCwutPX3NmzfHxcWFuLg4Fi9ezOjRo/Hx8eHAgQM888wz9OrVi379+tXWSyhS5024pzcmE7z67joAPvnvDnJzC3jxqaFalFhEAPjg8585n5oFwLD+Hekd3MrgiEREjGWXyV1kZCSpqanMmjWLxMREgoODiYqKom3btgAkJibarHkXFBREVFQUU6dO5f333ycgIIB3332Xe++919omLCyMpUuX8uKLLzJz5kw6dOjAsmXL6NOnT6Xve/r0aVauXAlAz549bWL+6aefGDRoEC4uLqxdu5Z33nmHzMxMAgMDueOOO3j55ZdxdHSsqZdMpF763d29cXVx4qU3V2M2w3++2U1ObgGzpkdc+2QRqdfiT11g0X93AODs7MifJw80OCIREePZ5Tp3onXupP65kTXkVkYf4Ll/rKKoyPJ2NfD29jy14F3czNW72LnWuROw77XcjGYvr43ZbGbSs8vZvP0EAJN/dztTJvY3LB4RkZpWZ9e5ExH5tbuGd+Wtl+60roO34efjPBfUj0uOLgZHJiJGWLvlmDWx82/ZlN8/cJuxAYmI2AkldyJSJ4wceBMfv34vTRu7AnDUvRnPdBjAGZfGBkcmIrUpIzOXv72z1rr/3BODcW+kX/SIiICSOxGpQ/r0bMPi/3c/fi2aApDk0phn2g9gd2MfgyMTkdry+gfrOZeSCUD/W9sRMaCTwRGJiNgPJXciUqd0DmrB0vcfoF1OGgAZTi7MbNeXr73bownEIvXblh0n+OL7vQC4N3Jm1jMRWvpARKQEJXciUuf4tWjK68c3c2u6ZSmSIpMD//LvztutepFn0tuaSH2UkZnLzH+utu7/ZfJAAnxV8EZEpCR9CxKROqlxUQEzE7YxPvmI9djaZm34c/twEl3cDYxMRKqb2Wzm5bejOXsuHYDbegYy/s4eBkclImJ/lNyJSJ3lCDycfJDnErbjWlQAwLFGXjzZYRCbPAKMDU5Eqs1Xq/YRte4QAE0au/DaX0bg4KDhmCIiv6bkTkTqvPD0s/zz+CYCci1FFrIdnflHm1t5L+AWcjVMU6ROizuZyqv/72p1zFenj6C1v5dxAYmI2DEnowMQkYYhrkV4jV6/fU4678Rt4P2AW1jvFQjAquZBHHD3ZurpnXS6UoBFROqOtIwc/jjza7JzLD3zv7njFkYOusngqERE7Jd+pS0i9YZ7UQHTT+/k6dO7rMM0T7p5MK3DAD5veRP5qqonUmcUFBbxzN++48SpiwB0bu/D838abHBUIiL2TcmdiNQrJiDiUgJvx22kQ/YlwFJNc0nLm5nafiDH3VRdT8Temc1m3vhgA5u3nwCgmWcj5v39bhq5ORsbmIiInVNyJyL1UtvcDN6K28gDyYdwNBcBEN/IkykdBrLQtyvZDo4GRygi5fnXkv/x7y9jAXBydOCdv95Faz9Pg6MSEbF/Su5EpN5ywsyDyYd5K24jbXMsJdQLTQ4sb9GJP3Qcwtam/lr4XMTOLF25h7f+tcm6//LUYdzWM9DAiERE6g4ldyJS73XMSeOduA08eO4QzkWFAJx3cefvbW/jlTZ9OOPS2OAIRQRg2bd7eGVutHX/md+H85s7bjEwIhGRukXJnYg0CM7mIh44f5j3j/1E74xk6/HtHn78odMQ5vt358KlywZGKNKwLfzvdl5+Kxrzle70iZG3Mum3fYwNSkSkjlFyJyINSqu8LGadjOG5hO1452cDlqGa33m3Z/iDH/Ph4m3k5OYbHKVIw1FYWMSc+et5ff4G67FHI0OZ/vgAA6MSEamblNyJSINjwrLw+UdH1vLguYO4FVqWTci6nMfbH29i+AMf8+8vY5XkidSw9MwcJj//FZ/8d4f12NOP9uPPjw/EpKVLRESqTMmdiDRYbuZCHjh/hH8dXcPICydwcLB8mTx/IYvZ7//EsN/+i0/+u4PsHCV5ItVt594z3PP7z9j0vxOApSrmX6cO4w8T+iqxExG5TkruRKTBa16Qy5Nn9/DNxw8TMaCT9XjKxcvMmb+eYQ/8i/mfxXAxTXPyRG5UTm4+b3+8id9NWcrpxDQAvDwaseCf93H/XT2NDU5EpI4zmc1mVQK3Q+np6Xh6epKWloaHx/UtuhzXIryaoxKp3zqct5RfPxx3nnmfxfDjhiM2z7u6ODFuRDcevq837dt4GxGi1ILqeP+tr27ktTGbzazdcozZ7//EmaR06/Hewa14/YXRWsdORKQClX3/darFmERE6oSbOrTgnb/exeHj5/ngs5/5ceMRiorM5OYVsOzbPSz7dg8D+gQReWcPBvZtj5OjBkGIVORSejbTX/2ezdtPWI85OTrwp0fCmPTb23DU/yERkWqh5E5EpBw3tW/B2y+P4XTiJT77ahdffP8Ll7Mt8+82botn47Z4Wvo04d5Rwdw7urt6HkTK0bSxKxcuZVv3+/ZuwwtPDqFjOx8DoxIRqX/0qzIRkWto7e/FjD8OZsN/J/OXPwwkwLep9bnklEzmf/Yzwx/4F4/++QtW/LCPzKxcA6OVhmTevHkEBQXh5uZGSEgImzZtqrD9hg0bCAkJwc3Njfbt2/PBBx/USpyOjg7MfHooAb5NmfvXMSz852+U2ImI1ADNubNTmnMnUvuK59xdS2FhEZu3n+CL73/hp61xFBbZvo26ODsyOKwDdwy5mYG3t8fVRYMk6pK6Mudu2bJlTJgwgXnz5tGvXz8+/PBDPv74Yw4cOECbNm1KtY+Pjyc4OJhJkybx+OOPs2XLFp544gmWLFnCvffeW6l73uhrk19QiLOTY5XPExFp6Cr7/qvkzk4puROpfZVN7kpKTs3kq1X7WL5qL6fOppV6vkljFwbcFsSQfh0Z0CcIjyZu1RGq1KC6ktz16dOH3r17M3/+fOuxLl26MG7cOGbPnl2q/bPPPsvKlSs5ePCg9djkyZPZs2cPMTExlbpnXXltRETqGxVUERGpBS29mzD5d7fz+IN92H0gke/WHuSH9YdJvWhZNiEzK4+onw4T9dNhnBwduK1nIEP6dWDQ7e1p7e9lbPBSZ+Xl5REbG8tzzz1nczwiIoKtW7eWeU5MTAwRERE2x0aMGMGCBQvIz8/H2dm5xuIVEZHaoeRORKQamEwmenULoFe3AGb8cTA/70zgu7UH+WlrHGkZOQAUFBaxNfYkW2NP8uq762gT4EVYaFv69m7L7b3b4NlUvXpSOSkpKRQWFuLr62tz3NfXl6SkpDLPSUpKKrN9QUEBKSkp+Pv7lzonNzeX3Nyrc0jT09NLtREREfuh5E5EpJo5OTrQ/9Z29L+1HfkFhcTuPcO6LcdYu+WYzfpeCWcvkbDyEktX7sHBwUS3zr7c1iOQ3sGt6N09gGae7gb+FFIXmEwmm32z2Vzq2LXal3W82OzZs3nllVduMEoREaktSu5ERGqQs5Mjt/dqw+292jDjj4M5Ep/CT1vj2LLjBLv3nyW/oAiAoiIzew8lsfdQEguWbQcgKLA5vYMD6B3cip7dAmjXupnWAxMAfHx8cHR0LNVLl5ycXKp3rpifn1+Z7Z2cnPD29i7znBkzZjBt2jTrfnp6OoGBgTcYvYiI1BQldyIitcRkMnFT+xbc1L4Fk393O5ez89jxy2m27DhJzM6THDmeYtM+/tQF4k9dYPmqfQC4uznTpVNLunbypVtnX7p2bkn7Nt5aRL0BcnFxISQkhOjoaO6++27r8ejoaMaOHVvmOX379uXbb7+1ObZ69WpCQ0PLnW/n6uqKq6tr9QUuIiI1SsmdiIhB3Bu5MKBPewb0aQ9A6sUsdu47y859Z9i57wwHjpyz9uwBXM7JJ3bvGWL3nrEec3N1omM7bzq09aZTOx86tPOmUztvAnw9cXAof3ie1H3Tpk1jwoQJhIaG0rdvXz766CMSEhKYPHkyYOl1O3PmDJ9++ilgqYz53nvvMW3aNCZNmkRMTAwLFixgyZIlRv4YIiJSjZTciYjYCe9mjRke3onh4Z0AyMnNZ++hJHbuO8u+w0nsP3KOs+dsC1rk5Baw7/A59h0+Z3O8kZsT7dt4075NcwIDvGjbyovAAC/aBHjh3cy9wnlZUjdERkaSmprKrFmzSExMJDg4mKioKNq2bQtAYmIiCQkJ1vZBQUFERUUxdepU3n//fQICAnj33XcrvcadiIjYP61zZ6e0zp1I7buede5q28W0bA4cPWd5HEnmwNFzJJy9RFXeyd0bORPo70WbVl608vPAv6UHfi2aWh4tm+LTzL1Bz+3TWm7l02sjImIMrXMnIlIPNfNsRL/QdvQLbWc9lpObz/GEC8SdSOXoiVTiTqZy7GQqp85eoqiodNZ3OTufw8fPc/j4+TLv4eToQEufxvj6NMW/ZVNaeDfBu5k73s3c8WnWmObN3PFp5o63lzsuLvoYERERsRf6VBYRqePcXJ3p2smXrp1sqyTm5OZz6mwap85esiy7cPaSZfvMJc4kpVNQWFTm9QoKizh7LoOz5zLYtb/iezdt7Ip3c0vS5+XhhkcTNzw93PBs6oZHE1c8mlq2PZu6Wbc9mrg26J5BERGRmmK3yd28efN44403SExMpFu3bsydO5fw8PKHGW7YsIFp06axf/9+AgIC+Mtf/mKdVF5s+fLlzJw5k7i4ODp06MDf//53mypjlbmv2WzmlVde4aOPPuLixYv06dOH999/n27dulnb5ObmMn36dJYsWUJ2djZDhw5l3rx5tG7duppeHRGRa3NzdaZTkA+dgnxKPVdQWERScjpnzqWTlJxB0vlMkpLTSUrJvLKfwcW07GveIyMrl4ysXE6culil2NwbOdPY3cXyaORi3XZ3K3H8V881cnPGzdUJNxcn3NycLNuulmOuV44raRQRkYbMLpO7ZcuWMWXKFObNm0e/fv348MMPGTVqFAcOHKBNmzal2sfHxzN69GgmTZrE559/zpYtW3jiiSdo0aKFdaJ4TEwMkZGR/O1vf+Puu+9mxYoVjB8/ns2bN9OnT59K3/f111/nrbfeYtGiRXTu3JlXX32V4cOHc/jwYZo2bQrAlClT+Pbbb1m6dCne3t4888wz3HnnncTGxuLo6FhLr6KISPmcHB1o7e9Fa3+vctvk5OaTdD6T1ItZpFy4zIVLl0m5mMWFi5dJuVi8f5nUi1lkZuVV6f6Xs/O5nJ3P+dSsG/xJbDk7O1qTv9+M7s5Tj/av1uuLiIjYM7ssqNKnTx969+7N/Pnzrce6dOnCuHHjmD17dqn2zz77LCtXruTgwYPWY5MnT2bPnj3ExMQAlqpi6enprFq1ytpm5MiRNGvWzFoG+lr3NZvNBAQEMGXKFJ599lnA0kvn6+vLnDlzePzxx0lLS6NFixZ89tlnREZGAnD27FkCAwOJiopixIgRlXoNVFBFpPbVhYIq9io3r4C0jBzS0nNIz7T8mZaRQ3pmLmnp2aRl5to8l3k5l6zL+WRdziMrO6/MuYE36pHfhPDcE4OrfJ6KhpRPr42IiDHqbEGVvLw8YmNjee6552yOR0REsHXr1jLPiYmJISIiwubYiBEjWLBgAfn5+Tg7OxMTE8PUqVNLtZk7d26l7xsfH09SUpLNvVxdXRk4cCBbt27l8ccfJzY2lvz8fJs2AQEBBAcHs3Xr1nKTu9zcXHJzc637aWlpgOUv8nplFBVc97kiDdGN/H8TcHMGN28XfL1dgMp/8TebzeTmFXD5ch5ZV3r0srLzuJydR3Z2/pVjeWTnFpCbW0BObj65eQXk5BZe3c4pIDe/gNwSx9yczdf1d1p8jh3+7tNwxa+J/q+IiNSuyn422V1yl5KSQmFhIb6+toUBfH19SUpKKvOcpKSkMtsXFBSQkpKCv79/uW2Kr1mZ+xb/WVabkydPWtu4uLjQrFmzSscPMHv2bF555ZVSxwMDA8s9R0Sqmaen0RFINdq8Aqb+/vrPz8jIwFP/JmxkZGQA+mwSETHKtT6b7C65K/brBXbNZnOFi+6W1f7Xxytzzepq82vXajNjxgymTZtm3S8qKuLChQt4e3vbxWLD6enpBAYGcurUqTo1FEdx1666GjfU3dgVd/Uzm81kZGQQEBBgdCh2JyAggFOnTtG0aVPDP5vs+d/QtdTV2BV37aqrcUPdjd2e467sZ5PdJXc+Pj44OjqW6uVKTk4u1WNWzM/Pr8z2Tk5OeHt7V9im+JqVua+fnx9g6Z3z9/cvt01eXh4XL1606b1LTk4mLCys3J/b1dUVV1dXm2NeXl7ltjeKh4eH3f1jrwzFXbvqatxQd2NX3NVLPXZlc3BwsLvKz/b6b6gy6mrsirt21dW4oe7Gbq9xV+azye5qRru4uBASEkJ0dLTN8ejo6HKTo759+5Zqv3r1akJDQ3F2dq6wTfE1K3PfoKAg/Pz8bNrk5eWxYcMGa5uQkBCcnZ1t2iQmJrJv374KkzsREREREZEbYXc9dwDTpk1jwoQJhIaG0rdvXz766CMSEhKs69bNmDGDM2fO8OmnnwKWypjvvfce06ZNY9KkScTExLBgwQJrFUyAp59+mgEDBjBnzhzGjh3LN998w5o1a9i8eXOl72symZgyZQqvvfYanTp1olOnTrz22mu4u7vzwAMPAJaMeuLEiTzzzDN4e3vTvHlzpk+fTvfu3Rk2bFhtvYQiIiIiItLA2GVyFxkZSWpqKrNmzSIxMZHg4GCioqJo27YtYOkJS0hIsLYPCgoiKiqKqVOn8v777xMQEMC7775rXeMOICwsjKVLl/Liiy8yc+ZMOnTowLJly6xr3FXmvgB/+cv/b+/eg6I6zz+AfxflYpWsMQLLigJeSCawoTHEqM2AQ1OCDcGEiuEihVRtbNFoaxrNtFYzScdMOtFpJhNNZtBcTNRUJCYiKAQwMqLQ4Bo0UTFccil4IYCoARb2+f3R2fPjuIt4WdiL388MM/i+7zn7nIcjzzyc3XOex08//YQ//vGPykPM9+/frzzjDgA2bNiA4cOHY968ecpDzN955x2Xfsadt7c31qxZY/XWUWfHuIeWq8YNuG7sjJtuV658Drlq7Ix7aLlq3IDrxu6qcffllM+5IyIiIiIiohvjdJ+5IyIiIiIiohvH5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3ACbu9vUunXr8OCDD8LX1xf+/v544okncOrUKdWarKwsaDQa1df06dNVa7q6urB06VKMHTsWI0eORGJiIr7//vtBjX3t2rVWcVkeMA8AIoK1a9dCr9djxIgRmDVrFk6cOOHwuENCQqzi1mg0yM7OBuA8+f7888/x+OOPQ6/XQ6PR4OOPP1bN2yu/ra2tyMjIgFarhVarRUZGBtra2gYlbpPJhJUrV8JgMGDkyJHQ6/X47W9/i//+97+qfcyaNcvqZ5CSkjKocQ8UO2C/c2Mocw7A5vmu0Wjwz3/+U1njqJyTc3LV2uSqdQlgbWJtuvG4AeetS9cTu7vXJjZ3t6kDBw4gOzsbhw8fRlFREXp6ehAXF4fLly+r1sXHx6OpqUn52rt3r2p++fLlyMvLw/bt21FeXo5Lly4hISEBvb29gxp/eHi4Kq6amhpl7tVXX8X69evxxhtvoKqqCjqdDr/61a/Q0dHh0LirqqpUMVsedJ+cnKyscYZ8X758GZGRkXjjjTdsztsrv2lpaTAajSgsLERhYSGMRiMyMjIGJe4rV66guroaq1evRnV1NXbt2oXTp08jMTHRau2iRYtUP4O33npLNW/vuAeK3cIe58ZQ5hyAKt6mpiZs3rwZGo1G9ZgawDE5J+fkyrXJFesSwNrE2nTjcVs4Y126ntjdvjYJkYicO3dOAMiBAweUsczMTJkzZ06/27S1tYmnp6ds375dGfvhhx/Ew8NDCgsLBy3WNWvWSGRkpM05s9ksOp1OXnnlFWWss7NTtFqtbNq0yaFxX23ZsmUyadIkMZvNIuKc+QYgeXl5yr/tld+vvvpKAMjhw4eVNRUVFQJATp48afe4bamsrBQA0tjYqIzFxMTIsmXL+t1msOMWsR27Pc4NZ8j5nDlzJDY2VjXmDDkn5+Uqtcld6pIIa5Ojf086Y21y1brUX+xXc7faxCt3BABob28HAIwZM0Y1XlZWBn9/f4SFhWHRokU4d+6cMvfFF1/AZDIhLi5OGdPr9YiIiMChQ4cGNd7a2lro9XqEhoYiJSUFdXV1AID6+no0NzerYvL29kZMTIwSkyPjtuju7sbWrVvxu9/9DhqNRhl31nxb2Cu/FRUV0Gq1eOihh5Q106dPh1arHbJjaW9vh0ajwejRo1XjH3zwAcaOHYvw8HA899xzqr/6OjLuWz03HJ3zs2fPIj8/HwsWLLCac9ack+O5Um1y9boEsDY5w+8bV6pNrl6XAPesTcMd+urkFEQEf/7zn/Hwww8jIiJCGZ89ezaSk5MRHByM+vp6rF69GrGxsfjiiy/g7e2N5uZmeHl54c4771TtLyAgAM3NzYMW70MPPYT33nsPYWFhOHv2LF5++WXMnDkTJ06cUF43ICDAKqbGxkYAcFjcfX388cdoa2tDVlaWMuas+e7LXvltbm6Gv7+/1f79/f2H5Fg6OzuxatUqpKWl4Y477lDG09PTERoaCp1Oh+PHj+OFF17AsWPHlLcpOSpue5wbjs75u+++C19fXyQlJanGnTXn5HiuVJvcoS4BrE2O/n3jSrXJHeoS4J61ic0dYcmSJfjyyy9RXl6uGn/qqaeU7yMiIhAVFYXg4GDk5+db/SfoS0RUf/Gzt9mzZyvfGwwGzJgxA5MmTcK7776rfJj36te/npgGO+6+cnJyMHv2bOj1emXMWfNtiz3ya2v9UByLyWRCSkoKzGYz3nzzTdXcokWLlO8jIiIwZcoUREVFobq6GlOnTnVY3PY6NxyVcwDYvHkz0tPT4ePjoxp31pyT47lSbXKHugSwNtnax/Xu51a5Wm1yh7oEuGdt4tsyb3NLly7FJ598gtLSUgQFBV1zbWBgIIKDg1FbWwsA0Ol06O7uRmtrq2rduXPnrP56NphGjhwJg8GA2tpa5e5kV//VpG9Mjo67sbERxcXFWLhw4TXXOWO+7ZVfnU6Hs2fPWu3//Pnzg3osJpMJ8+bNQ319PYqKilR/GbVl6tSp8PT0VP0MHBH31W7m3HBk7AcPHsSpU6cGPOcB5805DS1Xr02uVpcA1ibLGtamm+NqdQlw39rE5u42JSJYsmQJdu3ahZKSEoSGhg64TUtLC7777jsEBgYCAB544AF4enoql6iB/92B6Pjx45g5c+agxX61rq4ufP311wgMDFQuofeNqbu7GwcOHFBicnTcW7Zsgb+/Px577LFrrnPGfNsrvzNmzEB7ezsqKyuVNUeOHEF7e/ugHYuleNbW1qK4uBh33XXXgNucOHECJpNJ+Rk4Im5bbubccGTsOTk5eOCBBxAZGTngWmfNOQ0Nd6lNrlaXANYmgLXpVrhaXQLcuDYN1Z1byLn84Q9/EK1WK2VlZdLU1KR8XblyRUREOjo6ZMWKFXLo0CGpr6+X0tJSmTFjhowbN04uXryo7Gfx4sUSFBQkxcXFUl1dLbGxsRIZGSk9PT2DFvuKFSukrKxM6urq5PDhw5KQkCC+vr7S0NAgIiKvvPKKaLVa2bVrl9TU1EhqaqoEBgY6PG4Rkd7eXpkwYYKsXLlSNe5M+e7o6JCjR4/K0aNHBYCsX79ejh49qty5y175jY+Pl/vuu08qKiqkoqJCDAaDJCQkDErcJpNJEhMTJSgoSIxGo+qc7+rqEhGRM2fOyIsvvihVVVVSX18v+fn5cs8998j9998/qHEPFLs9z42hzLlFe3u7/OxnP5ONGzdabe/InJNzctXa5Mp1SYS1ibXpxuJ25ro0UOwW7lyb2NzdpgDY/NqyZYuIiFy5ckXi4uLEz89PPD09ZcKECZKZmSnffvutaj8//fSTLFmyRMaMGSMjRoyQhIQEqzX29tRTT0lgYKB4enqKXq+XpKQkOXHihDJvNptlzZo1otPpxNvbW6Kjo6WmpsbhcYuI7Nu3TwDIqVOnVOPOlO/S0lKb50ZmZqaI2C+/LS0tkp6eLr6+vuLr6yvp6enS2to6KHHX19f3e86XlpaKiMi3334r0dHRMmbMGPHy8pJJkybJs88+Ky0tLYMa90Cx2/PcGMqcW7z11lsyYsQIaWtrs9rekTkn5+SqtcmV65IIa1NfrE0Dx+3MdWmg2C3cuTZpRERu9qofEREREREROQd+5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3ACbOyIiIiIiIjfA5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3ACbOyIHO3LkCDQaDTQaDdatW+focOxu1qxZ0Gg0aGhosMv+QkJCoNFo7LIvIiIiInfC5o7Iwd5//32b398qNkHXtnbtWmg0GrzzzjuODoWIiIjILtjcETmQyWTCjh07oNFooNPp8PXXX6O6utrRYRERERGRC2JzR+RABQUFuHDhAqKjo/H73/8egH2v3hERERHR7YPNHZEDWRq5+fPnY/78+QCAbdu2obe3t99tvvrqKzz99NMIDg6Gt7c3AgICEB0djX/9618AgLKyMmg0GjQ2NgKA8nk+jUaDkJAQZT/XetumZR9ZWVmq8aamJrz66quIiYnBuHHj4OXlBZ1Oh6SkJFRVVd1sGqz09PRg3bp1mDJlCnx8fDBx4kSsXr0a3d3dNteLCLZt24aUlBSEhYVh5MiR8PX1xbRp0/Dmm2/CbDar1oeEhODFF18EADz99NOqHJWVlQEAOjs7kZOTgzlz5mDixIkYMWIERo8ejejoaGzfvt1ux0pERERkL8MdHQDR7aq9vR179uyBt7c35s6di9GjR2PatGmorKxEUVER4uPjrbb597//jYyMDHR1dSE8PBwzZ87Ejz/+iOPHj2P58uVYtmwZdDodMjMzsXPnTly+fBmZmZnK9mPHjr2lmHfv3o2VK1di8uTJMBgMuOOOO3DmzBnk5eVhz5492LNnD+Li4m7pNQAgNTUVO3fuxKhRoxAfHw8Rwfr163H06FGIiNX6rq4upKWl4c4778S9996LqVOn4sKFC6ioqEB2djYqKytVn62bO3cuiouLcezYMfziF7/A5MmTlTmdTgcAaGhowMKFCxEQEIB77rkH06ZNQ3NzMw4dOoSDBw/i5MmTWLt27S0fKxEREZHdCBE5xNtvvy0A5De/+Y0y9vrrrwsASU9Pt1p/+vRp8fHxEU9PT9mxY4dqrre3Vz799FPVWHBwsFzrv/i15ktLSwWAZGZmqsa//PJLOXbsmNX6wsJC8fLykkmTJonZbFbNxcTECACpr6/vN5a+PvzwQwEgEydOlO+//14Zr6urk6CgIAFgFbfJZJLc3Fzp6upSjZ87d06ioqIEgBw4cEA1t2bNGgEgW7ZssRnHhQsXZN++fdLb26sar6urk5CQEPHw8LjuYyIiIiIaCnxbJpGD9H1LpkVKSgqGDx+OvLw8XLp0SbV+w4YN6OzsxDPPPIN58+ap5jw8PJCQkDDoMRsMBtx3331W448++iiSk5PxzTff4Pjx47f0Ghs3bgQAvPTSSxg3bpwyHhoaitWrV9vcZvjw4UhKSoKXl5dq3M/PT3m8xO7du28ojrvuugtxcXHw8FD/mgwNDcVf//pXmM1mfPrppze0TyIiIqLBxLdlEjlAQ0MDysvLMWbMGPz6179Wxv38/PDoo48iPz8feXl5yMjIUOaKi4sBAM8888yQx9tXV1cXCgsLUVlZifPnzyufg6upqQEA1NbWwmAw3NS+TSYTjhw5Ag8PD8ydO9dqPjU19ZrHbzQasX//fjQ2NuLKlSsQEXR0dChx3Yzy8nKUlZXhhx9+QGdnJ0QETU1Nt7RPIiIiosHA5o7IAbZu3QoRwbx586yuNs2fPx/5+fl4//33Vc3dd999BwCYOHHikMbaV01NDRITE6/5QHJLM3UzWlpa0N3djcDAQKu8AICvry9Gjx6NtrY21Xh3dzeysrKwbds2u8XV3t6OpKQklJSU2G2fRERERIOJb8skcoCtW7cCAD777DM8/PDDqq/XXntNmbNcIbKw3NFxsF19d0kASjPa0NCAxYsXw2g04uLFizCbzRARvPDCC8q6m2XZ9kaPcf369di2bRsiIiJQUFCAs2fPoru7GyKCU6dO3VRcK1euRElJCaKjo1FWVoYLFy6gp6cHIoJ9+/bd1D6JiIiIBhOv3BENscrKSqXhqK2t7fetfWazGR9++CFWrFgBABg/fjxqa2vxzTffICIi4pbjsFwZu3TpEkaNGqWas1wl7OvkyZM4efIkoqKilM/F9VVXV3fLMY0dOxZeXl5obm5Gd3e31dW7jo4Oq6t2AJCXlwcASoNnj7jy8vIwbNgwfPLJJ9BqtXbZJxEREdFg4pU7oiFmuZHKX/7yF4iIza/9+/cD+P8rfADwyCOPAADefvvt63odS2PU09Njcz4wMBAAcPr0aas5y+v31draCgAICgqyOVdUVHRdcV2Lp6cnpk2bBrPZjNzcXKv5/p4vZ4lt/PjxVnMfffSRzW0Gyk9rayt8fX2tGrtr7ZOIiIjIkdjcEQ2hnp4e7NixA8D/bg7Sn9jYWPj7+8NoNCp3n1y+fDl8fHywadMmq8bHbDZj7969qjG9Xg8AylXCq8XExAAA1q1bp3po+tatW202UZMnT4aHhwdKSkpUVxs7OzuxePFi/Pjjj/0ez42w3DDl73//u+ptqY2NjXjppZdsbhMWFgYA2LRpk2p8586deO+992xuM1B+wsLC0NbWpvy8LDZs2IDS0tLrOBIiIiKiocXmjmgIFRQU4Pz587j77rtx//3397tu2LBhyt0iLVfvwsLCsHnzZgD/ewi3wWBAamoq4uPjMX78eDz22GOqfSQmJgIAfvnLXyI1NRULFy7EqlWrlPns7Gz4+flh586duPfee5GcnIyf//znyMrKwrJly6xi8vf3x4IFC3Dx4kVERkYiISEBycnJCAkJQUlJCbKysm4pNxbp6el48skncebMGdx999148skn8cQTTyA8PBwGgwETJkyw2ub555/HsGHDsGrVKkRFRSEtLQ0PPvggkpOT8ac//cnm68TFxcHHxwcbNmzA7NmzsWDBAixcuFBp9iyfIUxJSUF0dDTS0tIQHh6O5557rt99EhERETkSmzuiIWR5S2ZKSsqAay1X9j744APlBiepqamoqqpCWloaWlpakJubC6PRiClTpuD1119Xbf/ss8/ib3/7G0aNGoXc3Fzk5OSorsgFBATg888/R0JCApqamlBQUACtVouioiKlMbzaxo0b8dprryE0NBSfffYZDh48iEceeQT/+c9/EBwcfFM5uZpGo8GOHTvwj3/8A35+fti7dy+MRiOWLl2KXbt22bzZSnR0NMrLyxEbG4u6ujrs2bMHXl5eyM3NRXZ2ts3X0ev12L17N6ZPn47y8nJs3rwZOTk5ytXC9PR05OfnY/r06TAajSgoKIBer0dJSUm/+SEiIiJyJI3wdm9EREREREQuj1fuiIiIiIiI3ACbOyIiIiIiIjfA5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3ACbOyIiIiIiIjfA5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3ACbOyIiIiIiIjfA5o6IiIiIiMgNsLkjIiIiIiJyA2zuiIiIiIiI3MD/AYnLdtlgiqlfAAAAAElFTkSuQmCC\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = Gevdist.probapilityPlot(\n", + " shape, loc, scale, cdf_Weibul, func=func, n_samples=len(time_series1)\n", + ")\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/SensitivityAnalysis.py b/examples/SensitivityAnalysis.py index ad9129f..ae095a4 100644 --- a/examples/SensitivityAnalysis.py +++ b/examples/SensitivityAnalysis.py @@ -6,10 +6,8 @@ Path = "F:/01Algorithms/Hydrology/HAPI/examples" import matplotlib -# os.chdir(Path) -import pandas as pd - matplotlib.use("TkAgg") +import pandas as pd # functions import Hapi.rrm.hbv_bergestrom92 as HBVLumped diff --git a/examples/lmoments.py b/examples/lmoments.py new file mode 100644 index 0000000..7712105 --- /dev/null +++ b/examples/lmoments.py @@ -0,0 +1,41 @@ +import pandas as pd +import numpy as np +from statista.parameters import Lmoments + +time_series1 = pd.read_csv("examples/data/time_series1.txt", header=None)[0].tolist() +time_series2 = pd.read_csv("examples/data/time_series2.txt", header=None)[0].tolist() +#%% +L = Lmoments(time_series1) +l1, l2, l3, l4 = L.Lmom(4) + +sample = np.array(time_series1) +n = len(sample) +# sort descinding +sample = np.sort(sample.reshape(n))[::-1] +b0 = np.mean(sample) +b1 = np.array([(n - j - 1) * sample[j] / n / (n - 1) for j in range(n - 1)]).sum() +b2 = np.array( + [ + (n - j - 1) * (n - j - 2) * sample[j] / n / (n - 1) / (n - 2) + for j in range(n - 1) + ] +).sum() + +b3 = np.array( + [ + (n - j - 1) + * (n - j - 2) + * (n - j - 3) + * sample[j] + / n + / (n - 1) + / (n - 2) + / (n - 3) + for j in range(n - 1) + ] +).sum() +lmom1 = b0 +lmom2 = 2 * b1 - b0 +lmom3 = 6 * (b2 - b1) + b0 +lmom4 = 20 * b3 - 30 * b2 + 12 * b1 - b0 +lmom1, lmom2, lmom3, lmom4 diff --git a/mkdocs.yml b/mkdocs.yml deleted file mode 100644 index 740c8ae..0000000 --- a/mkdocs.yml +++ /dev/null @@ -1,13 +0,0 @@ -site_name: statista -site_description: The documentation of Hapi Hydrological Model -site_author: Mostafa Farrag - -repo_url: https://github.com/MAfarrag/statista -edit_url: "" - -theme: - name: readthedocs - -nav: - - Home: index.md - - License: license.md diff --git a/poetry.lock b/poetry.lock index dbf0562..939d7e6 100644 --- a/poetry.lock +++ b/poetry.lock @@ -44,32 +44,46 @@ yaml = ["PyYAML"] [[package]] name = "black" -version = "22.12.0" +version = "23.1.0" description = "The uncompromising code formatter." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "black-22.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eedd20838bd5d75b80c9f5487dbcb06836a43833a37846cf1d8c1cc01cef59d"}, - {file = "black-22.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:159a46a4947f73387b4d83e87ea006dbb2337eab6c879620a3ba52699b1f4351"}, - {file = "black-22.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d30b212bffeb1e252b31dd269dfae69dd17e06d92b87ad26e23890f3efea366f"}, - {file = "black-22.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:7412e75863aa5c5411886804678b7d083c7c28421210180d67dfd8cf1221e1f4"}, - {file = "black-22.12.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c116eed0efb9ff870ded8b62fe9f28dd61ef6e9ddd28d83d7d264a38417dcee2"}, - {file = "black-22.12.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1f58cbe16dfe8c12b7434e50ff889fa479072096d79f0a7f25e4ab8e94cd8350"}, - {file = "black-22.12.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77d86c9f3db9b1bf6761244bc0b3572a546f5fe37917a044e02f3166d5aafa7d"}, - {file = "black-22.12.0-cp38-cp38-win_amd64.whl", hash = "sha256:82d9fe8fee3401e02e79767016b4907820a7dc28d70d137eb397b92ef3cc5bfc"}, - {file = "black-22.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:101c69b23df9b44247bd88e1d7e90154336ac4992502d4197bdac35dd7ee3320"}, - {file = "black-22.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:559c7a1ba9a006226f09e4916060982fd27334ae1998e7a38b3f33a37f7a2148"}, - {file = "black-22.12.0-py3-none-any.whl", hash = "sha256:436cc9167dd28040ad90d3b404aec22cedf24a6e4d7de221bec2730ec0c97bcf"}, - {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, + {file = "black-23.1.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:b6a92a41ee34b883b359998f0c8e6eb8e99803aa8bf3123bf2b2e6fec505a221"}, + {file = "black-23.1.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:57c18c5165c1dbe291d5306e53fb3988122890e57bd9b3dcb75f967f13411a26"}, + {file = "black-23.1.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:9880d7d419bb7e709b37e28deb5e68a49227713b623c72b2b931028ea65f619b"}, + {file = "black-23.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e6663f91b6feca5d06f2ccd49a10f254f9298cc1f7f49c46e498a0771b507104"}, + {file = "black-23.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:9afd3f493666a0cd8f8df9a0200c6359ac53940cbde049dcb1a7eb6ee2dd7074"}, + {file = "black-23.1.0-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:bfffba28dc52a58f04492181392ee380e95262af14ee01d4bc7bb1b1c6ca8d27"}, + {file = "black-23.1.0-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:c1c476bc7b7d021321e7d93dc2cbd78ce103b84d5a4cf97ed535fbc0d6660648"}, + {file = "black-23.1.0-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:382998821f58e5c8238d3166c492139573325287820963d2f7de4d518bd76958"}, + {file = "black-23.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bf649fda611c8550ca9d7592b69f0637218c2369b7744694c5e4902873b2f3a"}, + {file = "black-23.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:121ca7f10b4a01fd99951234abdbd97728e1240be89fde18480ffac16503d481"}, + {file = "black-23.1.0-cp37-cp37m-macosx_10_16_x86_64.whl", hash = "sha256:a8471939da5e824b891b25751955be52ee7f8a30a916d570a5ba8e0f2eb2ecad"}, + {file = "black-23.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8178318cb74f98bc571eef19068f6ab5613b3e59d4f47771582f04e175570ed8"}, + {file = "black-23.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:a436e7881d33acaf2536c46a454bb964a50eff59b21b51c6ccf5a40601fbef24"}, + {file = "black-23.1.0-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:a59db0a2094d2259c554676403fa2fac3473ccf1354c1c63eccf7ae65aac8ab6"}, + {file = "black-23.1.0-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:0052dba51dec07ed029ed61b18183942043e00008ec65d5028814afaab9a22fd"}, + {file = "black-23.1.0-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:49f7b39e30f326a34b5c9a4213213a6b221d7ae9d58ec70df1c4a307cf2a1580"}, + {file = "black-23.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:162e37d49e93bd6eb6f1afc3e17a3d23a823042530c37c3c42eeeaf026f38468"}, + {file = "black-23.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b70eb40a78dfac24842458476135f9b99ab952dd3f2dab738c1881a9b38b753"}, + {file = "black-23.1.0-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:a29650759a6a0944e7cca036674655c2f0f63806ddecc45ed40b7b8aa314b651"}, + {file = "black-23.1.0-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:bb460c8561c8c1bec7824ecbc3ce085eb50005883a6203dcfb0122e95797ee06"}, + {file = "black-23.1.0-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:c91dfc2c2a4e50df0026f88d2215e166616e0c80e86004d0003ece0488db2739"}, + {file = "black-23.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2a951cc83ab535d248c89f300eccbd625e80ab880fbcfb5ac8afb5f01a258ac9"}, + {file = "black-23.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:0680d4380db3719ebcfb2613f34e86c8e6d15ffeabcf8ec59355c5e7b85bb555"}, + {file = "black-23.1.0-py3-none-any.whl", hash = "sha256:7a0f701d314cfa0896b9001df70a530eb2472babb76086344e688829efd97d32"}, + {file = "black-23.1.0.tar.gz", hash = "sha256:b0bd97bea8903f5a2ba7219257a44e3f1f9d00073d6cc1add68f0beec69692ac"}, ] [package.dependencies] click = ">=8.0.0" mypy-extensions = ">=0.4.3" +packaging = ">=22.0" pathspec = ">=0.9.0" platformdirs = ">=2" -tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""} +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""} [package.extras] @@ -385,14 +399,14 @@ flake8 = ">=5.0.0" [[package]] name = "flake8-bugbear" -version = "23.1.20" +version = "23.2.13" description = "A plugin for flake8 finding likely bugs and design problems in your program. Contains warnings that don't belong in pyflakes and pycodestyle." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "flake8-bugbear-23.1.20.tar.gz", hash = "sha256:55902ab5a48c5ea53d8689ecd146eda548e72f2724192b9c1d68f6d975d13c06"}, - {file = "flake8_bugbear-23.1.20-py3-none-any.whl", hash = "sha256:04a115e5f9c8e87c38bdbbcdf9f58223ffe05469c07c9a7bd8633330bc4d078b"}, + {file = "flake8-bugbear-23.2.13.tar.gz", hash = "sha256:39259814a83f33c8409417ee12dd4050c9c0bb4c8707c12fc18ae62b2f3ddee1"}, + {file = "flake8_bugbear-23.2.13-py3-none-any.whl", hash = "sha256:f136bd0ca2684f101168bba2310dec541e11aa6b252260c17dcf58d18069a740"}, ] [package.dependencies] @@ -481,14 +495,14 @@ smmap = ">=3.0.1,<6" [[package]] name = "gitpython" -version = "3.1.30" -description = "GitPython is a python library used to interact with Git repositories" +version = "3.1.31" +description = "GitPython is a Python library used to interact with Git repositories" category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "GitPython-3.1.30-py3-none-any.whl", hash = "sha256:cd455b0000615c60e286208ba540271af9fe531fa6a87cc590a7298785ab2882"}, - {file = "GitPython-3.1.30.tar.gz", hash = "sha256:769c2d83e13f5d938b7688479da374c4e3d49f71549aaf462b646db9602ea6f8"}, + {file = "GitPython-3.1.31-py3-none-any.whl", hash = "sha256:f04893614f6aa713a60cbbe1e6a97403ef633103cdd0ef5eb6efe0deb98dbe8d"}, + {file = "GitPython-3.1.31.tar.gz", hash = "sha256:8ce3bcf69adfdf7c7d503e78fd3b1c492af782d58893b650adb2ac8912ddd573"}, ] [package.dependencies] @@ -496,19 +510,38 @@ gitdb = ">=4.0.1,<5" [[package]] name = "identify" -version = "2.5.17" +version = "2.5.18" description = "File identification library for Python" category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "identify-2.5.17-py2.py3-none-any.whl", hash = "sha256:7d526dd1283555aafcc91539acc061d8f6f59adb0a7bba462735b0a318bff7ed"}, - {file = "identify-2.5.17.tar.gz", hash = "sha256:93cc61a861052de9d4c541a7acb7e3dcc9c11b398a2144f6e52ae5285f5f4f06"}, + {file = "identify-2.5.18-py2.py3-none-any.whl", hash = "sha256:93aac7ecf2f6abf879b8f29a8002d3c6de7086b8c28d88e1ad15045a15ab63f9"}, + {file = "identify-2.5.18.tar.gz", hash = "sha256:89e144fa560cc4cffb6ef2ab5e9fb18ed9f9b3cb054384bab4b95c12f6c309fe"}, ] [package.extras] license = ["ukkonen"] +[[package]] +name = "importlib-resources" +version = "5.12.0" +description = "Read resources from Python packages" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "importlib_resources-5.12.0-py3-none-any.whl", hash = "sha256:7b1deeebbf351c7578e09bf2f63fa2ce8b5ffec296e0d349139d43cca061a81a"}, + {file = "importlib_resources-5.12.0.tar.gz", hash = "sha256:4be82589bf5c1d7999aedf2a45159d10cb3ca4f19b2271f8792bc8e6da7b22f6"}, +] + +[package.dependencies] +zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["flake8 (<5)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] + [[package]] name = "iniconfig" version = "2.0.0" @@ -632,64 +665,65 @@ dev = ["Sphinx (>=4.1.1)", "black (>=19.10b0)", "colorama (>=0.3.4)", "docutils [[package]] name = "matplotlib" -version = "3.6.3" +version = "3.7.0" description = "Python plotting package" category = "main" optional = false python-versions = ">=3.8" files = [ - {file = "matplotlib-3.6.3-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:80c166a0e28512e26755f69040e6bf2f946a02ffdb7c00bf6158cca3d2b146e6"}, - {file = "matplotlib-3.6.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:eb9421c403ffd387fbe729de6d9a03005bf42faba5e8432f4e51e703215b49fc"}, - {file = "matplotlib-3.6.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5223affa21050fb6118353c1380c15e23aedfb436bf3e162c26dc950617a7519"}, - {file = "matplotlib-3.6.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d00c248ab6b92bea3f8148714837937053a083ff03b4c5e30ed37e28fc0e7e56"}, - {file = "matplotlib-3.6.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca94f0362f6b6f424b555b956971dcb94b12d0368a6c3e07dc7a40d32d6d873d"}, - {file = "matplotlib-3.6.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59400cc9451094b7f08cc3f321972e6e1db4cd37a978d4e8a12824bf7fd2f03b"}, - {file = "matplotlib-3.6.3-cp310-cp310-win32.whl", hash = "sha256:57ad1aee29043163374bfa8990e1a2a10ff72c9a1bfaa92e9c46f6ea59269121"}, - {file = "matplotlib-3.6.3-cp310-cp310-win_amd64.whl", hash = "sha256:1fcc4cad498533d3c393a160975acc9b36ffa224d15a6b90ae579eacee5d8579"}, - {file = "matplotlib-3.6.3-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:d2cfaa7fd62294d945b8843ea24228a27c8e7c5b48fa634f3c168153b825a21b"}, - {file = "matplotlib-3.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:c3f08df2ac4636249b8bc7a85b8b82c983bef1441595936f62c2918370ca7e1d"}, - {file = "matplotlib-3.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ff2aa84e74f80891e6bcf292ebb1dd57714ffbe13177642d65fee25384a30894"}, - {file = "matplotlib-3.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:11011c97d62c1db7bc20509572557842dbb8c2a2ddd3dd7f20501aa1cde3e54e"}, - {file = "matplotlib-3.6.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c235bf9be052347373f589e018988cad177abb3f997ab1a2e2210c41562cc0c"}, - {file = "matplotlib-3.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bebcff4c3ed02c6399d47329f3554193abd824d3d53b5ca02cf583bcd94470e2"}, - {file = "matplotlib-3.6.3-cp311-cp311-win32.whl", hash = "sha256:d5f18430f5cfa5571ab8f4c72c89af52aa0618e864c60028f11a857d62200cba"}, - {file = "matplotlib-3.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:dfba7057609ca9567b9704626756f0142e97ec8c5ba2c70c6e7bd1c25ef99f06"}, - {file = "matplotlib-3.6.3-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:9fb8fb19d03abf3c5dab89a8677e62c4023632f919a62b6dd1d6d2dbf42cd9f5"}, - {file = "matplotlib-3.6.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:bbf269e1d24bc25247095d71c7a969813f7080e2a7c6fa28931a603f747ab012"}, - {file = "matplotlib-3.6.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:994637e2995b0342699b396a320698b07cd148bbcf2dd2fa2daba73f34dd19f2"}, - {file = "matplotlib-3.6.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:77b384cee7ab8cf75ffccbfea351a09b97564fc62d149827a5e864bec81526e5"}, - {file = "matplotlib-3.6.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:73b93af33634ed919e72811c9703e1105185cd3fb46d76f30b7f4cfbbd063f89"}, - {file = "matplotlib-3.6.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:debeab8e2ab07e5e3dac33e12456da79c7e104270d2b2d1df92b9e40347cca75"}, - {file = "matplotlib-3.6.3-cp38-cp38-win32.whl", hash = "sha256:acc3b1a4bddbf56fe461e36fb9ef94c2cb607fc90d24ccc650040bfcc7610de4"}, - {file = "matplotlib-3.6.3-cp38-cp38-win_amd64.whl", hash = "sha256:1183877d008c752d7d535396096c910f4663e4b74a18313adee1213328388e1e"}, - {file = "matplotlib-3.6.3-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:6adc441b5b2098a4b904bbf9d9e92fb816fef50c55aa2ea6a823fc89b94bb838"}, - {file = "matplotlib-3.6.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:6d81b11ede69e3a751424b98dc869c96c10256b2206bfdf41f9c720eee86844c"}, - {file = "matplotlib-3.6.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:29f17b7f2e068dc346687cbdf80b430580bab42346625821c2d3abf3a1ec5417"}, - {file = "matplotlib-3.6.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f56a7252eee8f3438447f75f5e1148a1896a2756a92285fe5d73bed6deebff4"}, - {file = "matplotlib-3.6.3-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bbddfeb1495484351fb5b30cf5bdf06b3de0bc4626a707d29e43dfd61af2a780"}, - {file = "matplotlib-3.6.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:809119d1cba3ece3c9742eb01827fe7a0e781ea3c5d89534655a75e07979344f"}, - {file = "matplotlib-3.6.3-cp39-cp39-win32.whl", hash = "sha256:e0a64d7cc336b52e90f59e6d638ae847b966f68582a7af041e063d568e814740"}, - {file = "matplotlib-3.6.3-cp39-cp39-win_amd64.whl", hash = "sha256:79e501eb847f4a489eb7065bb8d3187117f65a4c02d12ea3a19d6c5bef173bcc"}, - {file = "matplotlib-3.6.3-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2787a16df07370dcba385fe20cdd0cc3cfaabd3c873ddabca78c10514c799721"}, - {file = "matplotlib-3.6.3-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:68d94a436f62b8a861bf3ace82067a71bafb724b4e4f9133521e4d8012420dd7"}, - {file = "matplotlib-3.6.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81b409b2790cf8d7c1ef35920f01676d2ae7afa8241844e7aa5484fdf493a9a0"}, - {file = "matplotlib-3.6.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:faff486b36530a836a6b4395850322e74211cd81fc17f28b4904e1bd53668e3e"}, - {file = "matplotlib-3.6.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:38d38cb1ea1d80ee0f6351b65c6f76cad6060bbbead015720ba001348ae90f0c"}, - {file = "matplotlib-3.6.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12f999661589981e74d793ee2f41b924b3b87d65fd929f6153bf0f30675c59b1"}, - {file = "matplotlib-3.6.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01b7f521a9a73c383825813af255f8c4485d1706e4f3e2ed5ae771e4403a40ab"}, - {file = "matplotlib-3.6.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:9ceebaf73f1a3444fa11014f38b9da37ff7ea328d6efa1652241fe3777bfdab9"}, - {file = "matplotlib-3.6.3.tar.gz", hash = "sha256:1f4d69707b1677560cd952544ee4962f68ff07952fb9069ff8c12b56353cb8c9"}, + {file = "matplotlib-3.7.0-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:3da8b9618188346239e51f1ea6c0f8f05c6e218cfcc30b399dd7dd7f52e8bceb"}, + {file = "matplotlib-3.7.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c0592ba57217c22987b7322df10f75ef95bc44dce781692b4b7524085de66019"}, + {file = "matplotlib-3.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:21269450243d6928da81a9bed201f0909432a74e7d0d65db5545b9fa8a0d0223"}, + {file = "matplotlib-3.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb2e76cd429058d8954121c334dddfcd11a6186c6975bca61f3f248c99031b05"}, + {file = "matplotlib-3.7.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de20eb1247725a2f889173d391a6d9e7e0f2540feda24030748283108b0478ec"}, + {file = "matplotlib-3.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c5465735eaaafd1cfaec3fed60aee776aeb3fd3992aa2e49f4635339c931d443"}, + {file = "matplotlib-3.7.0-cp310-cp310-win32.whl", hash = "sha256:092e6abc80cdf8a95f7d1813e16c0e99ceda8d5b195a3ab859c680f3487b80a2"}, + {file = "matplotlib-3.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:4f640534ec2760e270801056bc0d8a10777c48b30966eef78a7c35d8590915ba"}, + {file = "matplotlib-3.7.0-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:f336e7014889c38c59029ebacc35c59236a852e4b23836708cfd3f43d1eaeed5"}, + {file = "matplotlib-3.7.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3a10428d4f8d1a478ceabd652e61a175b2fdeed4175ab48da4a7b8deb561e3fa"}, + {file = "matplotlib-3.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46ca923e980f76d34c1c633343a72bb042d6ba690ecc649aababf5317997171d"}, + {file = "matplotlib-3.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c849aa94ff2a70fb71f318f48a61076d1205c6013b9d3885ade7f992093ac434"}, + {file = "matplotlib-3.7.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:827e78239292e561cfb70abf356a9d7eaf5bf6a85c97877f254009f20b892f89"}, + {file = "matplotlib-3.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:691ef1f15360e439886186d0db77b5345b24da12cbc4fc57b26c4826db4d6cab"}, + {file = "matplotlib-3.7.0-cp311-cp311-win32.whl", hash = "sha256:21a8aeac39b4a795e697265d800ce52ab59bdeb6bb23082e2d971f3041074f02"}, + {file = "matplotlib-3.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:01681566e95b9423021b49dea6a2395c16fa054604eacb87f0f4c439750f9114"}, + {file = "matplotlib-3.7.0-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cf119eee4e57389fba5ac8b816934e95c256535e55f0b21628b4205737d1de85"}, + {file = "matplotlib-3.7.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:21bd4033c40b95abd5b8453f036ed5aa70856e56ecbd887705c37dce007a4c21"}, + {file = "matplotlib-3.7.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:111ef351f28fd823ed7177632070a6badd6f475607122bc9002a526f2502a0b5"}, + {file = "matplotlib-3.7.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f91d35b3ef51d29d9c661069b9e4ba431ce283ffc533b981506889e144b5b40e"}, + {file = "matplotlib-3.7.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0a776462a4a63c0bfc9df106c15a0897aa2dbab6795c693aa366e8e283958854"}, + {file = "matplotlib-3.7.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0dfd4a0cbd151f6439e6d7f8dca5292839ca311e7e650596d073774847ca2e4f"}, + {file = "matplotlib-3.7.0-cp38-cp38-win32.whl", hash = "sha256:56b7b79488209041a9bf7ddc34f1b069274489ce69e34dc63ae241d0d6b4b736"}, + {file = "matplotlib-3.7.0-cp38-cp38-win_amd64.whl", hash = "sha256:8665855f3919c80551f377bc16df618ceabf3ef65270bc14b60302dce88ca9ab"}, + {file = "matplotlib-3.7.0-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:f910d924da8b9fb066b5beae0b85e34ed1b6293014892baadcf2a51da1c65807"}, + {file = "matplotlib-3.7.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:cf6346644e8fe234dc847e6232145dac199a650d3d8025b3ef65107221584ba4"}, + {file = "matplotlib-3.7.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3d1e52365d8d5af699f04581ca191112e1d1220a9ce4386b57d807124d8b55e6"}, + {file = "matplotlib-3.7.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c869b646489c6a94375714032e5cec08e3aa8d3f7d4e8ef2b0fb50a52b317ce6"}, + {file = "matplotlib-3.7.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4ddac5f59e78d04b20469bc43853a8e619bb6505c7eac8ffb343ff2c516d72f"}, + {file = "matplotlib-3.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb0304c1cd802e9a25743414c887e8a7cd51d96c9ec96d388625d2cd1c137ae3"}, + {file = "matplotlib-3.7.0-cp39-cp39-win32.whl", hash = "sha256:a06a6c9822e80f323549c6bc9da96d4f233178212ad9a5f4ab87fd153077a507"}, + {file = "matplotlib-3.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:cb52aa97b92acdee090edfb65d1cb84ea60ab38e871ba8321a10bbcebc2a3540"}, + {file = "matplotlib-3.7.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3493b48e56468c39bd9c1532566dff3b8062952721b7521e1f394eb6791495f4"}, + {file = "matplotlib-3.7.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d0dcd1a0bf8d56551e8617d6dc3881d8a1c7fb37d14e5ec12cbb293f3e6170a"}, + {file = "matplotlib-3.7.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51fb664c37714cbaac69c16d6b3719f517a13c96c3f76f4caadd5a0aa7ed0329"}, + {file = "matplotlib-3.7.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4497d88c559b76da320b7759d64db442178beeea06a52dc0c629086982082dcd"}, + {file = "matplotlib-3.7.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:9d85355c48ef8b9994293eb7c00f44aa8a43cad7a297fbf0770a25cdb2244b91"}, + {file = "matplotlib-3.7.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:03eb2c8ff8d85da679b71e14c7c95d16d014c48e0c0bfa14db85f6cdc5c92aad"}, + {file = "matplotlib-3.7.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71b751d06b2ed1fd017de512d7439c0259822864ea16731522b251a27c0b2ede"}, + {file = "matplotlib-3.7.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b51ab8a5d5d3bbd4527af633a638325f492e09e45e78afdf816ef55217a09664"}, + {file = "matplotlib-3.7.0.tar.gz", hash = "sha256:8f6efd313430d7ef70a38a3276281cb2e8646b3a22b3b21eb227da20e15e6813"}, ] [package.dependencies] contourpy = ">=1.0.1" cycler = ">=0.10" fonttools = ">=4.22.0" +importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""} kiwisolver = ">=1.0.1" -numpy = ">=1.19" +numpy = ">=1.20" packaging = ">=20.0" pillow = ">=6.2.0" -pyparsing = ">=2.2.1" +pyparsing = ">=2.3.1" python-dateutil = ">=2.7" [[package]] @@ -1380,14 +1414,14 @@ test = ["asv", "gmpy2", "mpmath", "pytest", "pytest-cov", "pytest-xdist", "sciki [[package]] name = "setuptools" -version = "67.2.0" +version = "67.3.2" description = "Easily download, build, install, upgrade, and uninstall Python packages" category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "setuptools-67.2.0-py3-none-any.whl", hash = "sha256:16ccf598aab3b506593c17378473978908a2734d7336755a8769b480906bec1c"}, - {file = "setuptools-67.2.0.tar.gz", hash = "sha256:b440ee5f7e607bb8c9de15259dba2583dd41a38879a7abc1d43a71c59524da48"}, + {file = "setuptools-67.3.2-py3-none-any.whl", hash = "sha256:bb6d8e508de562768f2027902929f8523932fcd1fb784e6d573d2cafac995a48"}, + {file = "setuptools-67.3.2.tar.gz", hash = "sha256:95f00380ef2ffa41d9bba85d95b27689d923c93dfbafed4aecd7cf988a25e012"}, ] [package.extras] @@ -1433,14 +1467,14 @@ files = [ [[package]] name = "stevedore" -version = "4.1.1" +version = "5.0.0" description = "Manage dynamic plugins for Python applications" category = "dev" optional = false python-versions = ">=3.8" files = [ - {file = "stevedore-4.1.1-py3-none-any.whl", hash = "sha256:aa6436565c069b2946fe4ebff07f5041e0c8bf18c7376dd29edf80cf7d524e4e"}, - {file = "stevedore-4.1.1.tar.gz", hash = "sha256:7f8aeb6e3f90f96832c301bff21a7eb5eefbe894c88c506483d355565d88cc1a"}, + {file = "stevedore-5.0.0-py3-none-any.whl", hash = "sha256:bd5a71ff5e5e5f5ea983880e4a1dd1bb47f8feebbb3d95b592398e2f02194771"}, + {file = "stevedore-5.0.0.tar.gz", hash = "sha256:2c428d2338976279e8eb2196f7a94910960d9f7ba2f41f3988511e95ca447021"}, ] [package.dependencies] @@ -1472,14 +1506,14 @@ files = [ [[package]] name = "typing-extensions" -version = "4.4.0" +version = "4.5.0" description = "Backported and Experimental Type Hints for Python 3.7+" category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "typing_extensions-4.4.0-py3-none-any.whl", hash = "sha256:16fa4864408f655d35ec496218b85f79b3437c829e93320c7c9215ccfd92489e"}, - {file = "typing_extensions-4.4.0.tar.gz", hash = "sha256:1511434bb92bf8dd198c12b1cc812e800d4181cfcb867674e0f8279cc93087aa"}, + {file = "typing_extensions-4.5.0-py3-none-any.whl", hash = "sha256:fb33085c39dd998ac16d1431ebc293a8b3eedd00fd4a32de0ff79002c19511b4"}, + {file = "typing_extensions-4.5.0.tar.gz", hash = "sha256:5cb5f4a79139d699607b3ef622a1dedafa84e115ab0024e0d9c044a9479ca7cb"}, ] [[package]] @@ -1518,7 +1552,23 @@ files = [ [package.extras] dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] +[[package]] +name = "zipp" +version = "3.14.0" +description = "Backport of pathlib-compatible object wrapper for zip files" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "zipp-3.14.0-py3-none-any.whl", hash = "sha256:188834565033387710d046e3fe96acfc9b5e86cbca7f39ff69cf21a4128198b7"}, + {file = "zipp-3.14.0.tar.gz", hash = "sha256:9e5421e176ef5ab4c0ad896624e87a7b2f07aca746c9b2aa305952800cb8eecb"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["flake8 (<5)", "func-timeout", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] + [metadata] lock-version = "2.0" python-versions = ">=3.9,<3.15" -content-hash = "d20710aa2622038b46baa4162c425d6290dc376a38f97de331ec50ed737ff46b" +content-hash = "0ed24074143660659315a270c224ee8ce76ebd856bfacf7e021a1c8e8c45ee96" diff --git a/pyproject.toml b/pyproject.toml index ebe868d..c021d56 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "statista" -version = "0.2.0" +version = "0.3.0" description = "statistics package" authors = ["Mostafa Farrag "] readme = "README.md" @@ -24,8 +24,8 @@ classifiers=[ [tool.poetry.dependencies] python = ">=3.9,<3.15" -numpy = "^1.24.1" -matplotlib = "^3.6.3" +numpy = "^1.24.2" +matplotlib = "^3.7.0" pandas = "^1.5.3" scipy = "^1.9.0" scikit-learn = "^1.2.1" @@ -36,10 +36,11 @@ loguru = "^0.6.0" [tool.poetry.dev-dependencies] pytest = "^7.2.1" pytest-cov = "^4.0.0" -pre-commit = "^3.0.2" -black = "^22.12.0" +pre-commit = "^3.0.4" +black = "^23.1.0" +flake8 = "^6.0.0" flake8-bandit = "^4.1.1" -flake8-bugbear = "^23.1.20" +flake8-bugbear = "^23.2.13" flake8-docstrings = "^1.7.0" flake8-rst-docstrings = "^0.3.0" pep8-naming = "^0.13.3" diff --git a/statista/confidence_interval.py b/statista/confidence_interval.py new file mode 100644 index 0000000..ab0717d --- /dev/null +++ b/statista/confidence_interval.py @@ -0,0 +1,121 @@ +"""Confidence interval module.""" +from collections import OrderedDict +from loguru import logger +from typing import Union +from numpy.random import randint +import numpy as np + + +class ConfidenceInterval: + """ConfidenceInterval.""" + + def __init__(self): + pass + + @staticmethod + def BSIndexes(data, n_samples=10000) -> np.ndarray: + """BSIndexes. + + - generate random indeces to shuffle the data of the given array. + - using the indeces, you can access the given data array and obtain randomly generated data from the + original given data. + - Given data points data, where axis 0 is considered to delineate points, return a generator for + sets of bootstrap indexes. + + This can be used as a list of bootstrap indexes (with + list(bootstrap_indexes(data))) as well. + + Returns + ------- + np.ndarray + array with the same length as the input data, containing integer indeces. + + Examples + -------- + >>> data = [3.1, 2.4, 5.6, 8.4] + >>> indeces = ConfidenceInterval.BSIndexes(data, n_samples=2) + >>> print(indeces) + >>> [1, 4, 4, 3] + >>> print(indeces) + >>> [2, 3, 1, 2] + """ + for _ in range(n_samples): + yield randint(data.shape[0], size=(data.shape[0],)) + + @staticmethod + def BootStrap( + data: Union[list, np.ndarray], + statfunction, + alpha: float = 0.05, + n_samples: int = 100, + **kargs, + ): # -> Dict[str, OrderedDict[str, Tuple[Any, Any]]] + """Calculate confidence intervals using parametric bootstrap and the percentil interval method This is used to obtain confidence intervals for the estimators and the return values for several return values. + + More info about bootstrapping can be found on: + - Efron: "An Introduction to the Bootstrap", Chapman & Hall (1993) + - https://en.wikipedia.org/wiki/Bootstrapping_%28statistics%29 + + parameters: + ----------- + alpha : [numeric] + alpha or SignificanceLevel is a value of the confidence interval. + kwargs : + gevfit : [list] + list of the three parameters of the GEV distribution [shape, loc, scale] + F : [list] + non exceedence probability/ cdf + """ + alphas = np.array([alpha / 2, 1 - alpha / 2]) + tdata = (np.array(data),) + + # We don't need to generate actual samples; that would take more memory. + # Instead, we can generate just the indexes, and then apply the statfun + # to those indexes. + bootindexes = ConfidenceInterval.BSIndexes(tdata[0], n_samples) + stat = np.array( + [ + statfunction(*(x[indexes] for x in tdata), **kargs) + for indexes in bootindexes + ] + ) + stat.sort(axis=0) + + # Percentile Interval Method + avals = alphas + nvals = np.round((n_samples - 1) * avals).astype("int") + + if np.any(nvals == 0) or np.any(nvals == n_samples - 1): + logger.debug( + "Some values used extremal samples; results are probably unstable." + ) + # warnings.warn( + # "Some values used extremal samples; results are probably unstable.", + # InstabilityWarning, + # ) + elif np.any(nvals < 10) or np.any(nvals >= n_samples - 10): + logger.debug( + "Some values used top 10 low/high samples; results may be unstable." + ) + # warnings.warn( + # "Some values used top 10 low/high samples; results may be unstable.", + # InstabilityWarning, + # ) + + if nvals.ndim == 1: + # All nvals are the same. Simple broadcasting + out = stat[nvals] + else: + # Nvals are different for each data point. Not simple broadcasting. + # Each set of nvals along axis 0 corresponds to the data at the same + # point in other axes. + out = stat[(nvals, np.indices(nvals.shape)[1:].squeeze())] + + UB = out[0, 3:] + LB = out[1, 3:] + params = OrderedDict() + params["shape"] = (out[0, 0], out[1, 0]) + params["location"] = (out[0, 1], out[1, 1]) + params["scale"] = (out[0, 2], out[1, 3]) + + return {"LB": LB, "UB": UB, "params": params} diff --git a/statista/distributions.py b/statista/distributions.py index 287b12c..3d73f88 100644 --- a/statista/distributions.py +++ b/statista/distributions.py @@ -1,20 +1,16 @@ -from collections import OrderedDict -from typing import Any, List, Tuple, Union # Dict, +"""Statistical distributions.""" +from typing import Any, List, Tuple, Union +from matplotlib.figure import Figure -import matplotlib.pyplot as plt import numpy as np - -# import scipy as sp import scipy.optimize as so -from loguru import logger -from matplotlib import gridspec -from matplotlib.figure import Figure from numpy import ndarray -from numpy.random import randint -from scipy.stats import chisquare, genextreme, gumbel_r, ks_2samp, norm +from scipy.stats import chisquare, genextreme, gumbel_r, ks_2samp, norm, expon from statista.parameters import Lmoments from statista.tools import Tools as st +from statista.plot import Plot +from statista.confidence_interval import ConfidenceInterval ninf = 1e-5 @@ -153,7 +149,7 @@ def pdf( ) pdf_fitted = self.pdf(loc, scale, actualdata=Qx) - fig, ax = plot.pdf( + fig, ax = Plot.pdf( Qx, pdf_fitted, self.data_sorted, @@ -207,7 +203,7 @@ def cdf( cdf_Weibul = PlottingPosition.weibul(self.data_sorted) - fig, ax = plot.cdf( + fig, ax = Plot.cdf( Qx, cdf_fitted, self.data_sorted, @@ -324,7 +320,7 @@ def estimateParameter( elif method == "lmoments": LM = Lmoments(self.data) LMU = LM.Lmom() - Param = Lmoments.Gumbel(LMU) + Param = Lmoments.gumbel(LMU) elif method == "optimization": if ObjFunc is None or threshold is None: raise TypeError("threshold should be numeric value") @@ -542,7 +538,7 @@ def probapilityPlot( pdf_fitted = self.pdf(loc, scale, actualdata=Qx) cdf_fitted = self.cdf(loc, scale, actualdata=Qx) - fig, ax = plot.details( + fig, ax = Plot.details( Qx, Qth, self.data, @@ -649,11 +645,11 @@ def pdf( ts = actualdata pdf = [] - for i in range(len(ts)): - z = (ts[i] - loc) / scale + for ts_i in ts: + z = (ts_i - loc) / scale if shape == 0: - val = np.exp(-(z + np.exp(-z))) - pdf.append((1 / scale) * val) + val = (1 / scale) * (np.exp(-(z + np.exp(-z)))) + pdf.append(val) continue y = 1 - shape * z @@ -661,8 +657,8 @@ def pdf( # np.log(y) = ln(y) # ln is the inverse of e lnY = (-1 / shape) * np.log(y) - val = np.exp(-(1 - shape) * lnY - np.exp(-lnY)) - pdf.append((1 / scale) * val) + val = (1 / scale) * (np.exp(-(1 - shape) * lnY - np.exp(-lnY))) + pdf.append(val) continue # y = 1 + shape * z @@ -691,7 +687,7 @@ def pdf( ) pdf_fitted = self.pdf(shape, loc, scale, actualdata=Qx) - fig, ax = plot.pdf( + fig, ax = Plot.pdf( Qx, pdf_fitted, self.data_sorted, @@ -736,9 +732,9 @@ def cdf( else: y = 1 - shape * z cdf = list() - for i in range(0, len(y)): - if y[i] > ninf: - logY = -np.log(y[i]) / shape + for y_i in y: + if y_i > ninf: + logY = -np.log(y_i) / shape cdf.append(np.exp(-np.exp(-logY))) elif shape < 0: cdf.append(0) @@ -755,7 +751,7 @@ def cdf( cdf_Weibul = PlottingPosition.weibul(self.data_sorted) - fig, ax = plot.cdf( + fig, ax = Plot.cdf( Qx, cdf_fitted, self.data_sorted, @@ -852,7 +848,7 @@ def estimateParameter( elif method == "lmoments": LM = Lmoments(self.data) LMU = LM.Lmom() - Param = Lmoments.GEV(LMU) + Param = Lmoments.gev(LMU) elif method == "optimization": if ObjFunc is None or threshold is None: raise TypeError("ObjFunc and threshold should be numeric value") @@ -1088,7 +1084,7 @@ def probapilityPlot( Qth = self.theporeticalEstimate(shape, loc, scale, F) if func is None: - func = ConfidenceInterval.GEVfunc + func = GEV.ci_func Param_dist = [shape, loc, scale] CI = ConfidenceInterval.BootStrap( @@ -1103,7 +1099,7 @@ def probapilityPlot( pdf_fitted = self.pdf(shape, loc, scale, actualdata=Qx) cdf_fitted = self.cdf(shape, loc, scale, actualdata=Qx) - fig, ax = plot.details( + fig, ax = Plot.details( Qx, Qth, self.data, @@ -1122,104 +1118,22 @@ def probapilityPlot( return fig, ax - -class ConfidenceInterval: - """ConfidenceInterval.""" - - def __init__(self): - pass + # The function to bootstrap @staticmethod - def BSIndexes(data, n_samples=10000): - """Given data points data, where axis 0 is considered to delineate points, return an generator for sets of bootstrap indexes. - - This can be used as a list of bootstrap indexes (with - list(bootstrap_indexes(data))) as well. - """ - for _ in range(n_samples): - yield randint(data.shape[0], size=(data.shape[0],)) - - def BootStrap( - data: Union[list, np.ndarray], - statfunction, - alpha: float = 0.05, - n_samples: int = 100, - **kargs, - ): # -> Dict[str, OrderedDict[str, Tuple[Any, Any]]] - """Calculate confidence intervals using parametric bootstrap and the percentil interval method This is used to obtain confidence intervals for the estimators and the return values for several return values. + def ci_func(data: Union[list, np.ndarray], **kwargs): + """GEV distribution function. - More info about bootstrapping can be found on: - - Efron: "An Introduction to the Bootstrap", Chapman & Hall (1993) - - https://en.wikipedia.org/wiki/Bootstrapping_%28statistics%29 - - parameters: - ----------- - alpha : [numeric] - alpha or SignificanceLevel is a value of the confidence interval. - kwargs : - gevfit : [list] - list of the three parameters of the GEV distribution [shape, loc, scale] - F : [list] - non exceedence probability/ cdf + Parameters + ---------- + data: [list, np.ndarray] + time series + kwargs: + - gevfit: [list] + GEV parameter [shape, location, scale] + - F: [list] + Non Exceedence probability """ - alphas = np.array([alpha / 2, 1 - alpha / 2]) - tdata = (np.array(data),) - - # We don't need to generate actual samples; that would take more memory. - # Instead, we can generate just the indexes, and then apply the statfun - # to those indexes. - bootindexes = ConfidenceInterval.BSIndexes(tdata[0], n_samples) - stat = np.array( - [ - statfunction(*(x[indexes] for x in tdata), **kargs) - for indexes in bootindexes - ] - ) - stat.sort(axis=0) - - # Percentile Interval Method - avals = alphas - nvals = np.round((n_samples - 1) * avals).astype("int") - - if np.any(nvals == 0) or np.any(nvals == n_samples - 1): - logger.debug( - "Some values used extremal samples; results are probably unstable." - ) - # warnings.warn( - # "Some values used extremal samples; results are probably unstable.", - # InstabilityWarning, - # ) - elif np.any(nvals < 10) or np.any(nvals >= n_samples - 10): - logger.debug( - "Some values used top 10 low/high samples; results may be unstable." - ) - # warnings.warn( - # "Some values used top 10 low/high samples; results may be unstable.", - # InstabilityWarning, - # ) - - if nvals.ndim == 1: - # All nvals are the same. Simple broadcasting - out = stat[nvals] - else: - # Nvals are different for each data point. Not simple broadcasting. - # Each set of nvals along axis 0 corresponds to the data at the same - # point in other axes. - out = stat[(nvals, np.indices(nvals.shape)[1:].squeeze())] - - UB = out[0, 3:] - LB = out[1, 3:] - params = OrderedDict() - params["shape"] = (out[0, 0], out[1, 0]) - params["location"] = (out[0, 1], out[1, 1]) - params["scale"] = (out[0, 2], out[1, 3]) - - return {"LB": LB, "UB": UB, "params": params} - - # The function to bootstrap - @staticmethod - def GEVfunc(data, **kwargs): - gevfit = kwargs["gevfit"] F = kwargs["F"] shape = gevfit[0] @@ -1230,7 +1144,7 @@ def GEVfunc(data, **kwargs): # get parameters based on the new generated sample LM = Lmoments(sample) mum = LM.Lmom() - newfit = LM.GEV(mum) + newfit = LM.gev(mum) shape = newfit[0] loc = newfit[1] scale = newfit[2] @@ -1247,158 +1161,539 @@ def GEVfunc(data, **kwargs): return tuple(res) -class plot: - """plot.""" +class Exponential: - def __init__(self): - pass + """ + f(x: threshold, scale) = (1/scale) e **(- (x-threshold)/scale) + + """ + + def __init__( + self, + data: Union[list, np.ndarray] = None, + loc: Union[int, float] = None, + scale: Union[int, float] = None, + ): + """Gumbel. + + Parameters + ---------- + data : [list] + data time series. + loc: [numeric] + location parameter + scale: [numeric] + scale parameter + """ + if isinstance(data, list) or isinstance(data, np.ndarray): + self.data = np.array(data) + self.data_sorted = np.sort(data) + self.cdf_Weibul = PlottingPosition.weibul(data) + self.KStable = 1.22 / np.sqrt(len(self.data)) + + self.loc = loc + self.scale = scale + self.Dstatic = None + self.KS_Pvalue = None + self.chistatic = None + self.chi_Pvalue = None def pdf( - Qx: np.ndarray, - pdf_fitted, - data_sorted: np.ndarray, + self, + loc: Union[float, int], + scale: Union[float, int], + plot_figure: bool = False, figsize: tuple = (6, 5), xlabel: str = "Actual data", ylabel: str = "pdf", - fontsize: int = 15, - ): + fontsize: Union[float, int] = 15, + actualdata: Union[bool, np.ndarray] = True, + ) -> Union[Tuple[np.ndarray, Figure, Any], np.ndarray]: """pdf. - Parameters - ---------- - pdf_fitted - data_sorted - figsize - xlabel - ylabel - fontsize + Returns the value of Gumbel's pdf with parameters loc and scale at x . + + Parameters: + ----------- + loc : [numeric] + location parameter of the gumbel distribution. + scale : [numeric] + scale parameter of the gumbel distribution. Returns ------- + pdf : [array] + probability density function pdf. """ - fig = plt.figure(figsize=figsize) - # gs = gridspec.GridSpec(nrows=1, ncols=2, figure=fig) - # Plot the histogram and the fitted distribution, save it for each gauge. - ax = fig.add_subplot() - ax.plot(Qx, pdf_fitted, "r-") - ax.hist(data_sorted, density=True) - ax.set_xlabel(xlabel, fontsize=fontsize) - ax.set_ylabel(ylabel, fontsize=fontsize) - return fig, ax + if scale <= 0: + raise ValueError("Scale parameter is negative") + + if isinstance(actualdata, bool): + ts = self.data + else: + ts = actualdata + + # pdf = [] + # + # for i in ts: + # Y = (i - loc) / scale + # if Y <= 0: + # pdf.append(0) + # else: + # pdf.append(np.exp(-Y) / scale) + # + # if len(pdf) == 1: + # pdf = pdf[0] + + pdf = expon.pdf(ts, loc=loc, scale=scale) + if plot_figure: + Qx = np.linspace( + float(self.data_sorted[0]), 1.5 * float(self.data_sorted[-1]), 10000 + ) + pdf_fitted = self.pdf(loc, scale, actualdata=Qx) + + fig, ax = Plot.pdf( + Qx, + pdf_fitted, + self.data_sorted, + figsize=figsize, + xlabel=xlabel, + ylabel=ylabel, + fontsize=fontsize, + ) + return pdf, fig, ax + else: + return pdf - @staticmethod def cdf( - Qx, - cdf_fitted, - data_sorted, - cdf_Weibul, - figsize=(6, 5), - xlabel="Actual data", - ylabel="cdf", - fontsize=15, - ): + self, + loc: Union[float, int], + scale: Union[float, int], + plot_figure: bool = False, + figsize: tuple = (6, 5), + xlabel: str = "data", + ylabel: str = "cdf", + fontsize: int = 15, + actualdata: Union[bool, np.ndarray] = True, + ) -> Union[Tuple[np.ndarray, Figure, Any], np.ndarray]: """cdf. + cdf calculates the value of Gumbel's cdf with parameters loc and scale at x. + + parameter: + ---------- + 1- loc : [numeric] + location parameter of the gumbel distribution. + 2- scale : [numeric] + scale parameter of the gumbel distribution. + """ + if scale <= 0: + raise ValueError("Scale parameter is negative") + if loc <= 0: + raise ValueError("Threshold parameter should be greater than zero") + + if isinstance(actualdata, bool): + ts = self.data + else: + ts = actualdata + + # Y = (ts - loc) / scale + # cdf = 1 - np.exp(-Y) + # + # for i in range(0, len(cdf)): + # if cdf[i] < 0: + # cdf[i] = 0 + cdf = expon.cdf(ts, loc=loc, scale=scale) + + if plot_figure: + Qx = np.linspace( + float(self.data_sorted[0]), 1.5 * float(self.data_sorted[-1]), 10000 + ) + cdf_fitted = self.cdf(loc, scale, actualdata=Qx) + + cdf_Weibul = PlottingPosition.weibul(self.data_sorted) + + fig, ax = Plot.cdf( + Qx, + cdf_fitted, + self.data_sorted, + cdf_Weibul, + figsize=figsize, + xlabel=xlabel, + ylabel=ylabel, + fontsize=fontsize, + ) + + return cdf, fig, ax + else: + return cdf + + def estimateParameter( + self, + method: str = "mle", + ObjFunc=None, + threshold: Union[int, float, None] = None, + test: bool = True, + ) -> tuple: + """estimateParameter. + + EstimateParameter estimate the distribution parameter based on MLM + (Maximum liklihood method), if an objective function is entered as an input + + There are two likelihood functions (L1 and L2), one for values above some + threshold (x>=C) and one for values below (x < C), now the likeliest parameters + are those at the max value of mutiplication between two functions max(L1*L2). + + In this case the L1 is still the product of multiplication of probability + density function's values at xi, but the L2 is the probability that threshold + value C will be exceeded (1-F(C)). + Parameters ---------- - Qx - cdf_fitted - data_sorted - cdf_Weibul - figsize - xlabel - ylabel - fontsize + ObjFunc : [function] + function to be used to get the distribution parameters. + threshold : [numeric] + Value you want to consider only the greater values. + method : [string] + 'mle', 'mm', 'lmoments', optimization + test: bool + Default is True Returns ------- + Param : [list] + shape, loc, scale parameter of the gumbel distribution in that order. """ - fig = plt.figure(figsize=figsize) - ax = fig.add_subplot() - ax.plot(Qx, cdf_fitted, "r-", label="Fitted distribution") - ax.plot(data_sorted, cdf_Weibul, ".-", label="Weibul plotting position") - ax.set_xlabel(xlabel, fontsize=fontsize) - ax.set_ylabel(ylabel, fontsize=fontsize) - plt.legend(fontsize=fontsize, framealpha=1) - return fig, ax + # obj_func = lambda p, x: (-np.log(Gumbel.pdf(x, p[0], p[1]))).sum() + # #first we make a simple Gumbel fit + # Par1 = so.fmin(obj_func, [0.5,0.5], args=(np.array(data),)) + method = method.lower() + if method not in ["mle", "mm", "lmoments", "optimization"]: + raise ValueError( + method + "value should be 'mle', 'mm', 'lmoments' or 'optimization'" + ) + + if method == "mle" or method == "mm": + Param = list(expon.fit(self.data, method=method)) + elif method == "lmoments": + LM = Lmoments(self.data) + LMU = LM.Lmom() + Param = Lmoments.gev(LMU) + elif method == "optimization": + if ObjFunc is None or threshold is None: + raise TypeError("ObjFunc and threshold should be numeric value") + + Param = expon.fit(self.data, method="mle") + # then we use the result as starting value for your truncated Gumbel fit + Param = so.fmin( + ObjFunc, + [threshold, Param[0], Param[1]], + args=(self.data,), + maxiter=500, + maxfun=500, + ) + Param = [Param[1], Param[2]] + + self.loc = Param[0] + self.scale = Param[1] + + if test: + self.ks() + try: + self.chisquare() + except ValueError: + print("chisquare test failed") + + return Param @staticmethod - def details( - Qx: Union[np.ndarray, list], - Qth: Union[np.ndarray, list], - Qact: Union[np.ndarray, list], - pdf: Union[np.ndarray, list], - cdf_fitted: Union[np.ndarray, list], - F: Union[np.ndarray, list], - Qlower: Union[np.ndarray, list], - Qupper: Union[np.ndarray, list], - alpha: float, - fig1size: tuple = (10, 5), - fig2size: tuple = (6, 6), + def theporeticalEstimate( + loc: Union[float, int], + scale: Union[float, int], + F: np.ndarray, + ) -> np.ndarray: + """TheporeticalEstimate. + + TheporeticalEstimate method calculates the theoretical values based on a given non exceedence probability + + Parameters: + ----------- + param : [list] + location ans scale parameters of the gumbel distribution. + F : [list] + cummulative distribution function/ Non Exceedence probability. + + Return: + ------- + theoreticalvalue : [numeric] + Value based on the theoretical distribution + """ + if scale <= 0: + raise ValueError("Parameters Invalid") + + if any(F) < 0 or any(F) > 1: + raise ValueError("cdf Value Invalid") + + # the main equation from scipy + Qth = expon.ppf(F, loc=loc, scale=scale) + return Qth + + +class Normal: + + """ + f(x: threshold, scale) = (1/scale) e **(- (x-threshold)/scale) + + """ + + def __init__( + self, + data: Union[list, np.ndarray] = None, + loc: Union[int, float] = None, + scale: Union[int, float] = None, + ): + """Gumbel. + + Parameters + ---------- + data : [list] + data time series. + loc: [numeric] + location parameter + scale: [numeric] + scale parameter + """ + if isinstance(data, list) or isinstance(data, np.ndarray): + self.data = np.array(data) + self.data_sorted = np.sort(data) + self.cdf_Weibul = PlottingPosition.weibul(data) + self.KStable = 1.22 / np.sqrt(len(self.data)) + + self.loc = loc + self.scale = scale + self.Dstatic = None + self.KS_Pvalue = None + self.chistatic = None + self.chi_Pvalue = None + + def pdf( + self, + loc: Union[float, int], + scale: Union[float, int], + plot_figure: bool = False, + figsize: tuple = (6, 5), xlabel: str = "Actual data", + ylabel: str = "pdf", + fontsize: Union[float, int] = 15, + actualdata: Union[bool, np.ndarray] = True, + ) -> Union[Tuple[np.ndarray, Figure, Any], np.ndarray]: + """pdf. + + Returns the value of Gumbel's pdf with parameters loc and scale at x . + + Parameters: + ----------- + loc : [numeric] + location parameter of the gumbel distribution. + scale : [numeric] + scale parameter of the gumbel distribution. + + Returns + ------- + pdf : [array] + probability density function pdf. + """ + if scale <= 0: + raise ValueError("Scale parameter is negative") + + if isinstance(actualdata, bool): + ts = self.data + else: + ts = actualdata + + pdf = norm.pdf(ts, loc=loc, scale=scale) + if plot_figure: + Qx = np.linspace( + float(self.data_sorted[0]), 1.5 * float(self.data_sorted[-1]), 10000 + ) + pdf_fitted = self.pdf(loc, scale, actualdata=Qx) + + fig, ax = Plot.pdf( + Qx, + pdf_fitted, + self.data_sorted, + figsize=figsize, + xlabel=xlabel, + ylabel=ylabel, + fontsize=fontsize, + ) + return pdf, fig, ax + else: + return pdf + + def cdf( + self, + loc: Union[float, int], + scale: Union[float, int], + plot_figure: bool = False, + figsize: tuple = (6, 5), + xlabel: str = "data", ylabel: str = "cdf", fontsize: int = 15, - ) -> Tuple[List[Figure], List[Any]]: - """details. + actualdata: Union[bool, np.ndarray] = True, + ) -> Union[Tuple[np.ndarray, Figure, Any], np.ndarray]: + """cdf. + + cdf calculates the value of Gumbel's cdf with parameters loc and scale at x. + + parameter: + ---------- + 1- loc : [numeric] + location parameter of the gumbel distribution. + 2- scale : [numeric] + scale parameter of the gumbel distribution. + """ + if scale <= 0: + raise ValueError("Scale parameter is negative") + if loc <= 0: + raise ValueError("Threshold parameter should be greater than zero") + + if isinstance(actualdata, bool): + ts = self.data + else: + ts = actualdata + + cdf = norm.cdf(ts, loc=loc, scale=scale) + + if plot_figure: + Qx = np.linspace( + float(self.data_sorted[0]), 1.5 * float(self.data_sorted[-1]), 10000 + ) + cdf_fitted = self.cdf(loc, scale, actualdata=Qx) + + cdf_Weibul = PlottingPosition.weibul(self.data_sorted) + + fig, ax = Plot.cdf( + Qx, + cdf_fitted, + self.data_sorted, + cdf_Weibul, + figsize=figsize, + xlabel=xlabel, + ylabel=ylabel, + fontsize=fontsize, + ) + + return cdf, fig, ax + else: + return cdf + + def estimateParameter( + self, + method: str = "mle", + ObjFunc=None, + threshold: Union[int, float, None] = None, + test: bool = True, + ) -> tuple: + """estimateParameter. + + EstimateParameter estimate the distribution parameter based on MLM + (Maximum liklihood method), if an objective function is entered as an input + + There are two likelihood functions (L1 and L2), one for values above some + threshold (x>=C) and one for values below (x < C), now the likeliest parameters + are those at the max value of mutiplication between two functions max(L1*L2). + + In this case the L1 is still the product of multiplication of probability + density function's values at xi, but the L2 is the probability that threshold + value C will be exceeded (1-F(C)). Parameters ---------- - Qx - Qth - Qact - pdf - cdf_fitted - F - Qlower - Qupper - alpha - fig1size - fig2size - xlabel - ylabel - fontsize + ObjFunc : [function] + function to be used to get the distribution parameters. + threshold : [numeric] + Value you want to consider only the greater values. + method : [string] + 'mle', 'mm', 'lmoments', optimization + test: bool + Default is True Returns ------- + Param : [list] + shape, loc, scale parameter of the gumbel distribution in that order. """ - fig1 = plt.figure(figsize=fig1size) - gs = gridspec.GridSpec(nrows=1, ncols=2, figure=fig1) - # Plot the histogram and the fitted distribution, save it for each gauge. - ax1 = fig1.add_subplot(gs[0, 0]) - ax1.plot(Qx, pdf, "r-") - ax1.hist(Qact, density=True) - ax1.set_xlabel(xlabel, fontsize=fontsize) - ax1.set_ylabel("pdf", fontsize=fontsize) - - ax2 = fig1.add_subplot(gs[0, 1]) - ax2.plot(Qx, cdf_fitted, "r-") - Qact.sort() - ax2.plot(Qact, F, ".-") - ax2.set_xlabel(xlabel, fontsize=fontsize) - ax2.set_ylabel(ylabel, fontsize=15) - - fig2 = plt.figure(figsize=fig2size) - plt.plot(Qth, Qact, "d", color="#606060", markersize=12, label="Actual Data") - plt.plot(Qth, Qth, "^-.", color="#3D59AB", label="Theoretical Data") - - plt.plot( - Qth, - Qlower, - "*--", - color="#DC143C", - markersize=12, - label="Lower limit (" + str(int((1 - alpha) * 100)) + " % CI)", - ) - plt.plot( - Qth, - Qupper, - "*--", - color="#DC143C", - markersize=12, - label="Upper limit (" + str(int((1 - alpha) * 100)) + " % CI)", - ) - plt.legend(fontsize=fontsize, framealpha=1) - plt.xlabel("Theoretical Values", fontsize=fontsize) - plt.ylabel("Actual Values", fontsize=fontsize) + # obj_func = lambda p, x: (-np.log(Gumbel.pdf(x, p[0], p[1]))).sum() + # #first we make a simple Gumbel fit + # Par1 = so.fmin(obj_func, [0.5,0.5], args=(np.array(data),)) + method = method.lower() + if method not in ["mle", "mm", "lmoments", "optimization"]: + raise ValueError( + method + "value should be 'mle', 'mm', 'lmoments' or 'optimization'" + ) + + if method == "mle" or method == "mm": + Param = list(norm.fit(self.data, method=method)) + elif method == "lmoments": + LM = Lmoments(self.data) + LMU = LM.Lmom() + Param = Lmoments.normal(LMU) + elif method == "optimization": + if ObjFunc is None or threshold is None: + raise TypeError("ObjFunc and threshold should be numeric value") + + Param = norm.fit(self.data, method="mle") + # then we use the result as starting value for your truncated Gumbel fit + Param = so.fmin( + ObjFunc, + [threshold, Param[0], Param[1]], + args=(self.data,), + maxiter=500, + maxfun=500, + ) + Param = [Param[1], Param[2]] + + self.loc = Param[0] + self.scale = Param[1] - return [fig1, fig2], [ax1, ax2] + if test: + self.ks() + try: + self.chisquare() + except ValueError: + print("chisquare test failed") + + return Param + + @staticmethod + def theporeticalEstimate( + loc: Union[float, int], + scale: Union[float, int], + F: np.ndarray, + ) -> np.ndarray: + """TheporeticalEstimate. + + TheporeticalEstimate method calculates the theoretical values based on a given non exceedence probability + + Parameters: + ----------- + param : [list] + location ans scale parameters of the gumbel distribution. + F : [list] + cummulative distribution function/ Non Exceedence probability. + + Return: + ------- + theoreticalvalue : [numeric] + Value based on the theoretical distribution + """ + if scale <= 0: + raise ValueError("Parameters Invalid") + + if any(F) < 0 or any(F) > 1: + raise ValueError("cdf Value Invalid") + + # the main equation from scipy + Qth = norm.ppf(F, loc=loc, scale=scale) + return Qth diff --git a/statista/eva.py b/statista/eva.py index 00ea3f1..1e890d9 100644 --- a/statista/eva.py +++ b/statista/eva.py @@ -1,6 +1,6 @@ """Extreme value analysis.""" import os -from typing import Union +from typing import Union, Tuple import matplotlib.pyplot as plt import numpy as np @@ -22,7 +22,7 @@ def ams_analysis( estimate_parameters: bool = False, quartile: float = 0, significance_level: float = 0.1, -): +) -> Tuple[DataFrame, DataFrame]: """StatisticalProperties. ams analysis method reads resamples all the the time series in the given dataframe to annual maximum, then fits @@ -51,7 +51,8 @@ def ams_analysis( estimate_parameters: [bool] Default is False. quartile: [float] - Default is 0. + the quartile is only used when estinating the distribution parameters based on optimization and a threshould + value, the threshould value will be calculated as a the quartile coresponding to the value of this parameter. significance_level: Default is [0.1]. @@ -157,16 +158,22 @@ def ams_analysis( threshold=threshold, ) else: - # estimate the parameters through an maximum liklehood method - if distribution == "GEV": - dist = GEV(ams) - # defult parameter estimation method is maximum liklihood method - param_dist = dist.estimateParameter(method=method) - else: - # A gumbel distribution is fitted to the annual maxima - dist = Gumbel(ams) - # defult parameter estimation method is maximum liklihood method - param_dist = dist.estimateParameter(method=method) + # estimate the parameters through maximum liklehood method + try: + if distribution == "GEV": + dist = GEV(ams) + # defult parameter estimation method is maximum liklihood method + param_dist = dist.estimateParameter(method=method) + else: + # A gumbel distribution is fitted to the annual maxima + dist = Gumbel(ams) + # defult parameter estimation method is maximum liklihood method + param_dist = dist.estimateParameter(method=method) + except Exception as e: + logger.warning( + f"The gauge {i} parameters could not be estimated because of {e}" + ) + continue ( distribution_properties.loc[i, "D-static"], diff --git a/statista/parameters.py b/statista/parameters.py index 3d21af0..deaab94 100644 --- a/statista/parameters.py +++ b/statista/parameters.py @@ -1,12 +1,26 @@ """L moments.""" +from __future__ import annotations + +from typing import Any, List, Union import numpy as np import scipy as sp +import scipy.special as _spsp +from numpy import ndarray + ninf = 1e-5 +MAXIT = 20 +EPS = 1e-6 +# Euler's constant +EU = 0.577215664901532861 class Lmoments: - """Hosking (1990) introduced the concept of L-moments, which are quantities that can be directly interpreted as scale and shape descriptors of probability distributions The L-moments of order r, denoted by λr. + """Lmoments. + + Hosking (1990) introduced the concept of L-moments, which are quantities that + can be directly interpreted as scale and shape descriptors of probability distributions + The L-moments of order r, denoted by λr. λ1 = α0 = β0 λ2 = α0 - 2α1 = 2β1 - β0 @@ -19,23 +33,27 @@ def __init__(self, data): pass def Lmom(self, nmom=5): + """Calculates the Lmoments.""" if nmom <= 5: - var = self.samlmusmall(nmom) - return var + var = self._samlmusmall(nmom) else: - var = self.samlmularge(nmom) - return var + var = self._samlmularge(nmom) + + return var @staticmethod - def comb(N, k): + def _comb(N, k): + """sum [(N-j)/(j+1)]""" if (k > N) or (N < 0) or (k < 0): - return 0 - val = 1 - for j in range(min(k, N - k)): - val = (val * (N - j)) // (j + 1) + val = 0 + else: + val = 1 + for j in range(min(k, N - k)): + val = (val * (N - j)) // (j + 1) # // is floor division return val - def samlmularge(self, nmom=5): + def _samlmularge(self, nmom: int = 5) -> list[ndarray | float | int | Any]: + """Large sample L moment.""" x = self.data if nmom <= 0: @@ -48,8 +66,7 @@ def samlmularge(self, nmom=5): raise ValueError("Insufficient length of data for specified nmoments") ## Calculate first order - ## Pretty efficient, no loops - coefl1 = 1.0 / self.comb(n, 1) + coefl1 = 1.0 / self._comb(n, 1) suml1 = sum(x) l = [coefl1 * suml1] @@ -61,11 +78,11 @@ def samlmularge(self, nmom=5): for i in range(1, nmom): comb.append([]) for j in range(n): - comb[-1].append(self.comb(j, i)) + comb[-1].append(self._comb(j, i)) for mom in range(2, nmom + 1): ## print(mom) - coefl = 1.0 / mom * 1.0 / self.comb(n, mom) + coefl = 1.0 / mom * 1.0 / self._comb(n, mom) xtrans = [] for i in range(0, n): coeftemp = [] @@ -79,7 +96,7 @@ def samlmularge(self, nmom=5): coeftemp[j] = coeftemp[j] * comb[j - 1][n - i - 1] for j in range(0, mom): - coeftemp[j] = coeftemp[j] * self.comb(mom - 1, j) + coeftemp[j] = coeftemp[j] * self._comb(mom - 1, j) for j in range(0, int(0.5 * mom)): coeftemp[j * 2 + 1] = -coeftemp[j * 2 + 1] @@ -92,31 +109,29 @@ def samlmularge(self, nmom=5): l.append(coefl * sum(xtrans)) return l - def samlmusmall(self, nmom=5): - x = self.data + def _samlmusmall(self, nmom: int = 5) -> list[ndarray | float | int | Any]: + """Small sample L-Moments.""" + sample = self.data if nmom <= 0: raise ValueError("Invalid number of Sample L-Moments") - x = sorted(x) - n = len(x) + sample = sorted(sample) + n = len(sample) if n < nmom: raise ValueError("Insufficient length of data for specified nmoments") - ## Pretty efficient, no loops - coefl1 = 1.0 / self.comb(n, 1) - - suml1 = sum(x) - l1 = coefl1 * suml1 - + # coefl1 = 1.0 / self._comb(n, 1) # coefl1 = 1/n + # suml1 = sum(sample) + # l_moment_1 = coefl1 * suml1 # l_moment_1 = mean(sample) + l_moment_1 = np.mean(sample) if nmom == 1: - ret = l1 - return ret + return [l_moment_1] # comb terms appear elsewhere, this will decrease calc time # for nmom > 2, and shouldn't decrease time for nmom == 2 - # comb(x,1) = x + # comb(sample,1) = sample # for i in range(1,n+1): ## comb1.append(comb(i-1,1)) ## comb2.append(comb(n-i,1)) @@ -125,17 +140,16 @@ def samlmusmall(self, nmom=5): comb1 = range(0, n) comb2 = range(n - 1, -1, -1) - coefl2 = 0.5 * 1.0 / self.comb(n, 2) + coefl2 = 0.5 * 1.0 / self._comb(n, 2) xtrans = [] for i in range(0, n): coeftemp = comb1[i] - comb2[i] - xtrans.append(coeftemp * x[i]) + xtrans.append(coeftemp * sample[i]) - l2 = coefl2 * sum(xtrans) + l_moment_2 = coefl2 * sum(xtrans) if nmom == 2: - ret = [l1, l2] - return ret + return [l_moment_1, l_moment_2] ## Calculate Third order # comb terms appear elsewhere, this will decrease calc time @@ -145,21 +159,20 @@ def samlmusmall(self, nmom=5): comb3 = [] comb4 = [] for i in range(0, n): - combtemp = self.comb(i, 2) + combtemp = self._comb(i, 2) comb3.append(combtemp) comb4.insert(0, combtemp) - coefl3 = 1.0 / 3 * 1.0 / self.comb(n, 3) + coefl3 = 1.0 / 3 * 1.0 / self._comb(n, 3) xtrans = [] for i in range(0, n): coeftemp = comb3[i] - 2 * comb1[i] * comb2[i] + comb4[i] - xtrans.append(coeftemp * x[i]) + xtrans.append(coeftemp * sample[i]) - l3 = coefl3 * sum(xtrans) / l2 + l_moment_3 = coefl3 * sum(xtrans) / l_moment_2 if nmom == 3: - ret = [l1, l2, l3] - return ret + return [l_moment_1, l_moment_2, l_moment_3] ## Calculate Fourth order # comb5 = comb(i-1,3) @@ -167,33 +180,32 @@ def samlmusmall(self, nmom=5): comb5 = [] comb6 = [] for i in range(0, n): - combtemp = self.comb(i, 3) + combtemp = self._comb(i, 3) comb5.append(combtemp) comb6.insert(0, combtemp) - coefl4 = 1.0 / 4 * 1.0 / self.comb(n, 4) + coefl4 = 1.0 / 4 * 1.0 / self._comb(n, 4) xtrans = [] for i in range(0, n): coeftemp = ( comb5[i] - 3 * comb3[i] * comb2[i] + 3 * comb1[i] * comb4[i] - comb6[i] ) - xtrans.append(coeftemp * x[i]) + xtrans.append(coeftemp * sample[i]) - l4 = coefl4 * sum(xtrans) / l2 + l_moment_4 = coefl4 * sum(xtrans) / l_moment_2 if nmom == 4: - ret = [l1, l2, l3, l4] - return ret + return [l_moment_1, l_moment_2, l_moment_3, l_moment_4] ## Calculate Fifth order comb7 = [] comb8 = [] for i in range(0, n): - combtemp = self.comb(i, 4) + combtemp = self._comb(i, 4) comb7.append(combtemp) comb8.insert(0, combtemp) - coefl5 = 1.0 / 5 * 1.0 / self.comb(n, 5) + coefl5 = 1.0 / 5 * 1.0 / self._comb(n, 5) xtrans = [] for i in range(0, n): coeftemp = ( @@ -203,23 +215,31 @@ def samlmusmall(self, nmom=5): - 4 * comb1[i] * comb6[i] + comb8[i] ) - xtrans.append(coeftemp * x[i]) + xtrans.append(coeftemp * sample[i]) - l5 = coefl5 * sum(xtrans) / l2 + l_moment_5 = coefl5 * sum(xtrans) / l_moment_2 if nmom == 5: - ret = [l1, l2, l3, l4, l5] - return ret + return [l_moment_1, l_moment_2, l_moment_3, l_moment_4, l_moment_5] @staticmethod - def GEV(xmom): - """Estimate the generalized extreme value distribution parameters using Lmoments method.""" - eps = 1e-6 - maxit = 20 - # euler constant - EU = 0.57721566 + def gev(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """Generalized Extreme Value distribution. + + Estimate the generalized extreme value distribution parameters using Lmoments method. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ DL2 = np.log(2) DL3 = np.log(3) + # COEFFICIENTS OF RATIONAL-FUNCTION APPROXIMATIONS FOR XI A0 = 0.28377530 A1 = -1.21096399 A2 = -2.50728214 @@ -234,9 +254,9 @@ def GEV(xmom): D1 = -0.64363929 D2 = 0.08985247 - T3 = xmom[2] + T3 = lmoments[2] # if std <= 0 or third moment > 1 - if xmom[1] <= 0 or abs(T3) >= 1: + if lmoments[1] <= 0 or abs(T3) >= 1: raise ValueError("L-Moments Invalid") if T3 <= 0: @@ -246,8 +266,8 @@ def GEV(xmom): if T3 >= -0.8: shape = G GAM = np.exp(sp.special.gammaln(1 + G)) - scale = xmom[1] * G / (GAM * (1 - 2 ** (-G))) - loc = xmom[0] - scale * (1 - GAM) / G + scale = lmoments[1] * G / (GAM * (1 - 2 ** (-G))) + loc = lmoments[0] - scale * (1 - GAM) / G para = [shape, loc, scale] return para @@ -255,7 +275,7 @@ def GEV(xmom): G = 1 - np.log(1 + T3) / DL2 T0 = (T3 + 3) * 0.5 - for IT in range(1, maxit): + for IT in range(1, MAXIT): X2 = 2 ** (-G) X3 = 3 ** (-G) XX2 = 1 - X2 @@ -264,38 +284,549 @@ def GEV(xmom): DERIV = (XX2 * X3 * DL3 - XX3 * X2 * DL2) / (XX2**2) GOLD = G G = G - (T - T0) / DERIV - if abs(G - GOLD) <= eps * G: + if abs(G - GOLD) <= EPS * G: shape = G GAM = np.exp(sp.special.gammaln(1 + G)) - scale = xmom[1] * G / (GAM * (1 - 2 ** (-G))) - loc = xmom[0] - scale * (1 - GAM) / G + scale = lmoments[1] * G / (GAM * (1 - 2 ** (-G))) + loc = lmoments[0] - scale * (1 - GAM) / G para = [shape, loc, scale] return para + raise Exception("Iteration has not converged") + else: + Z = 1 - T3 + G = (-1 + Z * (C1 + Z * (C2 + Z * C3))) / (1 + Z * (D1 + Z * D2)) + if abs(G) < ninf: + scale = lmoments[1] / DL2 + loc = lmoments[0] - EU * scale + para = [0, loc, scale] + else: + shape = G + GAM = np.exp(sp.special.gammaln(1 + G)) + scale = lmoments[1] * G / (GAM * (1 - 2 ** (-G))) + loc = lmoments[0] - scale * (1 - GAM) / G + para = [shape, loc, scale] - print("Iteration has not converged") + return para - Z = 1 - T3 - G = (-1 + Z * (C1 + Z * (C2 + Z * C3))) / (1 + Z * (D1 + Z * D2)) - if abs(G) < ninf: - scale = xmom[1] / DL2 - loc = xmom[0] - EU * scale - para = [0, loc, scale] + @staticmethod + def gumbel(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """ "Gumbel" distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + if lmoments[1] <= 0: + raise ValueError("L-Moments Invalid") + else: + para2 = lmoments[1] / np.log(2) + para1 = lmoments[0] - EU * para2 + para = [para1, para2] return para + + @staticmethod + def exponential(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """Exponential distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + if lmoments[1] <= 0: + print("L-Moments Invalid") + return else: - shape = G - GAM = np.exp(sp.special.gammaln(1 + G)) - scale = xmom[1] * G / (GAM * (1 - 2 ** (-G))) - loc = xmom[0] - scale * (1 - GAM) / G - para = [shape, loc, scale] + para = [lmoments[0] - 2 * lmoments[1], 2 * lmoments[1]] return para @staticmethod - def Gumbel(mom): - EU = 0.577215664901532861 - if mom[1] <= 0: - raise ValueError("L-Moments Invalid") + def gamma(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """Gamma distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + A1 = -0.3080 + A2 = -0.05812 + A3 = 0.01765 + B1 = 0.7213 + B2 = -0.5947 + B3 = -2.1817 + B4 = 1.2113 + + if lmoments[0] <= lmoments[1] or lmoments[1] <= 0: + print("L-Moments Invalid") + return + CV = lmoments[1] / lmoments[0] + if CV >= 0.5: + T = 1 - CV + ALPHA = T * (B1 + T * B2) / (1 + T * (B3 + T * B4)) else: - para2 = mom[1] / np.log(2) - para1 = mom[0] - EU * para2 - para = [para1, para2] + T = np.pi * CV**2 + ALPHA = (1 + A1 * T) / (T * (1 + T * (A2 + T * A3))) + + para = [ALPHA, lmoments[0] / ALPHA] + return para + + @staticmethod + def generalized_logistic( + lmoments: List[Union[float, int]] + ) -> List[Union[float, int]]: + """Generalized logistic distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + SMALL = 1e-6 + + G = -lmoments[2] + if lmoments[1] <= 0 or abs(G) >= 1: + print("L-Moments Invalid") + return + + if abs(G) <= SMALL: + para = [lmoments[0], lmoments[1], 0] + return para + + GG = G * np.pi / sp.sin(G * np.pi) + A = lmoments[1] / GG + para1 = lmoments[0] - A * (1 - GG) / G + para = [para1, A, G] + return para + + @staticmethod + def generalized_normal( + lmoments: List[Union[float, int]] + ) -> List[Union[float, int]]: + """Generalized Normal distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + A0 = 0.20466534e01 + A1 = -0.36544371e01 + A2 = 0.18396733e01 + A3 = -0.20360244e00 + B1 = -0.20182173e01 + B2 = 0.12420401e01 + B3 = -0.21741801e00 + SMALL = 1e-8 + + T3 = lmoments[2] + if lmoments[1] <= 0 or abs(T3) >= 1: + print("L-Moments Invalid") + return + if abs(T3) >= 0.95: + para = [0, -1, 0] + return para + + if abs(T3) <= SMALL: + para = [lmoments[0], lmoments[1] * np.sqrt(np.pi), 0] + + TT = T3**2 + G = ( + -T3 + * (A0 + TT * (A1 + TT * (A2 + TT * A3))) + / (1 + TT * (B1 + TT * (B2 + TT * B3))) + ) + E = sp.exp(0.5 * G**2) + A = lmoments[1] * G / (E * sp.special.erf(0.5 * G)) + U = lmoments[0] + A * (E - 1) / G + para = [U, A, G] + return para + + @staticmethod + def generalized_pareto( + lmoments: List[Union[float, int]] + ) -> List[Union[float, int]]: + """Generalized Pareto distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + T3 = lmoments[2] + if lmoments[1] <= 0: + print("L-Moments Invalid") + return + if abs(T3) >= 1: + print("L-Moments Invalid") + return + + G = (1 - 3 * T3) / (1 + T3) + + PARA3 = G + PARA2 = (1 + G) * (2 + G) * lmoments[1] + PARA1 = lmoments[0] - PARA2 / (1 + G) + para = [PARA1, PARA2, PARA3] + return para + + # def kappa(lmoments): + # + # MAXSR = 10 + # HSTART = 1.001 + # BIG = 10 + # OFLEXP = 170 + # OFLGAM = 53 + # + # T3 = lmoments[2] + # T4 = lmoments[3] + # para = [0] * 4 + # if lmoments[1] <= 0: + # print("L-Moments Invalid") + # return + # if abs(T3) >= 1 or abs(T4) >= 1: + # print("L-Moments Invalid") + # return + # + # if T4 <= (5 * T3 * T3 - 1) / 4: + # print("L-Moments Invalid") + # return + # + # if T4 >= (5 * T3 * T3 + 1) / 6: + # print("L-Moments Invalid") + # return + # + # G = (1 - 3 * T3) / (1 + T3) + # H = HSTART + # Z = G + H * 0.725 + # Xdist = BIG + # + # # Newton-Raphson Iteration + # for it in range(1, MAXIT + 1): + # for i in range(1, MAXSR + 1): + # if G > OFLGAM: + # print("Failed to converge") + # return + # if H > 0: + # U1 = sp.exp(_spsp.gammaln(1 / H) - _spsp.gammaln(1 / H + 1 + G)) + # U2 = sp.exp(_spsp.gammaln(2 / H) - _spsp.gammaln(2 / H + 1 + G)) + # U3 = sp.exp(_spsp.gammaln(3 / H) - _spsp.gammaln(3 / H + 1 + G)) + # U4 = sp.exp(_spsp.gammaln(4 / H) - _spsp.gammaln(4 / H + 1 + G)) + # else: + # U1 = sp.exp(_spsp.gammaln(-1 / H - G) - _spsp.gammaln(-1 / H + 1)) + # U2 = sp.exp(_spsp.gammaln(-2 / H - G) - _spsp.gammaln(-2 / H + 1)) + # U3 = sp.exp(_spsp.gammaln(-3 / H - G) - _spsp.gammaln(-3 / H + 1)) + # U4 = sp.exp(_spsp.gammaln(-4 / H - G) - _spsp.gammaln(-4 / H + 1)) + # + # ALAM2 = U1 - 2 * U2 + # ALAM3 = -U1 + 6 * U2 - 6 * U3 + # ALAM4 = U1 - 12 * U2 + 30 * U3 - 20 * U4 + # if ALAM2 == 0: + # print("Failed to Converge") + # return + # TAU3 = ALAM3 / ALAM2 + # TAU4 = ALAM4 / ALAM2 + # E1 = TAU3 - T3 + # E2 = TAU4 - T4 + # + # DIST = max(abs(E1), abs(E2)) + # if DIST < Xdist: + # Success = 1 + # break + # else: + # DEL1 = 0.5 * DEL1 + # DEL2 = 0.5 * DEL2 + # G = XG - DEL1 + # H = XH - DEL2 + # + # if Success == 0: + # print("Failed to converge") + # return + # + # # Test for convergence + # if DIST < EPS: + # para[3] = H + # para[2] = G + # TEMP = _spsp.gammaln(1 + G) + # if TEMP > OFLEXP: + # print("Failed to converge") + # return + # GAM = sp.exp(TEMP) + # TEMP = (1 + G) * sp.log(abs(H)) + # if TEMP > OFLEXP: + # print("Failed to converge") + # return + # + # HH = sp.exp(TEMP) + # para[1] = lmoments[1] * G * HH / (ALAM2 * GAM) + # para[0] = lmoments[0] - para[1] / G * (1 - GAM * U1 / HH) + # return (para) + # else: + # XG = G + # XH = H + # XZ = Z + # Xdist = DIST + # RHH = 1 / (H ** 2) + # if H > 0: + # U1G = -U1 * _spsp.psi(1 / H + 1 + G) + # U2G = -U2 * _spsp.psi(2 / H + 1 + G) + # U3G = -U3 * _spsp.psi(3 / H + 1 + G) + # U4G = -U4 * _spsp.psi(4 / H + 1 + G) + # U1H = RHH * (-U1G - U1 * _spsp.psi(1 / H)) + # U2H = 2 * RHH * (-U2G - U2 * _spsp.psi(2 / H)) + # U3H = 3 * RHH * (-U3G - U3 * _spsp.psi(3 / H)) + # U4H = 4 * RHH * (-U4G - U4 * _spsp.psi(4 / H)) + # else: + # U1G = -U1 * _spsp.psi(-1 / H - G) + # U2G = -U2 * _spsp.psi(-2 / H - G) + # U3G = -U3 * _spsp.psi(-3 / H - G) + # U4G = -U4 * _spsp.psi(-4 / H - G) + # U1H = RHH * (-U1G - U1 * _spsp.psi(-1 / H + 1)) + # U2H = 2 * RHH * (-U2G - U2 * _spsp.psi(-2 / H + 1)) + # U3H = 3 * RHH * (-U3G - U3 * _spsp.psi(-3 / H + 1)) + # U4H = 4 * RHH * (-U4G - U4 * _spsp.psi(-4 / H + 1)) + # + # DL2G = U1G - 2 * U2G + # DL2H = U1H - 2 * U2H + # DL3G = -U1G + 6 * U2G - 6 * U3G + # DL3H = -U1H + 6 * U2H - 6 * U3H + # DL4G = U1G - 12 * U2G + 30 * U3G - 20 * U4G + # DL4H = U1H - 12 * U2H + 30 * U3H - 20 * U4H + # D11 = (DL3G - TAU3 * DL2G) / ALAM2 + # D12 = (DL3H - TAU3 * DL2H) / ALAM2 + # D21 = (DL4G - TAU4 * DL2G) / ALAM2 + # D22 = (DL4H - TAU4 * DL2H) / ALAM2 + # DET = D11 * D22 - D12 * D21 + # H11 = D22 / DET + # H12 = -D12 / DET + # H21 = -D21 / DET + # H22 = D11 / DET + # DEL1 = E1 * H11 + E2 * H12 + # DEL2 = E1 * H21 + E2 * H22 + # + # ## TAKE NEXT N-R STEP + # G = XG - DEL1 + # H = XH - DEL2 + # Z = G + H * 0.725 + # + # ## REDUCE STEP IF G AND H ARE OUTSIDE THE PARAMETER _spACE + # FACTOR = 1 + # if G <= -1: + # FACTOR = 0.8 * (XG + 1) / DEL1 + # if H <= -1: + # FACTOR = min(FACTOR, 0.8 * (XH + 1) / DEL2) + # if Z <= -1: + # FACTOR = min(FACTOR, 0.8 * (XZ + 1) / (XZ - Z)) + # if H <= 0 and G * H <= -1: + # FACTOR = min(FACTOR, 0.8 * (XG * XH + 1) / (XG * XH - G * H)) + # + # if FACTOR == 1: + # pass + # else: + # DEL1 = DEL1 * FACTOR + # DEL2 = DEL2 * FACTOR + # G = XG - DEL1 + # H = XH - DEL2 + # Z = G + H * 0.725 + + @staticmethod + def normal(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """Normal distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + if lmoments[1] <= 0: + print("L-Moments Invalid") + return + else: + para = [lmoments[0], lmoments[1] * np.sqrt(np.pi)] + return para + + @staticmethod + def pearson_3(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """Pearson III (PE3) distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + Small = 1e-6 + # Constants used in Minimax Approx: + + C1 = 0.2906 + C2 = 0.1882 + C3 = 0.0442 + D1 = 0.36067 + D2 = -0.59567 + D3 = 0.25361 + D4 = -2.78861 + D5 = 2.56096 + D6 = -0.77045 + + T3 = abs(lmoments[2]) + if lmoments[1] <= 0 or T3 >= 1: + para = [0] * 3 + print("L-Moments Invalid") + return para + + if T3 <= Small: + para = [] + para.append(lmoments[0]) + para.append(lmoments[1] * np.sqrt(np.pi)) + para.append(0) return para + + if T3 >= (1.0 / 3): + T = 1 - T3 + Alpha = T * (D1 + T * (D2 + T * D3)) / (1 + T * (D4 + T * (D5 + T * D6))) + else: + T = 3 * np.pi * T3 * T3 + Alpha = (1 + C1 * T) / (T * (1 + T * (C2 + T * C3))) + + RTALPH = np.sqrt(Alpha) + BETA = ( + np.sqrt(np.pi) + * lmoments[1] + * sp.exp(_spsp.gammaln(Alpha) - _spsp.gammaln(Alpha + 0.5)) + ) + para = [] + para.append(lmoments[0]) + para.append(BETA * RTALPH) + para.append(2 / RTALPH) + if lmoments[2] < 0: + para[2] = -para[2] + + return para + + @staticmethod + def wakeby(lmoments: List[Union[float, int]]) -> List[Union[float, int]]: + """wakeby distribution. + + Parameters + ---------- + lmoments: List + list of l moments + + Returns + ------- + List of distribution parameters + """ + if lmoments[1] <= 0: + print("Invalid L-Moments") + return () + if abs(lmoments[2]) >= 1 or abs(lmoments[3]) >= 1 or abs(lmoments[4]) >= 1: + print("Invalid L-Moments") + return () + + ALAM1 = lmoments[0] + ALAM2 = lmoments[1] + ALAM3 = lmoments[2] * ALAM2 + ALAM4 = lmoments[3] * ALAM2 + ALAM5 = lmoments[4] * ALAM2 + + XN1 = 3 * ALAM2 - 25 * ALAM3 + 32 * ALAM4 + XN2 = -3 * ALAM2 + 5 * ALAM3 + 8 * ALAM4 + XN3 = 3 * ALAM2 + 5 * ALAM3 + 2 * ALAM4 + XC1 = 7 * ALAM2 - 85 * ALAM3 + 203 * ALAM4 - 125 * ALAM5 + XC2 = -7 * ALAM2 + 25 * ALAM3 + 7 * ALAM4 - 25 * ALAM5 + XC3 = 7 * ALAM2 + 5 * ALAM3 - 7 * ALAM4 - 5 * ALAM5 + + XA = XN2 * XC3 - XC2 * XN3 + XB = XN1 * XC3 - XC1 * XN3 + XC = XN1 * XC2 - XC1 * XN2 + DISC = XB * XB - 4 * XA * XC + skip20 = 0 + if DISC < 0: + pass + else: + DISC = np.sqrt(DISC) + ROOT1 = 0.5 * (-XB + DISC) / XA + ROOT2 = 0.5 * (-XB - DISC) / XA + B = max(ROOT1, ROOT2) + D = -min(ROOT1, ROOT2) + if D >= 1: + pass + else: + A = ( + (1 + B) + * (2 + B) + * (3 + B) + / (4 * (B + D)) + * ((1 + D) * ALAM2 - (3 - D) * ALAM3) + ) + C = ( + -(1 - D) + * (2 - D) + * (3 - D) + / (4 * (B + D)) + * ((1 - B) * ALAM2 - (3 + B) * ALAM3) + ) + XI = ALAM1 - A / (1 + B) - C / (1 - D) + if C >= 0 and A + C >= 0: + skip20 = 1 + + if skip20 == 0: + # IFAIL = 1 + D = -(1 - 3 * lmoments[2]) / (1 + lmoments[2]) + C = (1 - D) * (2 - D) * lmoments[1] + B = 0 + A = 0 + XI = lmoments[0] - C / (1 - D) + if D <= 0: + A = C + B = -D + C = 0 + D = 0 + + para = [XI, A, B, C, D] + return para + + # TODO: add the function lmrgum + # def weibull(lmoments): + # if len(lmoments) < 3: + # print("Insufficient L-Moments: Need 3") + # return + # if lmoments[1] <= 0 or lmoments[2] >= 1 or lmoments[2] <= -lmoments.lmrgum([0, 1], 3)[2]: + # print("L-Moments Invalid") + # return + # pg = Lmoments.GEV([-lmoments[0], lmoments[1], -lmoments[2]]) + # delta = 1 / pg[2] + # beta = pg[1] / pg[2] + # out = [-pg[0] - beta, beta, delta] + # return (out) diff --git a/statista/plot.py b/statista/plot.py new file mode 100644 index 0000000..e087b18 --- /dev/null +++ b/statista/plot.py @@ -0,0 +1,185 @@ +from typing import Union, Tuple, List, Any +import matplotlib.pyplot as plt +from matplotlib import gridspec +from matplotlib.figure import Figure +import numpy as np + + +class Plot: + """plot.""" + + def __init__(self): + pass + + @staticmethod + def pdf( + Qx: np.ndarray, + pdf_fitted, + data_sorted: np.ndarray, + figsize: tuple = (6, 5), + xlabel: str = "Actual data", + ylabel: str = "pdf", + fontsize: int = 11, + ) -> Tuple[Figure, Any]: + """pdf. + + Parameters + ---------- + Qx + pdf_fitted + data_sorted + figsize + xlabel + ylabel + fontsize + + Returns + ------- + Figure: + matplotlib figure object + Axis: + matplotlib plot axis + """ + fig = plt.figure(figsize=figsize) + # gs = gridspec.GridSpec(nrows=1, ncols=2, figure=fig) + # Plot the histogram and the fitted distribution, save it for each gauge. + ax = fig.add_subplot() + ax.plot(Qx, pdf_fitted, "-", color="#27408B", linewidth=2) + ax.hist( + data_sorted, density=True, histtype="stepfilled", color="#DC143C" + ) # , alpha=0.2 + ax.set_xlabel(xlabel, fontsize=fontsize) + ax.set_ylabel(ylabel, fontsize=fontsize) + return fig, ax + + @staticmethod + def cdf( + Qx, + cdf_fitted, + data_sorted, + cdf_Weibul, + figsize=(6, 5), + xlabel="Actual data", + ylabel="cdf", + fontsize=11, + ) -> Tuple[Figure, Any]: + """cdf. + + Parameters + ---------- + Qx + cdf_fitted + data_sorted + cdf_Weibul + figsize + xlabel + ylabel + fontsize + + Returns + ------- + Figure: + matplotlib figure object + Axis: + matplotlib plot axis + """ + fig = plt.figure(figsize=figsize) + ax = fig.add_subplot() + ax.plot( + Qx, cdf_fitted, "-", label="Estimated CDF", color="#27408B", linewidth=2 + ) + ax.scatter( + data_sorted, + cdf_Weibul, + label="Empirical CDF", + color="orangered", + facecolors="none", + ) + ax.set_xlabel(xlabel, fontsize=fontsize) + ax.set_ylabel(ylabel, fontsize=fontsize) + plt.legend(fontsize=fontsize, framealpha=1) + return fig, ax + + @staticmethod + def details( + Qx: Union[np.ndarray, list], + Qth: Union[np.ndarray, list], + Qact: Union[np.ndarray, list], + pdf: Union[np.ndarray, list], + cdf_fitted: Union[np.ndarray, list], + F: Union[np.ndarray, list], + Qlower: Union[np.ndarray, list], + Qupper: Union[np.ndarray, list], + alpha: float, + fig1size: tuple = (10, 5), + fig2size: tuple = (6, 6), + xlabel: str = "Actual data", + ylabel: str = "cdf", + fontsize: int = 11, + ) -> Tuple[List[Figure], List[Any]]: + """details. + + Parameters + ---------- + Qx + Qth + Qact + pdf + cdf_fitted + F + Qlower + Qupper + alpha + fig1size + fig2size + xlabel + ylabel + fontsize + + Returns + ------- + """ + fig1 = plt.figure(figsize=fig1size) + gs = gridspec.GridSpec(nrows=1, ncols=2, figure=fig1) + # Plot the histogram and the fitted distribution, save it for each gauge. + ax1 = fig1.add_subplot(gs[0, 0]) + ax1.plot(Qx, pdf, "-", color="#27408B", linewidth=2) + ax1.hist(Qact, density=True, histtype="stepfilled", color="#DC143C") + ax1.set_xlabel(xlabel, fontsize=fontsize) + ax1.set_ylabel("pdf", fontsize=fontsize) + + ax2 = fig1.add_subplot(gs[0, 1]) + ax2.plot(Qx, cdf_fitted, "-", color="#27408B", linewidth=2) + + Qact.sort() + ax2.scatter(Qact, F, color="#DC143C", facecolors="none") + ax2.set_xlabel(xlabel, fontsize=fontsize) + ax2.set_ylabel(ylabel, fontsize=15) + + fig2 = plt.figure(figsize=fig2size) + plt.plot(Qth, Qth, "-.", color="#3D59AB", linewidth=2, label="Theoretical Data") + # confidence interval + plt.plot( + Qth, + Qlower, + "*--", + color="grey", + markersize=10, + label=f"Lower limit ({int((1 - alpha) * 100)} % CI)", + ) + plt.plot( + Qth, + Qupper, + "*--", + color="grey", + markersize=10, + label=f"Upper limit ({int((1 - alpha) * 100)} % CI)", + ) + plt.scatter( + Qth, Qact, color="#DC143C", facecolors="none", label="Actual Data" + ) # "d", markersize=12, + plt.legend(fontsize=fontsize, framealpha=1) + plt.xlabel("Theoretical Values", fontsize=fontsize) + plt.ylabel("Actual Values", fontsize=fontsize) + + return [fig1, fig2], [ax1, ax2] diff --git a/tests/test_distributions.py b/tests/test_distributions.py index 8f29f97..d2e4f23 100644 --- a/tests/test_distributions.py +++ b/tests/test_distributions.py @@ -3,7 +3,14 @@ import numpy as np from matplotlib.figure import Figure -from statista.distributions import GEV, ConfidenceInterval, Gumbel, PlottingPosition +from statista.distributions import ( + GEV, + ConfidenceInterval, + Gumbel, + PlottingPosition, + Exponential, + Normal, +) def test_plotting_position_weibul( @@ -232,7 +239,7 @@ def test_gev_confidence_interval( Gdist = GEV(time_series1) cdf_Weibul = PlottingPosition.weibul(time_series1) Param = Gdist.estimateParameter(method=dist_estimation_parameters_ks, test=False) - func = ConfidenceInterval.GEVfunc + func = GEV.ci_func upper, lower = Gdist.confidenceInterval( Param[0], Param[1], @@ -254,7 +261,7 @@ def test_confidence_interval_directly( Gdist = GEV(time_series1) cdf_Weibul = PlottingPosition.weibul(time_series1) Param = Gdist.estimateParameter(method=dist_estimation_parameters_ks, test=False) - func = ConfidenceInterval.GEVfunc + func = GEV.ci_func # upper, lower = Gdist.ConfidenceInterval( # Param[0], Param[1], Param[2], F=cdf_Weibul, alpha=confidence_interval_alpha, # statfunction=func, n_samples=len(time_series1) @@ -271,3 +278,127 @@ def test_confidence_interval_directly( assert isinstance(LB, np.ndarray) assert isinstance(UB, np.ndarray) + + +class TestExponential: + def test_create_instance( + self, + time_series1: list, + ): + Edist = Exponential(time_series1) + assert isinstance(Edist.data, np.ndarray) + assert isinstance(Edist.data_sorted, np.ndarray) + + def test_estimate_parameter( + self, + time_series2: list, + dist_estimation_parameters: List[str], + ): + Edist = Exponential(time_series2) + for i in range(len(dist_estimation_parameters)): + param = Edist.estimateParameter( + method=dist_estimation_parameters[i], test=False + ) + assert isinstance(param, list) + assert Edist.loc + assert Edist.scale + + def test_pdf( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Exponential(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + pdf, fig, ax = Edist.pdf(Param[0], Param[1], plot_figure=True) + assert isinstance(pdf, np.ndarray) + assert isinstance(fig, Figure) + + def test_cdf( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Exponential(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + cdf, fig, ax = Edist.cdf(Param[0], Param[1], plot_figure=True) + assert isinstance(cdf, np.ndarray) + assert isinstance(fig, Figure) + + def test_TheporeticalEstimate( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Exponential(time_series2) + cdf_Weibul = PlottingPosition.weibul(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + Qth = Edist.theporeticalEstimate(Param[0], Param[1], cdf_Weibul) + assert isinstance(Qth, np.ndarray) + + +class TestNormal: + def test_create_instance( + self, + time_series1: list, + ): + Edist = Normal(time_series1) + assert isinstance(Edist.data, np.ndarray) + assert isinstance(Edist.data_sorted, np.ndarray) + + def test_estimate_parameter( + self, + time_series2: list, + dist_estimation_parameters: List[str], + ): + Edist = Normal(time_series2) + for method in dist_estimation_parameters: + param = Edist.estimateParameter(method=method, test=False) + assert isinstance(param, list) + assert Edist.loc + assert Edist.scale + + def test_pdf( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Normal(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + pdf, fig, ax = Edist.pdf(Param[0], Param[1], plot_figure=True) + assert isinstance(pdf, np.ndarray) + assert isinstance(fig, Figure) + + def test_cdf( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Normal(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + cdf, fig, ax = Edist.cdf(Param[0], Param[1], plot_figure=True) + assert isinstance(cdf, np.ndarray) + assert isinstance(fig, Figure) + + def test_TheporeticalEstimate( + self, + time_series2: list, + dist_estimation_parameters_ks: str, + ): + Edist = Normal(time_series2) + cdf_Weibul = PlottingPosition.weibul(time_series2) + Param = Edist.estimateParameter( + method=dist_estimation_parameters_ks, test=False + ) + Qth = Edist.theporeticalEstimate(Param[0], Param[1], cdf_Weibul) + assert isinstance(Qth, np.ndarray)