From 49ecd4784c1acab324ff66868c48c84131462803 Mon Sep 17 00:00:00 2001 From: user Date: Sun, 12 Jul 2026 14:22:00 +0400 Subject: [PATCH] Initial commit --- HashTable.pro | 85 ++ Installer/script.iss | 38 + QuestionsXML/questions.xml | 101 ++ SourceCode/BusinessLogic/Convert/convert.cpp | 22 + SourceCode/BusinessLogic/Convert/convert.h | 24 + .../Algorithm/Family/creatorDoubleHashing.h | 34 + .../Hash/Algorithm/Family/creatorFamily.h | 24 + .../Family/creatorPseudorandomProbing.h | 34 + .../Hash/Algorithm/Family/doubleHashing.h | 41 + .../Hash/Algorithm/Family/family.h | 36 + .../Algorithm/Family/pseudorandomProbing.h | 44 + .../Hash/Algorithm/One/creatorLinearProbing.h | 35 + .../Hash/Algorithm/One/creatorOne.h | 24 + .../Algorithm/One/creatorQuadraticProbing.h | 30 + .../Hash/Algorithm/One/linearProbing.h | 41 + .../BusinessLogic/Hash/Algorithm/One/one.h | 36 + .../Hash/Algorithm/One/quadraticProbing.h | 36 + .../BusinessLogic/Hash/Algorithm/abstract.h | 101 ++ .../Hash/Algorithm/creatorAbstract.h | 29 + .../BusinessLogic/Hash/Factory/abstract.h | 48 + .../BusinessLogic/Hash/Factory/family.h | 46 + SourceCode/BusinessLogic/Hash/Factory/one.h | 46 + .../Hash/Function/Family/creatorFamily.h | 27 + .../Hash/Function/Family/creatorFnv1a.h | 25 + .../Hash/Function/Family/family.h | 39 + .../Hash/Function/Family/fnv1a.h | 40 + .../Hash/Function/One/creatorEquivalent.h | 25 + .../Hash/Function/One/creatorOne.h | 27 + .../Hash/Function/One/creatorStandart.h | 24 + .../Hash/Function/One/equivalent.h | 35 + .../BusinessLogic/Hash/Function/One/one.h | 37 + .../Hash/Function/One/standart.h | 37 + .../Function/Pattern/creatorFamilyToOne.h | 36 + .../Hash/Function/Pattern/familyToOne.h | 30 + .../BusinessLogic/Hash/Function/abstract.h | 30 + .../Hash/Function/creatorAbstract.h | 27 + .../Hash/Table/Pattern/subscriber.h | 58 ++ .../BusinessLogic/Hash/Table/abstract.h | 60 ++ SourceCode/BusinessLogic/Hash/Table/chains.h | 93 ++ .../BusinessLogic/Hash/Table/openAddress.h | 82 ++ SourceCode/BusinessLogic/Pattern/singleton.h | 37 + .../BusinessLogic/Statistics/dispersion.cpp | 18 + .../BusinessLogic/Statistics/dispersion.h | 25 + SourceCode/BusinessLogic/businessLogic.h | 102 ++ SourceCode/BusinessLogic/debug.cpp | 197 ++++ SourceCode/BusinessLogic/hashHeaderFiles.h | 32 + .../ManualHTML/Images/demonstration.png | Bin 0 -> 146171 bytes SourceCode/ManualHTML/Images/menubarFirst.png | Bin 0 -> 3575 bytes .../ManualHTML/Images/menubarSecond.png | Bin 0 -> 4213 bytes SourceCode/ManualHTML/Images/testingPage.png | Bin 0 -> 36377 bytes SourceCode/ManualHTML/Images/theory.png | Bin 0 -> 54014 bytes SourceCode/ManualHTML/Images/theoryPage.png | Bin 0 -> 44902 bytes .../ManualHTML/Pages/demonstration.html | 84 ++ SourceCode/ManualHTML/Pages/main.html | 33 + SourceCode/ManualHTML/Pages/menubar.html | 57 + SourceCode/ManualHTML/Pages/testingPage.html | 67 ++ SourceCode/ManualHTML/Pages/theory.html | 63 ++ SourceCode/ManualHTML/Pages/theoryPage.html | 50 + SourceCode/ManualHTML/info.xml | 13 + .../ClassesUI/Validator/validator.h | 21 + .../Demonstration/demonstrationWidget.cpp | 564 ++++++++++ .../Demonstration/demonstrationWidget.h | 233 +++++ .../Widgets/Testing/testingWidget.cpp | 284 +++++ .../ClassesUI/Widgets/Testing/testingWidget.h | 71 ++ .../Widgets/TextBrowser/textBrowserWidget.cpp | 112 ++ .../Widgets/TextBrowser/textBrowserWidget.h | 50 + .../Windows/MainWindow/mainWindow.cpp | 154 +++ .../ClassesUI/Windows/MainWindow/mainWindow.h | 29 + .../FilesUI/demonstrationWidget.ui | 972 ++++++++++++++++++ .../UserInterface/FilesUI/mainWindow.ui | 261 +++++ .../UserInterface/FilesUI/testingWidget.ui | 381 +++++++ .../FilesUI/textBrowserWidget.ui | 91 ++ SourceCode/main.cpp | 11 + SourceCode/resources.qrc | 17 + TheoryHTML/Images/2.1.png | Bin 0 -> 12761 bytes TheoryHTML/Images/2.2.png | Bin 0 -> 47425 bytes TheoryHTML/Images/6.1.png | Bin 0 -> 42054 bytes TheoryHTML/Images/7.1.png | Bin 0 -> 11986 bytes TheoryHTML/Images/7.2.png | Bin 0 -> 42118 bytes TheoryHTML/Images/8.1.png | Bin 0 -> 1479 bytes TheoryHTML/Pages/analysis.html | 139 +++ TheoryHTML/Pages/binaryRelationship.html | 149 +++ TheoryHTML/Pages/chainMethod.html | 56 + TheoryHTML/Pages/dirichletPrinciple.html | 52 + TheoryHTML/Pages/hashFunction.html | 102 ++ TheoryHTML/Pages/hashTable.html | 120 +++ TheoryHTML/Pages/introduction.html | 116 +++ TheoryHTML/Pages/main.html | 170 +++ TheoryHTML/Pages/openAddressing.html | 274 +++++ TheoryHTML/info.xml | 16 + 90 files changed, 6910 insertions(+) create mode 100644 HashTable.pro create mode 100644 Installer/script.iss create mode 100644 QuestionsXML/questions.xml create mode 100644 SourceCode/BusinessLogic/Convert/convert.cpp create mode 100644 SourceCode/BusinessLogic/Convert/convert.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorDoubleHashing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorFamily.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorPseudorandomProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/doubleHashing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/family.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/Family/pseudorandomProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/creatorLinearProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/creatorOne.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/creatorQuadraticProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/linearProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/one.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/One/quadraticProbing.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/abstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Algorithm/creatorAbstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Factory/abstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Factory/family.h create mode 100644 SourceCode/BusinessLogic/Hash/Factory/one.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Family/creatorFamily.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Family/creatorFnv1a.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Family/family.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Family/fnv1a.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/creatorEquivalent.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/creatorOne.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/creatorStandart.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/equivalent.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/one.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/One/standart.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Pattern/creatorFamilyToOne.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/Pattern/familyToOne.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/abstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Function/creatorAbstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Table/Pattern/subscriber.h create mode 100644 SourceCode/BusinessLogic/Hash/Table/abstract.h create mode 100644 SourceCode/BusinessLogic/Hash/Table/chains.h create mode 100644 SourceCode/BusinessLogic/Hash/Table/openAddress.h create mode 100644 SourceCode/BusinessLogic/Pattern/singleton.h create mode 100644 SourceCode/BusinessLogic/Statistics/dispersion.cpp create mode 100644 SourceCode/BusinessLogic/Statistics/dispersion.h create mode 100644 SourceCode/BusinessLogic/businessLogic.h create mode 100644 SourceCode/BusinessLogic/debug.cpp create mode 100644 SourceCode/BusinessLogic/hashHeaderFiles.h create mode 100644 SourceCode/ManualHTML/Images/demonstration.png create mode 100644 SourceCode/ManualHTML/Images/menubarFirst.png create mode 100644 SourceCode/ManualHTML/Images/menubarSecond.png create mode 100644 SourceCode/ManualHTML/Images/testingPage.png create mode 100644 SourceCode/ManualHTML/Images/theory.png create mode 100644 SourceCode/ManualHTML/Images/theoryPage.png create mode 100644 SourceCode/ManualHTML/Pages/demonstration.html create mode 100644 SourceCode/ManualHTML/Pages/main.html create mode 100644 SourceCode/ManualHTML/Pages/menubar.html create mode 100644 SourceCode/ManualHTML/Pages/testingPage.html create mode 100644 SourceCode/ManualHTML/Pages/theory.html create mode 100644 SourceCode/ManualHTML/Pages/theoryPage.html create mode 100644 SourceCode/ManualHTML/info.xml create mode 100644 SourceCode/UserInterface/ClassesUI/Validator/validator.h create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.cpp create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.cpp create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.cpp create mode 100644 SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h create mode 100644 SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.cpp create mode 100644 SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h create mode 100644 SourceCode/UserInterface/FilesUI/demonstrationWidget.ui create mode 100644 SourceCode/UserInterface/FilesUI/mainWindow.ui create mode 100644 SourceCode/UserInterface/FilesUI/testingWidget.ui create mode 100644 SourceCode/UserInterface/FilesUI/textBrowserWidget.ui create mode 100644 SourceCode/main.cpp create mode 100644 SourceCode/resources.qrc create mode 100644 TheoryHTML/Images/2.1.png create mode 100644 TheoryHTML/Images/2.2.png create mode 100644 TheoryHTML/Images/6.1.png create mode 100644 TheoryHTML/Images/7.1.png create mode 100644 TheoryHTML/Images/7.2.png create mode 100644 TheoryHTML/Images/8.1.png create mode 100644 TheoryHTML/Pages/analysis.html create mode 100644 TheoryHTML/Pages/binaryRelationship.html create mode 100644 TheoryHTML/Pages/chainMethod.html create mode 100644 TheoryHTML/Pages/dirichletPrinciple.html create mode 100644 TheoryHTML/Pages/hashFunction.html create mode 100644 TheoryHTML/Pages/hashTable.html create mode 100644 TheoryHTML/Pages/introduction.html create mode 100644 TheoryHTML/Pages/main.html create mode 100644 TheoryHTML/Pages/openAddressing.html create mode 100644 TheoryHTML/info.xml diff --git a/HashTable.pro b/HashTable.pro new file mode 100644 index 0000000..7992869 --- /dev/null +++ b/HashTable.pro @@ -0,0 +1,85 @@ +TEMPLATE = app + +QMAKE_CXXFLAGS += -O2 -finline-small-functions -momit-leaf-frame-pointer #-mpreferred-stack-boundary=2 + +#QMAKE_CXXFLAGS_DEBUG += -pg +#QMAKE_LFLAGS_DEBUG += -pg + +CONFIG += \ + c++14 \ + #release + +QT += \ + widgets \ + core \ + gui \ + charts \ + xml + +RESOURCES += \ + SourceCode/resources.qrc + +FORMS += \ + SourceCode/UserInterface/FilesUI/demonstrationWidget.ui \ + SourceCode/UserInterface/FilesUI/mainWindow.ui \ + SourceCode/UserInterface/FilesUI/testingWidget.ui \ + SourceCode/UserInterface/FilesUI/textBrowserWidget.ui + +HEADERS += \ + SourceCode/BusinessLogic/Convert/convert.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorDoubleHashing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorFamily.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorPseudorandomProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/doubleHashing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/family.h \ + SourceCode/BusinessLogic/Hash/Algorithm/Family/pseudorandomProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/creatorLinearProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/creatorOne.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/creatorQuadraticProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/linearProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/one.h \ + SourceCode/BusinessLogic/Hash/Algorithm/One/quadraticProbing.h \ + SourceCode/BusinessLogic/Hash/Algorithm/abstract.h \ + SourceCode/BusinessLogic/Hash/Algorithm/creatorAbstract.h \ + SourceCode/BusinessLogic/Hash/Factory/abstract.h \ + SourceCode/BusinessLogic/Hash/Factory/family.h \ + SourceCode/BusinessLogic/Hash/Factory/one.h \ + SourceCode/BusinessLogic/Hash/Function/Family/creatorFamily.h \ + SourceCode/BusinessLogic/Hash/Function/Family/creatorFnv1a.h \ + SourceCode/BusinessLogic/Hash/Function/Family/family.h \ + SourceCode/BusinessLogic/Hash/Function/Family/fnv1a.h \ + SourceCode/BusinessLogic/Hash/Function/One/creatorEquivalent.h \ + SourceCode/BusinessLogic/Hash/Function/One/creatorOne.h \ + SourceCode/BusinessLogic/Hash/Function/One/equivalent.h \ + SourceCode/BusinessLogic/Hash/Function/One/one.h \ + SourceCode/BusinessLogic/Hash/Function/One/creatorStandart.h \ + SourceCode/BusinessLogic/Hash/Function/One/standart.h \ + SourceCode/BusinessLogic/Hash/Function/Pattern/creatorFamilyToOne.h \ + SourceCode/BusinessLogic/Hash/Function/Pattern/familyToOne.h \ + SourceCode/BusinessLogic/Hash/Function/abstract.h \ + SourceCode/BusinessLogic/Hash/Function/creatorAbstract.h \ + SourceCode/BusinessLogic/Hash/Table/Pattern/subscriber.h \ + SourceCode/BusinessLogic/Hash/Table/abstract.h \ + SourceCode/BusinessLogic/Hash/Table/chains.h \ + SourceCode/BusinessLogic/Hash/Table/openAddress.h \ + SourceCode/BusinessLogic/Pattern/singleton.h \ + SourceCode/BusinessLogic/Statistics/dispersion.h \ + SourceCode/BusinessLogic/businessLogic.h \ + SourceCode/BusinessLogic/hashHeaderFiles.h \ + SourceCode/UserInterface/ClassesUI/Validator/validator.h \ + SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h \ + SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h \ + SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h \ + SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h + +SOURCES += \ + SourceCode/BusinessLogic/Convert/convert.cpp \ + SourceCode/BusinessLogic/Statistics/dispersion.cpp \ + SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.cpp \ + SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.cpp \ + SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.cpp \ + SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.cpp \ + SourceCode/main.cpp + #SourceCode/BusinessLogic/debug.cpp + + diff --git a/Installer/script.iss b/Installer/script.iss new file mode 100644 index 0000000..99c8f96 --- /dev/null +++ b/Installer/script.iss @@ -0,0 +1,38 @@ +; Script generated by the Inno Setup Script Wizard. +; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES! + +#define MyAppName "Inserting into a hash table" +#define MyAppVersion "1.0.0" +#define MyAppExeName "HashTable.exe" + +[Setup] +; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications. +; (To generate a new GUID, click Tools | Generate GUID inside the IDE.) +AppId={{E9AC9BF2-18C1-4A8D-9576-5A1B632AC7F7} +AppName={#MyAppName} +AppVersion={#MyAppVersion} +;AppVerName={#MyAppName} {#MyAppVersion} +DefaultDirName={autopf}\HashTable +AllowNoIcons=yes +OutputBaseFilename=setup +Compression=lzma +SolidCompression=yes + +[Languages] +Name: "english"; MessagesFile: "compiler:Default.isl" +Name: "russian"; MessagesFile: "compiler:Languages\Russian.isl" + +[Tasks] +Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked + +[Files] +Source: "C:\Users\*\Desktop\HashTable\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion +Source: "C:\Users\*\Desktop\HashTable\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs +; NOTE: Don't use "Flags: ignoreversion" on any shared system files + +[Icons] +Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}" +Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon + +[Run] +Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent \ No newline at end of file diff --git a/QuestionsXML/questions.xml b/QuestionsXML/questions.xml new file mode 100644 index 0000000..217421f --- /dev/null +++ b/QuestionsXML/questions.xml @@ -0,0 +1,101 @@ + + + + + Соотнесите подходящие варианты ответа с высказыванием. + Метод решения коллизий в хеш-таблице. + Прямая адрессация. + Открытая адрессация. + Регистровая адресация. + Метод цепочек. + Ничего из вышеперечисленного. + + + + Выберите несколько правильных ответов. + С какими данными оперирует хеш-функция в процессе хеширования? + Хеш-память. + Хеш-значение. + Кеш-память. + Множество ключей. + Множество значений. + + + + Выберите несколько правильных ответов. + На что влияет коэффициент заполнения? + Поиск неиспользующегося бункера, при гарантии его существования. + Поиск использующегося бункера по его ключу. + Скорость хеширования. + Количество используемых бункеров. + Количество возможных ключей. + + + + Выберите несколько правильных ответов. + Какие алгоритмы поиска бункера при решении коллизий открытой адресацией используют ровно одну хеш-функцию? + Линейное пробирование. + Квадратичное пробирование. + Псевдослучайное пробирование. + Двойное хеширование. + Ничего из перечисленного. + + + + Введите правильное целочисленое число. + Чему равна дисперсия, как мера разброса элементов хеш-таблицы от средней условной величины при идеальном хешировании? + 0 + + + + Выберите варианты ответов, которые подходят по смыслу с заданным текстом. + Сопоставьте - идеальное хеширование. + Словарь. + Прямая адрессация. + Открытая адрессация. + Регистровая адресация. + Метод цепочек. + Ничего из вышеперечисленного. + + + + Определите про какие алгоритмы поиска бункера при решении коллизий открытой адресацией идёт речь? + Политика разрешения коллизий использует шаг по индексу, который зависит от информации (позиция или данные) бункера. + Линейное пробирование. + Квадратичное пробирование. + Псевдослучайное пробирование. + Двойное хеширование. + Ничего из вышеперечисленного. + + + + Определите про какие алгоритмы поиска бункера при решении коллизий открытой адресацией идёт речь? + Политика разрешения коллизий использует шаг по индексу, который зависит от количества итераций и/или размера хеш-таблицы. + Линейное пробирование. + Квадратичное пробирование. + Псевдослучайное пробирование. + Двойное хеширование. + Ничего из вышеперечисленного. + + + + Напишите правильный ответ. + Рассмотрим хеш-функцию, которая равномерно распределяет значения по хеш-таблице. + Размер хеш-таблицы равен 20. + После какого количества вставок вероятность того, что при попытке вставить в хеш-таблицу новое значение произойдёт коллизия, превысит 0.5? + 11 + + + + Напишите правильный ответ. + Чему будет равен коэффициент заполненности, если в хеш-таблица с 25 цепочками поместить 2000 элементов? + 80 + + + + Напишите правильный ответ. + Определите коэффициет заполнения хеш-таблицы с решением коллизий методом открытой адресациии, если её размер равняется 50, но свободных бункеров - 20. + 0,60 + + + \ No newline at end of file diff --git a/SourceCode/BusinessLogic/Convert/convert.cpp b/SourceCode/BusinessLogic/Convert/convert.cpp new file mode 100644 index 0000000..ae32a71 --- /dev/null +++ b/SourceCode/BusinessLogic/Convert/convert.cpp @@ -0,0 +1,22 @@ +#include "convert.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Convert) + +size_t FromStdString::operator()(const std::array &value, size_t alphabetPower) const { + if (value.empty()) { + throw std::invalid_argument("undefined key"); + } + + size_t result = 0; + size_t counter = 0; + for (auto crbegin = value.crbegin(), crend = value.crend() + ; crbegin != crend && *crbegin >= '!' && *crbegin <= '~'; ++crbegin, ++counter + ) { + result += (*crbegin) * std::pow(alphabetPower, counter); + } + return result; +} + +END_NAMESPACE // Convert +END_NAMESPACE // BusinessLogic diff --git a/SourceCode/BusinessLogic/Convert/convert.h b/SourceCode/BusinessLogic/Convert/convert.h new file mode 100644 index 0000000..ea49c12 --- /dev/null +++ b/SourceCode/BusinessLogic/Convert/convert.h @@ -0,0 +1,24 @@ +#ifndef CONVERT_H +#define CONVERT_H + +#include "../businessLogic.h" + +#include +#include +#include +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Convert) + +class FromStdString +{ +public: + size_t operator()(const std::array &, size_t) const; +}; + +END_NAMESPACE // Convert +END_NAMESPACE // BusinessLogic + +#endif // CONVERT_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorDoubleHashing.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorDoubleHashing.h new file mode 100644 index 0000000..259ab5e --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorDoubleHashing.h @@ -0,0 +1,34 @@ +#ifndef CREATOR_ALGHORITHM_DOUBLE_HASHING_H +#define CREATOR_ALGHORITHM_DOUBLE_HASHING_H + +#include "doubleHashing.h" +#include "creatorFamily.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(DoubleHashing) + +class Creator : public Family::Creator +{ +private: + size_t m_firstHashFunction; + size_t m_secondHashFunction; + +public: + Creator(size_t first, size_t second) : m_firstHashFunction(first), m_secondHashFunction(second) + { + } + +public: + virtual std::unique_ptr create() const override { + return std::unique_ptr(new Product(m_firstHashFunction, m_secondHashFunction)); + } +}; + +END_NAMESPACE // DoubleHashing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_DOUBLE_HASHING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorFamily.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorFamily.h new file mode 100644 index 0000000..8809ebd --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorFamily.h @@ -0,0 +1,24 @@ +#ifndef CREATOR_ALGHORITHM_FAMILY_H +#define CREATOR_ALGHORITHM_FAMILY_H + +#include "../creatorAbstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(Family) + +class Creator : public Abstract::Creator +{ +protected: + Creator() + { + } +}; + +END_NAMESPACE // Family +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_FAMILY_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorPseudorandomProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorPseudorandomProbing.h new file mode 100644 index 0000000..089e2e6 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/creatorPseudorandomProbing.h @@ -0,0 +1,34 @@ +#ifndef CREATOR_ALGHORITHM_PSEUDORANDOM_PROBING_H +#define CREATOR_ALGHORITHM_PSEUDORANDOM_PROBING_H + +#include "pseudorandomProbing.h" +#include "creatorFamily.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(PseudorandomProbing) + +class Creator : public Family::Creator +{ +private: + size_t m_hashFunctionNumber; + +public: + Creator(size_t number) : m_hashFunctionNumber(number) + { + } + +public: + virtual std::unique_ptr create() const override { + return std::unique_ptr(new Product(m_hashFunctionNumber)); + } + +}; + +END_NAMESPACE // PseudorandomProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_PSEUDORANDOM_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/doubleHashing.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/doubleHashing.h new file mode 100644 index 0000000..89390ad --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/doubleHashing.h @@ -0,0 +1,41 @@ +#ifndef ALGHORITHM_DOUBLE_HASHING_H +#define ALGHORITHM_DOUBLE_HASHING_H + +#include "family.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(DoubleHashing) + +class Product final : public Family::Product +{ +private: + size_t m_firstHashFunction; + size_t m_secondHashFunction; + size_t m_multiplier; +private: + friend Creator; + Product(size_t first, size_t second) : m_firstHashFunction(first), m_secondHashFunction(second) + { + if (first == second) { + throw std::invalid_argument("hash functions must be different"); + } + } + +protected: + virtual size_t getFirstCoefficient() override { + m_multiplier = m_hashFunction->getHash(m_convertValue, m_firstHashFunction); + return m_hashFunction->getHash(m_convertValue, m_firstHashFunction); + } + virtual size_t getSecondCoefficient(size_t counter) override { + return counter * m_multiplier; + } +}; + +END_NAMESPACE // DoubleHashing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_DOUBLE_HASHING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/family.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/family.h new file mode 100644 index 0000000..2f9eeed --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/family.h @@ -0,0 +1,36 @@ +#ifndef ALGHORITHM_FAMILY_H +#define ALGHORITHM_FAMILY_H + +#include "../../Function/Family/family.h" +#include "../abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(Family) + +class Product : public Abstract::Product +{ +public: + using function_type = Function::Family::Product; + +protected: + const function_type *m_hashFunction; + +protected: + Product() : m_hashFunction(nullptr) + { + } + +public: + void setHashFunction(const function_type &hashFunction) { + m_hashFunction = &hashFunction; + } +}; + +END_NAMESPACE // Family +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_FAMILY_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/Family/pseudorandomProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/Family/pseudorandomProbing.h new file mode 100644 index 0000000..d790ef7 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/Family/pseudorandomProbing.h @@ -0,0 +1,44 @@ +#ifndef ALGHORITHM_PSEUDORANDOM_PROBING_H +#define ALGHORITHM_PSEUDORANDOM_PROBING_H + +#include "family.h" + +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(PseudorandomProbing) + +class Product final : public Family::Product +{ +private: + size_t m_hashFunctionNumber; + size_t m_multiplier; + +private: + friend Creator; + Product(size_t number) : m_hashFunctionNumber(number) + { + } + +protected: +// virtual bool isValidInput() const override { +// return isPrimeNumber(size()); +// } + virtual size_t getFirstCoefficient() override { + m_multiplier = m_hashFunction->getHash(m_convertValue, m_hashFunctionNumber); + srand(m_multiplier); + return m_hashFunction->getHash(m_convertValue, m_hashFunctionNumber); + } + virtual size_t getSecondCoefficient(size_t counter) override { + return counter * rand(); + } +}; + +END_NAMESPACE // PseudorandomProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_PSEUDORANDOM_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorLinearProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorLinearProbing.h new file mode 100644 index 0000000..391b99f --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorLinearProbing.h @@ -0,0 +1,35 @@ +#ifndef CREATOR_ALGHORITHM_LINEAR_PROBING_H +#define CREATOR_ALGHORITHM_LINEAR_PROBING_H + +#include "linearProbing.h" +#include "creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(LinearProbing) + +class Creator : public One::Creator +{ +private: + /* A number that is not mutually prime to the size will not apply */ + const size_t m_coefficient; + +public: + Creator(size_t coefficient = 1) : m_coefficient(coefficient) + { + } + +public: + virtual std::unique_ptr create() const override { + return std::unique_ptr(new Product(m_coefficient)); + } + +}; + +END_NAMESPACE // LinearProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_LINEAR_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorOne.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorOne.h new file mode 100644 index 0000000..de371a4 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorOne.h @@ -0,0 +1,24 @@ +#ifndef CREATOR_ALGHORITHM_ONE_H +#define CREATOR_ALGHORITHM_ONE_H + +#include "../creatorAbstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(One) + +class Creator : public Abstract::Creator +{ +protected: + Creator() + { + } +}; + +END_NAMESPACE // One +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorQuadraticProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorQuadraticProbing.h new file mode 100644 index 0000000..58c8add --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/creatorQuadraticProbing.h @@ -0,0 +1,30 @@ +#ifndef CREATOR_ALGHORITHM_QUADRATIC_PROBING_H +#define CREATOR_ALGHORITHM_QUADRATIC_PROBING_H + +#include "quadraticProbing.h" +#include "creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(QuadraticProbing) + +class Creator : public One::Creator +{ +public: + Creator() + { + } + +public: + virtual std::unique_ptr create() const override { + return std::unique_ptr(new Product()); + } +}; + +END_NAMESPACE // LinearProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_QUADRATIC_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/linearProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/linearProbing.h new file mode 100644 index 0000000..a686dd4 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/linearProbing.h @@ -0,0 +1,41 @@ +#ifndef ALGHORITHM_LINEAR_PROBING_H +#define ALGHORITHM_LINEAR_PROBING_H + +#include "one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(LinearProbing) + +class Product final : public One::Product +{ +private: + /* A number that is not mutually prime to the size will not apply */ + const size_t m_coefficient; + +private: + friend Creator; + Product(size_t coefficient) + : m_coefficient(coefficient == 0 ? 1 : coefficient) + { + } + +protected: +// virtual bool isValidInput() const override { +// return gcd(m_coefficient, size()) == 1; +// } + virtual size_t getFirstCoefficient() override { + return m_hashFunction->getHash(m_convertValue); + } + virtual size_t getSecondCoefficient(size_t counter) override { + return counter * m_coefficient; + } +}; + +END_NAMESPACE // LinearProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_LINEAR_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/one.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/one.h new file mode 100644 index 0000000..4878f09 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/one.h @@ -0,0 +1,36 @@ +#ifndef ALGHORITHM_ONE_H +#define ALGHORITHM_ONE_H + +#include "../../Function/One/one.h" +#include "../abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(One) + +class Product : public Abstract::Product +{ +public: + using function_type = Function::One::Product; + +protected: + const function_type *m_hashFunction; + +protected: + Product() : m_hashFunction(nullptr) + { + } + +public: + void setHashFunction(const function_type &hashFunction) { + m_hashFunction = &hashFunction; + } +}; + +END_NAMESPACE // One +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/One/quadraticProbing.h b/SourceCode/BusinessLogic/Hash/Algorithm/One/quadraticProbing.h new file mode 100644 index 0000000..a36e9cb --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/One/quadraticProbing.h @@ -0,0 +1,36 @@ +#ifndef ALGHORITHM_QUADRATIC_PROBING_H +#define ALGHORITHM_QUADRATIC_PROBING_H + +#include "one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(QuadraticProbing) + +class Product final : public One::Product +{ +private: + friend Creator; + Product() + { + } + +protected: +// virtual bool isValidInput() const override { +// return isPrimeNumber(size()); +// } + virtual size_t getFirstCoefficient() override { + return m_hashFunction->getHash(m_convertValue); + } + virtual size_t getSecondCoefficient(size_t counter) override { + return std::pow(size(), counter); + } +}; + +END_NAMESPACE // LinearProbing +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_QUADRATIC_PROBING_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/abstract.h b/SourceCode/BusinessLogic/Hash/Algorithm/abstract.h new file mode 100644 index 0000000..5bd4297 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/abstract.h @@ -0,0 +1,101 @@ +#ifndef ALGHORITHM_ABSTRACT_H +#define ALGHORITHM_ABSTRACT_H + +#include "../../Convert/convert.h" + +#include +#include +#include +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(Abstract) + +class Product +{ +public: + using value_type = std::array; + +private: + const std::vector *m_table; + BusinessLogic::Convert::FromStdString m_toInteger; + +protected: + size_t m_convertValue; + +protected: + Product() : m_table(nullptr) + { + } + +protected: + size_t gcd(size_t first, size_t second) const { + while (first > 0 && second > 0) { + first > second + ? first %= second + : second %= first; + } + return first + second; + } + bool isPrimeNumber(size_t value) const { + size_t size = static_cast(sqrt(value)); + for (size_t i = 2; i <= size; i++) { + if (value % i == 0) { + return false; + } + } + return true; + } + size_t size() const { + return m_table->size(); + } + +protected: + virtual bool isValidInput() const { + return true; + } + virtual size_t getFirstCoefficient() = 0; + virtual size_t getSecondCoefficient(size_t counter) = 0; + +public: + void setTable(decltype(m_table) table) { + m_table = table; + } + + size_t getIndex(const value_type &value, size_t& numberOfCollisions, size_t alphabetPower) { + if (not isValidInput()) { + throw std::invalid_argument("the condition for using the algorithm is not met"); + } + + size_t size = m_table->size(); + m_convertValue = m_toInteger(value, alphabetPower); + // It is necessary to use some coefficient + + numberOfCollisions = 0; + decltype (m_table->cbegin()) currentIterator; + + constexpr std::array nullValue = {'\0', '\0', '\0', '\0', '\0'}; + while (numberOfCollisions <= size) { + currentIterator = { + m_table->cbegin() + + ( getFirstCoefficient() + getSecondCoefficient(numberOfCollisions) ) % size + }; + + if ( *currentIterator == nullValue || *currentIterator == value ) { // Free cell or value match + return ( currentIterator - m_table->cbegin() ); + } + ++numberOfCollisions; + } + return std::numeric_limits::max(); + } +}; + +END_NAMESPACE // Abstract +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ALGHORITHM_ABSTRACT_H diff --git a/SourceCode/BusinessLogic/Hash/Algorithm/creatorAbstract.h b/SourceCode/BusinessLogic/Hash/Algorithm/creatorAbstract.h new file mode 100644 index 0000000..7250a43 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Algorithm/creatorAbstract.h @@ -0,0 +1,29 @@ +#ifndef CREATOR_ALGHORITHM_ABSTRACT_H +#define CREATOR_ALGHORITHM_ABSTRACT_H + +#include "../../../BusinessLogic/businessLogic.h" + +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Algorithm) +BEGIN_NAMESPACE(Abstract) + +class Creator +{ +protected: + Creator() + { + } + +public: + virtual std::unique_ptr create() const = 0; +}; + +END_NAMESPACE // Abstract +END_NAMESPACE // Algorithm +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ALGHORITHM_ABSTRACT_H diff --git a/SourceCode/BusinessLogic/Hash/Factory/abstract.h b/SourceCode/BusinessLogic/Hash/Factory/abstract.h new file mode 100644 index 0000000..505fb35 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Factory/abstract.h @@ -0,0 +1,48 @@ +#ifndef FACTORY_ABSTRACT_H +#define FACTORY_ABSTRACT_H + +#include "../Function/abstract.h" +#include "../Algorithm/abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Factory) + +class Abstract +{ +public: + /* + * I used to use a constant link. This led to UB. + * + * https://eel.is/c++draft/class.temporary#6 (27.10.2021) + * + * The exceptions to this lifetime rule are: + * (6.9) A temporary object bound to a reference parameter in a function call ([expr.call]) persists until the completion of the full-expression containing the call. + */ + using AFC_type = std::shared_ptr; + using AAC_type = std::shared_ptr; + +protected: + AFC_type m_functionCreator; + AAC_type m_algorithmCreator; + +protected: + Abstract(AFC_type functionCreator, AAC_type algorithmCreator) + : m_functionCreator(functionCreator), m_algorithmCreator(algorithmCreator) + { + } + +public: + using AFP_type = Function::Abstract::Product; + using AAP_type = Algorithm::Abstract::Product; + +public: + virtual const AFP_type &getFunction() const = 0; + virtual std::unique_ptr getAlgorithm() const = 0; +}; + +END_NAMESPACE // Factory +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FACTORY_ABSTRACT_H \ No newline at end of file diff --git a/SourceCode/BusinessLogic/Hash/Factory/family.h b/SourceCode/BusinessLogic/Hash/Factory/family.h new file mode 100644 index 0000000..ba5857b --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Factory/family.h @@ -0,0 +1,46 @@ +#ifndef FACTORY_FAMILY_H +#define FACTORY_FAMILY_H + +#include "../Factory/abstract.h" + +#include "../Function/Family/family.h" +#include "../Function/Family/creatorFamily.h" + +#include "../Algorithm/Family/family.h" +#include "../Algorithm/Family/creatorFamily.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Factory) + +class Family final : public Abstract +{ +public: + using FFC_type = std::shared_ptr; + using FAC_type = std::shared_ptr; + + using FFP_type = Function::Family::Product; + using FAP_type = Algorithm::Family::Product; + +public: + Family(const FFC_type functionCreator, const FAC_type algorithmCreator) + : Abstract(functionCreator, algorithmCreator) + { + } + +public: + virtual const FFP_type &getFunction() const override { + return dynamic_cast(m_functionCreator->create()); + } + virtual std::unique_ptr getAlgorithm() const override { + std::unique_ptr algorithm = m_algorithmCreator->create(); + dynamic_cast(algorithm.get())->setHashFunction(getFunction()); + return algorithm; + } +}; + +END_NAMESPACE // Factory +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FACTORY_FAMILY_H diff --git a/SourceCode/BusinessLogic/Hash/Factory/one.h b/SourceCode/BusinessLogic/Hash/Factory/one.h new file mode 100644 index 0000000..a9b2a3f --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Factory/one.h @@ -0,0 +1,46 @@ +#ifndef FACTORY_ONE_H +#define FACTORY_ONE_H + +#include "../Factory/abstract.h" + +#include "../Function/One/one.h" +#include "../Function/One/creatorOne.h" + +#include "../Algorithm/One/one.h" +#include "../Algorithm/One/creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Factory) + +class One final : public Abstract +{ +public: + using OFC_type = std::shared_ptr; + using OAC_type = std::shared_ptr; + + using OFP_type = Function::One::Product; + using OAP_type = Algorithm::One::Product; + +public: + One(OFC_type functionCreator, OAC_type algorithmCreator) + : Abstract(functionCreator, algorithmCreator) + { + } + +public: + virtual const OFP_type &getFunction() const override { + return dynamic_cast(m_functionCreator->create()); + } + virtual std::unique_ptr getAlgorithm() const override { + std::unique_ptr algorithm = m_algorithmCreator->create(); + dynamic_cast(algorithm.get())->setHashFunction(getFunction()); + return algorithm; + } +}; + +END_NAMESPACE // Factory +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FACTORY_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Family/creatorFamily.h b/SourceCode/BusinessLogic/Hash/Function/Family/creatorFamily.h new file mode 100644 index 0000000..019d4cc --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Family/creatorFamily.h @@ -0,0 +1,27 @@ +#ifndef CREATOR_FUNCTION_FAMILY_H +#define CREATOR_FUNCTION_FAMILY_H + +#include "../creatorAbstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Family) + +class Creator : public Abstract::Creator +{ +protected: + Creator() + { + } + +public: + virtual const Product &create() const = 0; +}; + +END_NAMESPACE // Family +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // CREATOR_FUNCTION_FAMILY_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Family/creatorFnv1a.h b/SourceCode/BusinessLogic/Hash/Function/Family/creatorFnv1a.h new file mode 100644 index 0000000..3ca1c90 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Family/creatorFnv1a.h @@ -0,0 +1,25 @@ +#ifndef CREATOR_FUNCTION_FNV1a_H +#define CREATOR_FUNCTION_FNV1a_H + +#include "fnv1a.h" +#include "creatorFamily.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(FNV1a) + +class Creator : public Family::Creator +{ +public: + virtual const Product &create() const override { + return Product::getInstance(); + } +}; + +END_NAMESPACE // FNV1a +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_FUNCTION_FNV1a_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Family/family.h b/SourceCode/BusinessLogic/Hash/Function/Family/family.h new file mode 100644 index 0000000..b6d8763 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Family/family.h @@ -0,0 +1,39 @@ +#ifndef FUNCTION_FAMILY_H +#define FUNCTION_FAMILY_H + +#include "../abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Family) + +using function_type = std::function; + +class Product : public Abstract::Product +{ +protected: + const function_type m_function; + +protected: + Product(const function_type& function) : m_function(function) + { + } + +public: + const function_type &to_std() const { + return m_function; + } + size_t getHash(size_t first, size_t second) const { + // First - the value that is hashed + // Second - coefficient + return m_function(first, second); + } +}; + +END_NAMESPACE // Family +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // FUNCTION_FAMILY_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Family/fnv1a.h b/SourceCode/BusinessLogic/Hash/Function/Family/fnv1a.h new file mode 100644 index 0000000..5c0f0e5 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Family/fnv1a.h @@ -0,0 +1,40 @@ +#ifndef FUNCTION_FNV1a_H +#define FUNCTION_FNV1a_H + +#include "family.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(FNV1a) + +using Singleton = BusinessLogic::Pattern::Singleton; + +class Product final : public Family::Product, public Singleton +{ +private: + const int32_t m_p; + +private: + friend const Product &Singleton::getInstance(); + Product() + : Family::Product( + [this](size_t value, size_t i) -> size_t { + size_t result = (0x811C9DC5 xor i) xor static_cast(value); + return static_cast(result * m_p); + } + ) + , m_p(0x01000193) + { + } + +public: + using Singleton::getInstance; +}; + +END_NAMESPACE // FNV1a +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FUNCTION_FNV1a_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/creatorEquivalent.h b/SourceCode/BusinessLogic/Hash/Function/One/creatorEquivalent.h new file mode 100644 index 0000000..dd98a69 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/creatorEquivalent.h @@ -0,0 +1,25 @@ +#ifndef CREATOR_FUNCTION_EQUIVALENT_H +#define CREATOR_FUNCTION_EQUIVALENT_H + + +#include "creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Equivalent) + +class Creator : public One::Creator +{ +public: + virtual const Product &create() const override { + return Product::getInstance(); + } +}; + +END_NAMESPACE // Equivalent +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_FUNCTION_EQUIVALENT_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/creatorOne.h b/SourceCode/BusinessLogic/Hash/Function/One/creatorOne.h new file mode 100644 index 0000000..3d06deb --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/creatorOne.h @@ -0,0 +1,27 @@ +#ifndef CREATOR_FUNCTION_ONE_H +#define CREATOR_FUNCTION_ONE_H + +#include "../creatorAbstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(One) + +class Creator : public Abstract::Creator +{ +protected: + Creator() + { + } + +public: + virtual const Product &create() const = 0; +}; + +END_NAMESPACE // One +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_FUNCTION_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/creatorStandart.h b/SourceCode/BusinessLogic/Hash/Function/One/creatorStandart.h new file mode 100644 index 0000000..5287f84 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/creatorStandart.h @@ -0,0 +1,24 @@ +#ifndef CREATOR_FUNCTION_STANDART_H +#define CREATOR_FUNCTION_STANDART_H + +#include "creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Standart) + +class Creator : public One::Creator +{ +public: + virtual const Product &create() const override { + return Product::getInstance(); + } +}; + +END_NAMESPACE // Standart +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_FUNCTION_FNV1a_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/equivalent.h b/SourceCode/BusinessLogic/Hash/Function/One/equivalent.h new file mode 100644 index 0000000..9243ada --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/equivalent.h @@ -0,0 +1,35 @@ +#ifndef FUNCTION_EQUIVALENT_H +#define FUNCTION_EQUIVALENT_H + +#include "one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Equivalent) + +using Singleton = BusinessLogic::Pattern::Singleton; + +class Product final : public One::Product, public Singleton +{ +private: + friend const Product &Singleton::getInstance(); + Product() : + One::Product( + [](size_t value) -> size_t { + return value; + } + ) + { + } + +public: + using Singleton::getInstance; +}; + +END_NAMESPACE // Equivalent +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FUNCTION_EQUIVALENT_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/one.h b/SourceCode/BusinessLogic/Hash/Function/One/one.h new file mode 100644 index 0000000..84bd552 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/one.h @@ -0,0 +1,37 @@ +#ifndef FUNCTION_ONE_H +#define FUNCTION_ONE_H + +#include "../abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(One) + +using function_type = std::function; + +class Product : public Abstract::Product +{ +protected: + const function_type m_function; + +protected: + Product(const function_type& function) : m_function(function) + { + } + +public: + const function_type& to_std() const { + return m_function; + } + size_t getHash(size_t value) const { + return m_function(value); + } +}; + +END_NAMESPACE // One +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FUNCTION_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Function/One/standart.h b/SourceCode/BusinessLogic/Hash/Function/One/standart.h new file mode 100644 index 0000000..0d3a988 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/One/standart.h @@ -0,0 +1,37 @@ +#ifndef FUNCTION_STANDART_H +#define FUNCTION_STANDART_H + +#include "one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Standart) + +using Singleton = BusinessLogic::Pattern::Singleton; + +class Product final : public One::Product, public Singleton +{ +private: + std::hash m_standartHashFunction; + +private: + friend const Product &Singleton::getInstance(); + Product() + : One::Product( + std::bind(&std::hash::operator(), &m_standartHashFunction, std::placeholders::_1) + ) + , m_standartHashFunction() + { + } + +public: + using Singleton::getInstance; +}; + +END_NAMESPACE // Standart +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FUNCTION_FNV1a_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Pattern/creatorFamilyToOne.h b/SourceCode/BusinessLogic/Hash/Function/Pattern/creatorFamilyToOne.h new file mode 100644 index 0000000..c242dd8 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Pattern/creatorFamilyToOne.h @@ -0,0 +1,36 @@ +#ifndef CREATOR_ADAPTER_FAMILY_TO_ONE_H +#define CREATOR_ADAPTER_FAMILY_TO_ONE_H + +#include "familyToOne.h" +#include "../One/creatorOne.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Pattern) +BEGIN_NAMESPACE(FamilyToOne) + +class Creator final : public One::Creator +{ +private: + Product m_product; // To support the interface + +public: + Creator(std::shared_ptr adaptee, size_t coefficient) + : m_product(adaptee->create(), coefficient) + { + } + +public: + virtual const Product &create() const override { + return m_product; + } +}; + +END_NAMESPACE // FamilyToOne +END_NAMESPACE // Pattern +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_ADAPTER_FAMILY_TO_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Function/Pattern/familyToOne.h b/SourceCode/BusinessLogic/Hash/Function/Pattern/familyToOne.h new file mode 100644 index 0000000..e4380d7 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/Pattern/familyToOne.h @@ -0,0 +1,30 @@ +#ifndef ADAPTER_FAMILY_TO_ONE_H +#define ADAPTER_FAMILY_TO_ONE_H + +#include "../Family/family.h" +#include "../One/one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Pattern) +BEGIN_NAMESPACE(FamilyToOne) + +class Product final : public One::Product +{ +public: + Product(const Family::Product &adaptee, size_t coefficient) + : One::Product( + std::bind(adaptee.to_std(), std::placeholders::_1, coefficient) + ) + { + } +}; + +END_NAMESPACE // FamilyToOne +END_NAMESPACE // Pattern +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !ADAPTER_FAMILY_TO_ONE_H diff --git a/SourceCode/BusinessLogic/Hash/Function/abstract.h b/SourceCode/BusinessLogic/Hash/Function/abstract.h new file mode 100644 index 0000000..8211502 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/abstract.h @@ -0,0 +1,30 @@ +#ifndef FUNCTION_ABSTRACT_H +#define FUNCTION_ABSTRACT_H + +#include "../../businessLogic.h" +#include "../../Pattern/singleton.h" + +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Abstract) + +class Product +{ +protected: + Product() + { + } + /* With the virtual destructor, the compiler considers this class to be polymorphic */ + virtual ~Product() = default; +}; + +END_NAMESPACE // Abstract +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !FUNCTION_ABSTRACT_H diff --git a/SourceCode/BusinessLogic/Hash/Function/creatorAbstract.h b/SourceCode/BusinessLogic/Hash/Function/creatorAbstract.h new file mode 100644 index 0000000..1a7c5cd --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Function/creatorAbstract.h @@ -0,0 +1,27 @@ +#ifndef CREATOR_FUNCTION_ABSTRACT_H +#define CREATOR_FUNCTION_ABSTRACT_H + +#include "../../businessLogic.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Function) +BEGIN_NAMESPACE(Abstract) + +class Creator +{ +protected: + Creator() + { + } + +public: + virtual const Product &create() const = 0; +}; + +END_NAMESPACE // Abstract +END_NAMESPACE // Function +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // !CREATOR_FUNCTION_ABSTRACT_H diff --git a/SourceCode/BusinessLogic/Hash/Table/Pattern/subscriber.h b/SourceCode/BusinessLogic/Hash/Table/Pattern/subscriber.h new file mode 100644 index 0000000..125b5b2 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Table/Pattern/subscriber.h @@ -0,0 +1,58 @@ +#ifndef SUBSCRIBER_H +#define SUBSCRIBER_H + +#include "../../../businessLogic.h" + +#include +#include +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Table) +BEGIN_NAMESPACE(Pattern) + +class InterfaceSubscriber +{ +public: + virtual void successfulInsertion(const Table::Abstract *, const std::array &, std::pair, size_t) = 0; + virtual void unsuccessfulInsertion(const Table::Abstract *, const std::array &) = 0; +}; + +class Publisher +{ +private: + std::vector m_subscribers; + +public: + virtual void signTheObject(InterfaceSubscriber *subscriber) { + if (subscriber not_eq nullptr) { + m_subscribers.push_back(subscriber); + } + } + virtual void unsubscribe(InterfaceSubscriber *subscriber) { + if (subscriber not_eq nullptr) { + m_subscribers.erase(std::find(m_subscribers.begin(), m_subscribers.end(), subscriber)); + } + } + +protected: + virtual void sendSuccessfulInsertion(const Table::Abstract *sender, const std::array &value, std::pair index, size_t numberOfCollisions) const { + for (decltype(auto) currentSubscriber : m_subscribers) { + currentSubscriber->successfulInsertion(sender, value, index, numberOfCollisions); + } + } + virtual void sendUnseccessInsertion(const Table::Abstract *sender, const std::array &value) const { + for (decltype(auto) currentSubscriber : m_subscribers) { + currentSubscriber->unsuccessfulInsertion(sender, value); + } + } +}; + +END_NAMESPACE // Pattern +END_NAMESPACE // Table +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // SUBSCRIBER_H diff --git a/SourceCode/BusinessLogic/Hash/Table/abstract.h b/SourceCode/BusinessLogic/Hash/Table/abstract.h new file mode 100644 index 0000000..ec53e8c --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Table/abstract.h @@ -0,0 +1,60 @@ +#ifndef ABSTRACT_HASH_TABLE_H +#define ABSTRACT_HASH_TABLE_H + +#include "../../businessLogic.h" +#include "../../Statistics/dispersion.h" +#include "Pattern/subscriber.h" + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Table) + +class Abstract : public Pattern::Publisher +{ +public: + using value_type = std::array; + using collision_container = BusinessLogic::Statistics::Dispersion::container_type; + +protected: // Members + size_t m_numberOfBuckets; + size_t m_alphabetPower; + BusinessLogic::Statistics::Dispersion m_dispersion; + +protected: + Abstract(size_t alphabetPower) + : m_numberOfBuckets(0) + , m_alphabetPower(alphabetPower) + { + } + + Abstract(Abstract &&) = default; + Abstract &operator=(Abstract &&) = default; + Abstract(const Abstract &) = delete; + Abstract &operator=(const Abstract &) = delete; + +public: + virtual bool isExist(const value_type &) const = 0; + virtual size_t size() const = 0; + virtual bool insert(const value_type &value) = 0; + virtual double simpleUniformHashingCoefficient() const = 0; + size_t alphabetPower() const { + return m_alphabetPower; + } + size_t numberOfBuckets() const { + return m_numberOfBuckets; + } +}; + +END_NAMESPACE // Table +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // ABSTRACT_HASH_TABLE_H diff --git a/SourceCode/BusinessLogic/Hash/Table/chains.h b/SourceCode/BusinessLogic/Hash/Table/chains.h new file mode 100644 index 0000000..dc87bcb --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Table/chains.h @@ -0,0 +1,93 @@ +#ifndef CHAINS_HASH_TABLE_H +#define CHAINS_HASH_TABLE_H + +#include "abstract.h" +#include "../../Convert/convert.h" +#include "../Function/One/one.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Table) + +class Chains final : public Abstract +{ +public: // Types + using container_type = std::vector>; + using OFP_type = Function::One::Product; + using OFC_type = Function::One::Creator; + +private: + BusinessLogic::Convert::FromStdString m_toInteger; + +public: + container_type m_container; + const OFP_type &m_function; + + Chains(size_t size, const OFC_type &function, size_t alphabetPower = std::numeric_limits::max()) + : Abstract(alphabetPower) + , m_function(function.create()) + { + if (size == 0) { + size = 1; + } + /* The use of 'this' is mandatory */ + this->m_container.resize(size); + } + +private: + bool isExist(const value_type &value, size_t index) const { + const std::list ¤tList = m_container[index]; + return std::find(currentList.cbegin(), currentList.cend(), value) not_eq currentList.cend(); + } + +public: + virtual bool isExist(const value_type &value) const override { + size_t size = this->size(); + size_t index = m_function.getHash(m_toInteger(value, m_alphabetPower)) % size; + return isExist(value, index); + } + auto row(size_t index) const { + return m_container[index]; + } + virtual size_t size() const override { + return m_container.size(); + } + virtual bool insert(const value_type &value) override { + using namespace BusinessLogic::Statistics; + + size_t index = m_function.getHash(m_toInteger(value, m_alphabetPower)) % this->size(); + if( isExist(value, index) ) { + sendUnseccessInsertion(this, value); + return false; + } + + try { + // List does not need a reserve + m_container[index].push_back(value); + } + catch (const std::bad_alloc &) { + sendUnseccessInsertion(this, value); + return false; + } + ++m_numberOfBuckets; + + size_t listLength = m_container[index].size(); + sendSuccessfulInsertion(this, value, std::make_pair(index, listLength - 1), listLength - 1); + + return true; + } + virtual double simpleUniformHashingCoefficient() const override { + size_t size = this->size(); + collision_container container(size); + for(size_t i = 0; i < size; ++i) { + container[i] = m_container[i].size(); + } + return m_dispersion(container, size); + } +}; + +END_NAMESPACE // Table +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // CHAINS_HASH_TABLE_H diff --git a/SourceCode/BusinessLogic/Hash/Table/openAddress.h b/SourceCode/BusinessLogic/Hash/Table/openAddress.h new file mode 100644 index 0000000..88628e4 --- /dev/null +++ b/SourceCode/BusinessLogic/Hash/Table/openAddress.h @@ -0,0 +1,82 @@ +#ifndef DIRECT_ADRESS_HASH_TABLE_H +#define DIRECT_ADRESS_HASH_TABLE_H + +#include "../Factory/abstract.h" +#include "abstract.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Hash) +BEGIN_NAMESPACE(Table) + +class OpenAddressing final : public Abstract +{ +public: // Types + using container_type = std::vector; + using factory_type = Factory::Abstract; + +private: + using sample_type = BusinessLogic::Statistics::Dispersion::container_type; + +private: + friend factory_type::AAP_type; + container_type m_container; + collision_container m_numberOfCollision; + std::unique_ptr m_algorithm; + +public: + OpenAddressing(size_t size, const factory_type &factory, size_t alphabetPower = std::numeric_limits::max()) + : Abstract(alphabetPower) + , m_numberOfCollision(size, std::numeric_limits::max()) + , m_algorithm(factory.getAlgorithm()) + { + constexpr std::array nullValue = {'\0', '\0', '\0', '\0', '\0'}; + m_container.resize(size, nullValue); + m_algorithm->setTable(&m_container); + } + +public: + virtual bool isExist(const value_type &value) const override { + size_t numberOfCollisions = 0; + size_t index = (*m_algorithm).getIndex(value, numberOfCollisions, m_alphabetPower); + return ( index != std::numeric_limits::max() ) + || ( (m_container.begin() + index).operator*() == value ); + } + virtual size_t size() const override { + return m_container.size(); + } + virtual bool insert(const value_type &value) override { + using namespace BusinessLogic::Statistics; + + size_t size = m_container.size(); + if ( m_numberOfBuckets == size) { + sendUnseccessInsertion(this, value); + return false; + } + + size_t numberOfCollisions = 0; + size_t index = (*m_algorithm).getIndex(value, numberOfCollisions, m_alphabetPower); + if (index == std::numeric_limits::max() + || (m_container.begin() + index).operator*() == value + ) { + sendUnseccessInsertion(this, value); + return false; + } + + m_container[index] = value; + m_numberOfCollision[m_numberOfBuckets] = numberOfCollisions; + ++m_numberOfBuckets; + + sendSuccessfulInsertion(this, value, std::make_pair(index, 0), numberOfCollisions); + + return true; + } + virtual double simpleUniformHashingCoefficient() const override { + return m_dispersion(m_numberOfCollision, m_numberOfBuckets); + } +}; + +END_NAMESPACE // Table +END_NAMESPACE // Hash +END_NAMESPACE // BusinessLogic + +#endif // DIRECT_ADRESS_HASH_TABLE_H diff --git a/SourceCode/BusinessLogic/Pattern/singleton.h b/SourceCode/BusinessLogic/Pattern/singleton.h new file mode 100644 index 0000000..ed51914 --- /dev/null +++ b/SourceCode/BusinessLogic/Pattern/singleton.h @@ -0,0 +1,37 @@ +#ifndef SINGLETON_H +#define SINGLETON_H + +#include "../businessLogic.h" + +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Pattern) + +template +class Singleton { +private: + static std::unique_ptr m_singleton; + +public: + static const T &getInstance() { + if (m_singleton == nullptr) { + m_singleton = std::unique_ptr(new T); + } + return m_singleton.operator*(); + } + + Singleton() = default; + Singleton(const Singleton &) = delete; + Singleton(Singleton &&) = delete; + Singleton &operator=(const Singleton &) = delete; + Singleton &operator=(Singleton &&) = delete; +}; + +template +std::unique_ptr Singleton::m_singleton = nullptr; + +END_NAMESPACE // Pattern +END_NAMESPACE // BusinessLogic + +#endif // SINGLETON_H diff --git a/SourceCode/BusinessLogic/Statistics/dispersion.cpp b/SourceCode/BusinessLogic/Statistics/dispersion.cpp new file mode 100644 index 0000000..9268aea --- /dev/null +++ b/SourceCode/BusinessLogic/Statistics/dispersion.cpp @@ -0,0 +1,18 @@ +#include "dispersion.h" + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Statistics) + +long double Dispersion::operator()(const container_type &container, size_t size) const { + long double average = 0; + long double averageOfSquares = 0; + + for(size_t i = 0; i < size; ++i) { + average += ( container[i] ) / static_cast(size); + averageOfSquares += ( container[i] ) * ( container[i] ) / static_cast(size); + } + return averageOfSquares - average * average; +} + +END_NAMESPACE // Statistics +END_NAMESPACE // BusinessLogic diff --git a/SourceCode/BusinessLogic/Statistics/dispersion.h b/SourceCode/BusinessLogic/Statistics/dispersion.h new file mode 100644 index 0000000..bb9751d --- /dev/null +++ b/SourceCode/BusinessLogic/Statistics/dispersion.h @@ -0,0 +1,25 @@ +#ifndef DISPERSION_H +#define DISPERSION_H + +#include "../businessLogic.h" + +#include +#include +#include + +BEGIN_NAMESPACE(BusinessLogic) +BEGIN_NAMESPACE(Statistics) + +class Dispersion { +public: // Types + using value_type = size_t; + using container_type = std::vector; + +public: + long double operator()(const container_type &container, size_t size) const; +}; + +END_NAMESPACE // Statistics +END_NAMESPACE // BusinessLogic + +#endif // DISPERSION_H diff --git a/SourceCode/BusinessLogic/businessLogic.h b/SourceCode/BusinessLogic/businessLogic.h new file mode 100644 index 0000000..48f6755 --- /dev/null +++ b/SourceCode/BusinessLogic/businessLogic.h @@ -0,0 +1,102 @@ +#ifndef BUSINESS_LOGIC_H +#define BUSINESS_LOGIC_H + +/* Opening bracket */ +#define OPEN { + +/* Closing bracket */ +#define CLOSE } + +/* Begin of namespace */ +#define BEGIN_NAMESPACE(name) \ + namespace name OPEN + +/* Begin of namespace */ +#define END_NAMESPACE \ + CLOSE + +/* Declaring classes of factory method */ +#define DFM_TYPES \ + class Product; \ + class Creator; + +/* Factory method namespace declaration */ +#define DFM_NAMESPACE(name) \ + BEGIN_NAMESPACE(name) \ + DFM_TYPES \ + END_NAMESPACE + +/* Factory method base cod declaration */ +#define DFM_BASE \ + DFM_NAMESPACE(Abstract) \ + DFM_NAMESPACE(One) \ + DFM_NAMESPACE(Family) + +namespace BusinessLogic +{ + namespace Hash + { + namespace Function + { + DFM_BASE + DFM_NAMESPACE(FNV1a) + DFM_NAMESPACE(Standart) + DFM_NAMESPACE(Equivalent) + + namespace Pattern + { + DFM_NAMESPACE(FamilyToOne) + } + } + + namespace Algorithm + { + DFM_BASE + DFM_NAMESPACE(LinearProbing) + DFM_NAMESPACE(QuadraticProbing) + DFM_NAMESPACE(PseudorandomProbing) + DFM_NAMESPACE(DoubleHashing) + } + + namespace Factory + { + class Abstract; + class One; + class Family; + } + + namespace Table /* Only string data */ + { + class Abstract; + + class OpenAddressing; // Direct address hash function + + class Chains; // Hash function implemented by the chain method + + namespace Pattern + { + class InterfaceSubscriber; + + class Publisher; + } + } + } + + namespace Pattern // Can be used for different classes + { + template + class Singleton; + } + + namespace Convert + { + class FromStdString; + } + + namespace Statistics + { + class Dispersion; + } +} + +#endif // BUSINESS_LOGIC_H diff --git a/SourceCode/BusinessLogic/debug.cpp b/SourceCode/BusinessLogic/debug.cpp new file mode 100644 index 0000000..c257293 --- /dev/null +++ b/SourceCode/BusinessLogic/debug.cpp @@ -0,0 +1,197 @@ +#include "hashHeaderFiles.h" + +#include +#include +#include +#include +#include +#include + +#include "Convert/convert.h" + +using namespace BusinessLogic::Hash; +using namespace Function::Pattern; +using namespace Table::Pattern; + +using factory_ptr = std::shared_ptr; + +class Subscriber : public InterfaceSubscriber { +private: + clock_t m_time; + size_t m_maxCollision; + size_t m_numberOfSuccesses; + size_t m_numberOfFailures; + size_t m_target; + long double m_lastCoefficients; + +public: + Subscriber(size_t target) + : m_maxCollision(0) + , m_numberOfSuccesses(0) + , m_numberOfFailures(0) + , m_target(target) + , m_lastCoefficients(0) + { + } + + void startTime() { + m_time = clock(); + } + void endTime() { + m_time = clock() - m_time; + } + double lastCoefficient() const { + return m_lastCoefficients; + } + double workingTime() const { + return m_time / static_cast(CLOCKS_PER_SEC); + } + size_t maxCollision() const { + return m_maxCollision; + } + auto numberOfSuccesses() const { + return m_numberOfSuccesses; + } + auto numberOfFailures() const { + return m_numberOfFailures; + } + + virtual void successfulInsertion(const Table::Abstract *table, const std::array &, std::pair, size_t numberOfCollisions) override { + m_maxCollision = { + numberOfCollisions > m_maxCollision + ? numberOfCollisions + : m_maxCollision + }; + ++m_numberOfSuccesses; + + if(m_numberOfSuccesses + m_numberOfFailures >= m_target) { + m_lastCoefficients = table->simpleUniformHashingCoefficient(); + } + } + virtual void unsuccessfulInsertion(const Table::Abstract *, const std::array &) override { + ++m_numberOfFailures; + } + virtual void filledInPart(const Table::Abstract *) override { + m_lastCoefficients = 0; + } +}; + +void runTable(std::unique_ptr table, size_t target) { + /* 26 letters */ + constexpr char firstChar = ' '; + constexpr char endChar = '~'; + size_t progress = 0; + std::array currentString = { ' ', ' ', ' ', ' ', ' ' }; + + bool continueFlag = true; + while (continueFlag) { + if (++progress > target || not table->insert(currentString)) { + continueFlag = false; + } + + currentString[4] < endChar ? ++currentString[4] + : (currentString[4] = firstChar, currentString[3] < endChar) ? ++currentString[3] + : (currentString[3] = firstChar, currentString[2] < endChar) ? ++currentString[2] + : (currentString[2] = firstChar, currentString[1] < endChar) ? ++currentString[1] + : (currentString[1] = firstChar, currentString[0] < endChar) ? ++currentString[0] + : (continueFlag = false); + } +} + +int main(int /*argc*/, char **/*argv*/) +{ + auto fnv1a = std::make_shared(); + auto equivalent = std::make_shared(); + auto standart = std::make_shared(); + + auto doubleHashing = std::make_shared(0, 1); + auto pseudorandomProbing = std::make_shared(0); + auto linearProbing = std::make_shared(); + auto quadraticProbing = std::make_shared(); + + /* First Hash Function has a number 0, second - 1 */ + const Factory::Abstract &fac1 { Factory::Family(fnv1a, doubleHashing) }; + const Factory::Abstract &fac2 { Factory::Family(fnv1a, pseudorandomProbing) }; + const Factory::Abstract &fac3 { Factory::One(equivalent, linearProbing) }; + const Factory::Abstract &fac4 { Factory::One(equivalent, quadraticProbing) }; + const Factory::Abstract &fac5 { Factory::One(standart, linearProbing) }; + const Factory::Abstract &fac6 { Factory::One(standart, quadraticProbing) }; + + auto simpleFNV1a = std::make_shared(fnv1a, 0); + const Factory::Abstract &fac7 { Factory::One(simpleFNV1a, linearProbing) }; + const Factory::Abstract &fac8 { Factory::One(simpleFNV1a, quadraticProbing) }; + + /* 0x5 == 0b0101 */ + auto complicatedFNV1a = std::make_shared(fnv1a, 0x55555555); + const Factory::Abstract &fac9 { Factory::One(complicatedFNV1a, linearProbing) }; + const Factory::Abstract &fac10 { Factory::One(complicatedFNV1a, quadraticProbing) }; + +/* + * Constants +*/ + + constexpr size_t numberOfInserts = ( + //11 + //101 + //5'003 + //50'021 + //230'003 + //456'959 + //1'000'003 + //5'000'011 + //10'000'019 + 10'000'019 + ); // Must be simple - max is 10'371'957'246 + + constexpr size_t quantityOfTables = 14; + constexpr size_t numberOfBins = numberOfInserts / 10; + constexpr size_t alphabetPower = '~' - ' ' + 1; + constexpr double alpha = 0.9; + + std::array, quantityOfTables> results; + for(std::shared_ptr ¤t : results) { + current = std::make_shared(static_cast(numberOfInserts * alpha)); + } + +/* + * Constants +*/ + + + + std::array, quantityOfTables> tables { + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac1, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac2, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac3, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac4, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac5, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac6, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac7, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac8, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac9, alphabetPower) ), + std::unique_ptr( new Table::OpenAddressing(numberOfInserts, fac10, alphabetPower) ), + std::unique_ptr( new Table::Chains (numberOfBins, *equivalent, alphabetPower) ), + std::unique_ptr( new Table::Chains (numberOfBins, *standart, alphabetPower) ), + std::unique_ptr( new Table::Chains (numberOfBins, *simpleFNV1a, alphabetPower) ), + std::unique_ptr( new Table::Chains (numberOfBins, *complicatedFNV1a, alphabetPower) ) + }; + + std::cout << std::fixed; + std::cout.precision(10); + std::cout << "START!" << std::endl; + for(size_t i = 0; i < quantityOfTables; ++i) { + tables[i]->signTheObject( &results[i].operator*() ); + results[i]->startTime(); + runTable(std::move(tables[i]), numberOfInserts * alpha); + results[i]->endTime(); + + std::cout + << results[i]->maxCollision() << ' ' + << std::sqrt(results[i]->lastCoefficient()) << ' ' + << results[i]->numberOfSuccesses() << '/' + << alpha << '/' + << numberOfInserts << ' ' + << results[i]->workingTime() << std::endl; + } + std::cout << "END!" << std::endl; +} diff --git a/SourceCode/BusinessLogic/hashHeaderFiles.h b/SourceCode/BusinessLogic/hashHeaderFiles.h new file mode 100644 index 0000000..0efc586 --- /dev/null +++ b/SourceCode/BusinessLogic/hashHeaderFiles.h @@ -0,0 +1,32 @@ +#ifndef HASH_HEADER_FILES_H +#define HASH_HEADER_FILES_H + +#include "Statistics/dispersion.h" + +#include "Hash/Algorithm/One/linearProbing.h" +#include "Hash/Algorithm/One/quadraticProbing.h" +#include "Hash/Algorithm/Family/pseudorandomProbing.h" +#include "Hash/Algorithm/Family/doubleHashing.h" + +#include "Hash/Function/Family/fnv1a.h" +#include "Hash/Function/One/standart.h" +#include "Hash/Function/One/equivalent.h" +#include "Hash/Function/Pattern/familyToOne.h" + +#include "Hash/Algorithm/One/creatorLinearProbing.h" +#include "Hash/Algorithm/One/creatorQuadraticProbing.h" +#include "Hash/Algorithm/Family/creatorPseudorandomProbing.h" +#include "Hash/Algorithm/Family/creatorDoubleHashing.h" + +#include "Hash/Function/Family/creatorFnv1a.h" +#include "Hash/Function/One/creatorStandart.h" +#include "Hash/Function/One/creatorEquivalent.h" +#include "Hash/Function/Pattern/creatorFamilyToOne.h" + +#include "Hash/Factory/one.h" +#include "Hash/Factory/family.h" + +#include "Hash/Table/chains.h" +#include "Hash/Table/openAddress.h" + +#endif // HASH_HEADER_FILES_H diff --git a/SourceCode/ManualHTML/Images/demonstration.png b/SourceCode/ManualHTML/Images/demonstration.png new file mode 100644 index 0000000000000000000000000000000000000000..4759c8b5d684e1b5f54658dab7d3791990919cf3 GIT binary patch literal 146171 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%0An&O{mhVPOdOPlUD{lQXkhzt1iM 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%0D;v8sH_Tr;o>PxqH|a+ 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 Lx++EYp1l5FPZ^yT literal 0 HcmV?d00001 diff --git a/SourceCode/ManualHTML/Images/menubarFirst.png b/SourceCode/ManualHTML/Images/menubarFirst.png new file mode 100644 index 0000000000000000000000000000000000000000..3a28472e1087f5c3d050cd3ce7d78a47003d673d GIT binary patch literal 3575 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 y + + + + + + Demonstration + + +

Руководство пользователя

+

Система демонстрации

+

+ Данный раздел - описание существующих возможностей взаимодействия с + системой демонстрации изученного материала.
+ На рисунке 3.1 виден весь основной интерфейс пользователя, необходимый для + полноценного комфортного взаимодействия с данной системой. +

+
+ +

+ Рисунок 2.1 - система демонстрации вставки элемента в хеш-таблицу +

+
+

+ Каждая цифра указывает на определённый интерфейс пользователя, где даётся + его описание: +

+
    +
  1. + Табличное представление модели, которое заполняется ранее + вставленными в хеш-таблицу элементами в порядке их хранения в самой + хей-таблице. +
    2. +
  2. + График, показывающий тенденцию изменения коэффициента простого + равномерного хеширования на протяжении процесса вставки элементов в + хеш-таблицу. +
    3. +
  3. + График, показывающий тенденцию изменения количества коллизий на + протяжении процесса вставки элементов в хеш-таблицу. +
    4. +
  4. + Группирующий блок, позволяющий изменять способ решения проблем + коллизий хеш-таблицы. +
    5. +
  5. + Группирующий блок, позволяющий изменять применяемую в процессе вставки + элемента хеш-функцию. +
    6. +
  6. + Группирующий блок, позволяющий изменять применяемую в процессе вставки + элемента алгоритм, применяемый в попытке решения колизии на основе + таблицы с открытой адрессацией. +
    7. +
  7. + Сгруппированный интерфейс, позволяющий создать новую хеш-таблицу с + указанием размера первоначального контейнера, сбросить действительную + хеш-таблицу, запросить последнюю статистику по операциям вставки + элементов +
    8. +
  8. + Сгруппированный интерфейс, позволяющий создавать инструкции по вставке + новых элементов в хеш таблицу несколькими способами: n-ое количество + элементов разных элементов и один единственный, где задаётся первый + элемент. Так же существует возможность поиска первого несуществующего + элемента хеш-таблице, остановки процесса вставки элементов в + хеш-таблцицу, фокусирования графиков для полного отображения информации. + Каждая функция соответствует своей кнопке данного сгруппированного + интерфейса. +
    9. +
  9. + Вывод информации о действиях пользователя и результатах хеширования + элементов. +
    10. +
  10. + Масштабирование всех видов, вплоть до освобождения места для + определённого вида с целью его более детального рассмотрения. + Существвует возможность полного масштабирования одного вида, взамен + скрытия всех остальных. +
    11. +
+ + diff --git a/SourceCode/ManualHTML/Pages/main.html b/SourceCode/ManualHTML/Pages/main.html new file mode 100644 index 0000000..407a2d3 --- /dev/null +++ b/SourceCode/ManualHTML/Pages/main.html @@ -0,0 +1,33 @@ + + + + + + + Main + + +

Руководство пользователя

+

+ Предоставление помощи пользователю
+ в использовании демонстрационной программы:
+ "Алгоритм вставки в хеш-таблицу" +

+

+ Данное руководство предназначено пользователю для лучшего понимания работы + программы и взаимодействия с ней. +

+

Оглавление:

+
    +
  1. + Раздел теории + +
    2. +
  2. Раздел тестирования
    3. +
  3. Полоса или строка меню
    4. +
+ + diff --git a/SourceCode/ManualHTML/Pages/menubar.html b/SourceCode/ManualHTML/Pages/menubar.html new file mode 100644 index 0000000..cf33894 --- /dev/null +++ b/SourceCode/ManualHTML/Pages/menubar.html @@ -0,0 +1,57 @@ + + + + + + + Menubar + + +

Руководство пользователя

+

Полоска или строка меню

+

+ Данный раздел - описание существующих возможностей взаимодействия с + посолкой или строкой меню данной программы.
+ На рисунке 5.1 и 5.2 отображены подменю, каждое из которых группирует + определённые действия. +

+
+ +

+ Рисунок 5.1 - подменю выбора текущего раздела +

+

+ +

+

Рисунок 5.2 - подменю предоставления помощи

+
+

+ Первое подменю (см. рис. 5.1) необходимо для переключения разделов - + раздел теории, который включает две системы (система теории и система + демонстрации) и раздел тестирования. +

+

+ Каждая цифра указывает на определённый интерфейс пользователя, где даётся + его описание: +

+
    +
  1. + Действие подменю, необходимое для переключения вида на раздел теории. +
    2. +
  2. + Действие подменю, необходимое для переключения вида на раздел практики. +
    3. +
  3. + Действие подменю, необходимое для открытия модального диалогового окна - + руководства пользователя. +
    4. +
  4. + Действие подменю, необходимое для открытия модального диалогового окна, + которое содержит информацию об использующимся программой фреймворке + Qt. +
    5. +
+ + diff --git a/SourceCode/ManualHTML/Pages/testingPage.html b/SourceCode/ManualHTML/Pages/testingPage.html new file mode 100644 index 0000000..25eb3f6 --- /dev/null +++ b/SourceCode/ManualHTML/Pages/testingPage.html @@ -0,0 +1,67 @@ + + + + + + + PracticPage + + +

Руководство пользователя

+

Система тестирования

+

+ Данный раздел - описание существующих возможностей взаимодействия с + системой тестирования.
+ На рисунке 4.1 виден весь основной интерфейс пользователя, необходимый для + полноценного комфортного взаимодействия с данной системой. +

+
+ +

Рисунок 4.1 - система тестирования

+
+

+ Каждая цифра указывает на определённый интерфейс пользователя, где даётся + его описание: +

+
    +
  1. + Отображаемый текст, как текущий вопрос с описанием ввода правильного + ответа и самого тестового задания. +
    2. +
  2. + Панель ввода правильного ответа. Может представлять + определённое количество флагов для указания множественного + ответа из множества альтернатив (от 5-и до 9-и), поле ввода целого + числа или числа с плавающей точкой. +
    3. +
  3. + Нажимная кнопка для подтверждения ответа и проверки его на корректность. +
    4. +
  4. + Выходная информация, как способ идентификации успешного / безуспешного + начала тестирования с указанием конкретной ошибки, завершения + тестирования и успешного / безуспешного ответа на предыдущий вопрос. +
    5. +
  5. + Нажимная кнопка, реализующая начало тестирования. +
    6. +
  6. + Нажимная кнопка, реализующая предварительное завершение тестирования. +
    7. +
  7. + Группирующий интерфейс необходимый для выбора типа предоставляемых + вопросов в процессе тестирования. +
    8. +
  8. + Группирующий интерфейс необходимый для выбора сложности + предоставляемых вопросов в процессе тестирования. +
    9. +
+

+ Стоит отметить, что результат тестирования сохраняется в бинарном файле + (формат записи смотри в технической документации), когда тестирование + завершается после окончания подходящих под критерии вопросов или решения + пользователя, при нажатии соответствующей кнопки. +

+ + diff --git a/SourceCode/ManualHTML/Pages/theory.html b/SourceCode/ManualHTML/Pages/theory.html new file mode 100644 index 0000000..494e169 --- /dev/null +++ b/SourceCode/ManualHTML/Pages/theory.html @@ -0,0 +1,63 @@ + + + + + + + Theory + + +

Руководство пользователя

+

Система теории

+

+ Данный раздел - описание существующих возможностей взаимодействия с + системой изучения теоретического материала.
+ На рисунке 2.1 виден весь основной интерфейс пользователя, необходимый для + полноценного комфортного взаимодействия с данной системой. +

+
+ +

+ Рисунок 2.1 - система изучения теоретического материала +

+
+

+ Каждая цифра указывает на определённый интерфейс пользователя, где даётся + его описание: +

+
    +
  1. + Нажимная кнопка, при нажатии которой пользователь переходит на следующую + страницу теоретического материала. Доступна, если отображается не + главная и не последняя страницы. +
    2. +
  2. + Нажимная кнопка, при нажатии которой пользователь переходит на главную + страницу теоретического материала. Доступна, если не отображается + главная страница. +
    3. +
  3. + Нажимная кнопка, при нажатии которой пользователь переходит на + предыдущую страницу теоретического материала. Доступна, если + отображается не главная и не первая страницы. +
    4. +
  4. + Нажимная кнопка, позволяющая отобразить предыдущую небольшую + доступную часть отображаемой страницы. +
    5. +
  5. + Ползунок, при перемещении которого можно перейти к любой части + отображаемой страницы. +
    6. +
  6. + Нажимная кнопка, позволяющая отобразить следующую небольшую + доступную часть отображаемой страницы. +
    7. +
  7. + Гиперссылка оглавления, при нажатии на которую пользователь может + перейти к любой интересующей его теме, которая описывается в отдельной + страцице. +
    8. +
+ + diff --git a/SourceCode/ManualHTML/Pages/theoryPage.html b/SourceCode/ManualHTML/Pages/theoryPage.html new file mode 100644 index 0000000..bad99ce --- /dev/null +++ b/SourceCode/ManualHTML/Pages/theoryPage.html @@ -0,0 +1,50 @@ + + + + + + + TheoryPage + + +

Руководство пользователя

+

Раздел теории

+

+ Данный раздел - первое, что видит пользователь, при первом запуске + программы.
+ На рисунке 1.1 виден весь основной интерфейс пользователя, необходимый для + перехода в ту или иную систему. +

+
+ +

Рисунок 1.1 - раздел теории и практики

+
+

Всего существует три системы:

+
    +
  • Теории.
    • +
  • Демонстрации.
    • +
  • Тестирования.
    • +
+

+ Основой графического интерфейса пользователя являются нажимаемые кнопки, + переключающие между собой вкладки, флажки множественного или одиночного + выборов, и другие элементы, которые будут обсуждаться по мере описания + данного руководства. Каждая цифра указывает на определённый интерфейс + пользователя, где даётся его описание: +

+
    +
  1. + Раздел изучения теоретического материала, необходимый для понимания темы + "Алгоритм вставки элемента в хеш-таблицу". +
    2. +
  2. + Раздел демонстрации вставки элемента в хеш-таблицу.  +
    3. +
  3. + Полоса или строка меню, как единственный способ переключения фокуса + между системами теории, которая подразумевает включение системы + демонстрации, и тестирования. +
    4. +
+ + diff --git a/SourceCode/ManualHTML/info.xml b/SourceCode/ManualHTML/info.xml new file mode 100644 index 0000000..5ed8729 --- /dev/null +++ b/SourceCode/ManualHTML/info.xml @@ -0,0 +1,13 @@ + + + :/ManualHTML/Pages + :/ManualHTML/Images + + main.html + theoryPage.html + theory.html + demonstration.html + testingPage.html + menubar.html + + diff --git a/SourceCode/UserInterface/ClassesUI/Validator/validator.h b/SourceCode/UserInterface/ClassesUI/Validator/validator.h new file mode 100644 index 0000000..cc99f55 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Validator/validator.h @@ -0,0 +1,21 @@ +#ifndef LATIN_VALIDATOR_H +#define LATIN_VALIDATOR_H + +#include + +class LatinValidator : public QValidator { +public: + LatinValidator(QObject *parent) : QValidator(parent) + { + } + + virtual State validate(QString& str, int&) const override { + QRegExp rxp = QRegExp("[!-~]*"); + if (str.contains(rxp)) { + return Acceptable; + } + return Invalid; + } +}; + +#endif // LATIN_VALIDATOR_H diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.cpp b/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.cpp new file mode 100644 index 0000000..a10b9ab --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.cpp @@ -0,0 +1,564 @@ +#include "demonstrationWidget.h" + +inline void DemonstrationWidget::TableInformation::clear() { + for (size_t *value : + {&m_maxCollision, &m_numberOfSuccesses, &m_numberOfFailures}) { + *value = 0; + } + for (double *value : {&m_lastCoefficient, &m_maxCoefficient}) { + *value = 0; + } + for (auto *series : {m_pSeriesNumberOfCollisions}) { + series->removePoints(0, series->count()); + } + m_pSeriesNumberOfCollisions->append(0, 0); + + m_lastCoord = {0, 0}; + m_lastValue = {'\0', '\0', '\0', '\0', '\0'}; + m_lastInsertion = false; +} + +DemonstrationWidget::DemonstrationWidget(QWidget *pWidget) + : QWidget(pWidget), + m_pChartCollisionsView(new QChartView(new QChart, this)), + m_pStandardModel(nullptr), m_stop(false), m_pFunction(nullptr), + m_complicatedFunction(nullptr), m_pAlgorithm(nullptr), + m_alphabetPower(endChar - firstChar + 1), m_pTable(nullptr), + m_tableInformation(new QLineSeries(m_pChartCollisionsView->chart())) { + setupUi(dynamic_cast(this)); + + m_tableView->horizontalHeader()->setSectionResizeMode( + QHeaderView::ResizeToContents); + QGridLayout *gridLayout = new QGridLayout; + + /* + * Сhart + */ + + auto *axisX = new QValueAxis(); + auto *axisY = new QValueAxis(); + axisX->setTickCount(20); + axisY->setTickCount(10); + axisX->setRange(1, 2); + axisY->setRange(0, 1); + + QChart *chartCollision = m_pChartCollisionsView->chart(); + chartCollision->setTitle("Graph of collision changes"); + chartCollision->legend()->hide(); + chartCollision->addAxis(axisX, Qt::AlignBottom); + chartCollision->addAxis(axisY, Qt::AlignLeft); + chartCollision->addSeries(m_tableInformation.m_pSeriesNumberOfCollisions); + m_tableInformation.m_pSeriesNumberOfCollisions->attachAxis(axisX); + m_tableInformation.m_pSeriesNumberOfCollisions->attachAxis(axisY); + + /* + * View(-s) + */ + + m_pChartCollisionsView->installEventFilter(this); + m_pChartCollisionsView->setRubberBand(QChartView::RectangleRubberBand); + m_pChartCollisionsView->setRenderHint(QPainter::Antialiasing); + m_pChartCollisionsView->setMinimumHeight(m_tableView->minimumHeight()); + m_pChartCollisionsView->setMinimumWidth(m_tableView->minimumWidth()); + + /* + * Splitter + */ + + QSplitter *splitter = new QSplitter(Qt::Vertical); + splitter->addWidget(m_tableView); + splitter->addWidget(m_pChartCollisionsView); + + gridLayout->addWidget(splitter, 0, 0, 1, 1); + gridLayout->addWidget(m_rightScrollArea, 0, 1, 1, 1); + gridLayout->addWidget(m_frmProgressBar, 1, 0, 1, 2); + setLayout(gridLayout); + + /* + * Validator and HTML theory + */ + + m_leFrom->setValidator(new LatinValidator(m_leFrom)); + m_leInsert->setValidator(new LatinValidator(m_leInsert)); + + /* + * Signal & slots + */ + + connect(m_pbReset, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedReset); + connect(m_pbApply, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedApply); + connect(m_pbStatistics, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedStatistics); + connect(m_pbMakeItems, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedMakeItems); + connect(m_pbInsert, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedInsert); + connect(m_pbFindFree, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedFindFree); + connect(m_pbStop, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedStop); + connect(m_pbFocus, &QPushButton::clicked, this, + &DemonstrationWidget::slotClickedFocus); + + connect(m_rbFNV1a32bit, &QRadioButton::toggled, this, + &DemonstrationWidget::slotUpdateAdditionalInputData); + connect(m_rbPseudorandomProbing, &QRadioButton::toggled, this, + &DemonstrationWidget::slotUpdateAdditionalInputData); + connect(m_rbDoubleHashing, &QRadioButton::toggled, this, + &DemonstrationWidget::slotUpdateAdditionalInputData); + connect(m_rbChains, &QRadioButton::toggled, this, + &DemonstrationWidget::slotUpdateAdditionalInputData); + + /* + * GUI + */ + m_frmProgressBar->hide(); + m_frmFirstInputData->hide(); + m_frmSecondInputData->hide(); + m_gbInputData->hide(); +} + +/* + * Inserting elements + */ + +void DemonstrationWidget::successfulInsertion(const table_type *, + const value_type &value, + std::pair index, + size_t numberOfCollisions) { + m_tableInformation.m_lastCoord = index; + m_tableInformation.m_lastValue = value; + m_tableInformation.m_lastInsertion = true; + ++m_tableInformation.m_numberOfSuccesses; + + m_tableInformation.m_lastCollision = numberOfCollisions; + m_tableInformation.m_maxCollision = {numberOfCollisions > + m_tableInformation.m_maxCollision + ? numberOfCollisions + : m_tableInformation.m_maxCollision}; + + m_tableInformation.m_lastCollision = numberOfCollisions; + if (numberOfCollisions > m_tableInformation.m_maxCollision) { + m_tableInformation.m_maxCollision = numberOfCollisions; + } + + m_tableInformation.m_pSeriesNumberOfCollisions->append( + m_tableInformation.m_numberOfSuccesses, numberOfCollisions); + + QModelIndex modelIndex = m_pStandardModel->index(index.first, index.second); + if (getCurrentTableType() == TableType::Chain) { + updateColumns(index.first); + } else { + m_pStandardModel->setData(modelIndex, QVariant(toQString(value))); + } +} + +void DemonstrationWidget::unsuccessfulInsertion(const table_type *, + const value_type &value) { + m_tableInformation.m_lastValue = value; + m_tableInformation.m_lastInsertion = false; + ++m_tableInformation.m_numberOfFailures; +} + +inline void DemonstrationWidget::updateColumns(size_t rowIndex) { + using namespace BusinessLogic::Hash::Table; + + auto tableRow = + dynamic_cast(m_pTable.get()) + ->row(rowIndex); + size_t modelColumnCount = m_pStandardModel->columnCount(); + size_t tableColumnCount = tableRow.size(); + + if (modelColumnCount < tableColumnCount) { + m_pStandardModel->insertColumns( + modelColumnCount, + std::max(tableColumnCount - modelColumnCount, + static_cast(std::ceil( + std::sqrt(m_tableInformation.m_lastCoefficient))))); + } + + QModelIndex modelIndex; + auto iterator = tableRow.begin(); + for (size_t i = 0, size = tableRow.size(); i < size; ++i, ++iterator) { + modelIndex = m_pStandardModel->index(rowIndex, i); + m_pStandardModel->setData(modelIndex, QVariant(toQString(*iterator))); + } +} + +inline void DemonstrationWidget::updateCharts() { + m_pChartCollisionsView->chart() + ->axes(Qt::Horizontal) + .front() + ->setRange(1, m_tableInformation.m_numberOfSuccesses); + m_pChartCollisionsView->chart() + ->axes(Qt::Vertical) + .front() + ->setRange(0, m_tableInformation.m_maxCollision); + m_pChartCollisionsView->chart()->resetMatrix(); +} + +inline void DemonstrationWidget::updateTableView() { + m_tableView->scrollTo( + m_pStandardModel->index(m_tableInformation.m_lastCoord.first, + m_tableInformation.m_lastCoord.second), + QAbstractItemView::PositionAtCenter); + m_tableView->repaint(); +} + +inline DemonstrationWidget::value_type & +DemonstrationWidget::next(value_type &value) const { + auto rbegin = value.rbegin(); + auto rend = value.rend(); + + for (; rbegin != rend; ++rbegin) { + if (*rbegin >= firstChar && *rbegin < endChar) { + ++(*rbegin); + return value; + } else if (*rbegin == '\0') { + *rbegin = firstChar; + return value; + } else { + *rbegin = firstChar; + } + } + value = toStdArray(std::string(4, '\0') + firstChar); + return value; +} + +inline bool DemonstrationWidget::checkBeforeInsertion(bool tableTypeIsChain) { + size_t quantityOfInserts = m_sbQuantity->value(); + if (tableTypeIsChain && + (m_pTable->numberOfBuckets() + quantityOfInserts) / m_pTable->size() > + 10) { + outputMessage( + "Prohibit insertion when allocating more than 10 elements per chain", + "red"); + return false; + } + return true; +} + +inline void DemonstrationWidget::slotClickedMakeItems() { + using namespace BusinessLogic::Convert; + + bool tableTypeIsChain = getCurrentTableType() == TableType::Chain; + if (not checkBeforeInsertion(tableTypeIsChain)) { + return; + } + + /* + * Preparing + */ + + if (tableTypeIsChain && m_pStandardModel->columnCount() == 0) { + m_pStandardModel->insertColumns(0, m_sbQuantity->value() / + m_sbBucketQuantity->value()); + } + + m_frmProgressBar->setVisible(true); + m_progressBar->setValue(0); + + /* + * For other thread + */ + + setEnabledInsertingProcess(false); + m_frmProgressBar->setVisible(true); + + auto differenceNumberOfSuccesses = m_tableInformation.m_numberOfSuccesses; + auto differenceNumberOfFailures = m_tableInformation.m_numberOfFailures; + + int value; + value_type currentString = toStdArray(m_leFrom->text().toStdString()); + for (size_t progress = 0, target = m_sbQuantity->value(); progress < target; + ++progress) { + m_pTable->insert(currentString); + next(currentString); + if (m_stop) { + m_stop = false; + break; + } + + value = static_cast( + progress * static_cast(m_progressBar->maximum()) / target); + if (value > m_progressBar->value()) { + m_progressBar->setValue(value); + } + + QApplication::processEvents(); + } + + updateCharts(); + updateTableView(); + + m_frmProgressBar->setVisible(false); + setEnabledInsertingProcess(true); + + /* + * Output message + */ + + differenceNumberOfSuccesses = + m_tableInformation.m_numberOfSuccesses - differenceNumberOfSuccesses; + differenceNumberOfFailures = + m_tableInformation.m_numberOfFailures - differenceNumberOfFailures; + + m_lblOutputMessages->setText( + getColorTextHTML( + QString("Successful inserts: %1").arg(differenceNumberOfSuccesses), + "green") + + "
" + + getColorTextHTML(QString("Failed inserts    : %1") + .arg(differenceNumberOfFailures), + "red")); +} + +inline void DemonstrationWidget::slotClickedInsert() { + bool tableTypeIsChain = getCurrentTableType() == TableType::Chain; + if (not checkBeforeInsertion(tableTypeIsChain)) { + return; + } + + m_pTable->insert(toStdArray(m_leInsert->text().toStdString())); + outputMessage(m_tableInformation.m_lastInsertion ? "Inserting is successful" + : "The insertion has failed", + m_tableInformation.m_lastInsertion ? "green" : "red"); +} + +/* + * Other logic + */ + +inline auto DemonstrationWidget::getCurrentFactory() const { + using namespace BusinessLogic::Hash; + + std::unique_ptr factory; + bool functionTypeIsFamily = + getCurrentFunctionType() == RelationshipType::Family; + if (getCurrentAlgorythmType() == RelationshipType::One) { + factory = std::make_unique( + functionTypeIsFamily + ? m_complicatedFunction // The complicated function must be prepared + : std::dynamic_pointer_cast(m_pFunction), + std::dynamic_pointer_cast(m_pAlgorithm)); + } else if (functionTypeIsFamily) { + factory = std::make_unique( + std::dynamic_pointer_cast(m_pFunction), + std::dynamic_pointer_cast(m_pAlgorithm)); + } else { + std::invalid_argument("function type not defined"); + } + return factory; +} + +inline void DemonstrationWidget::updateFunctionCreator() { + using namespace BusinessLogic::Hash::Function; + if (m_rbEquivalent->isChecked()) { + m_pFunction = std::make_shared(); + } else if (m_rbStandart->isChecked()) { + m_pFunction = std::make_shared(); + } else { // m_rbFNV1a32bit->isChecked() + m_pFunction = std::make_shared(); + } +} + +inline void DemonstrationWidget::updateAlgorithmCreator() { + using namespace BusinessLogic::Hash::Algorithm; + if (m_rbLinearProbing->isChecked()) { + m_pAlgorithm = std::make_shared(); + } else if (m_rbQuadraticProbing->isChecked()) { + m_pAlgorithm = std::make_shared(); + } else if (m_rbPseudorandomProbing->isChecked()) { + m_pAlgorithm = std::make_shared( + m_sbFirstInputData->value()); + } else { // m_rbDoubleHashing->isChecked() + m_pAlgorithm = std::make_shared( + m_sbFirstInputData->value(), m_sbSecondInputData->value()); + } +} + +inline void DemonstrationWidget::deleteModel() { + auto stringListModel = m_tableView->selectionModel(); + m_tableView->setModel(nullptr); + if (stringListModel not_eq nullptr) { + delete stringListModel; + } +} + +/* + * Table GUI + */ + +inline void DemonstrationWidget::slotUpdateAdditionalInputData() { + bool predicate = {getCurrentFunctionType() == RelationshipType::Family}; + m_gbInputData->setVisible(predicate); + m_frmFirstInputData->setVisible(predicate); + + if (getCurrentTableType() == TableType::Chain) { + m_rbStandart->setEnabled(true); + m_rbEquivalent->setEnabled(true); + m_frmSecondInputData->setVisible(false); + } else { + bool algorythmIsFamily = + getCurrentAlgorythmType() == RelationshipType::Family; + m_rbEquivalent->setDisabled(algorythmIsFamily); + m_rbStandart->setDisabled(algorythmIsFamily); + m_frmSecondInputData->setVisible(algorythmIsFamily); + + if (algorythmIsFamily) { + m_rbFNV1a32bit->setChecked(true); + repaint(); + m_frmSecondInputData->setVisible(m_rbDoubleHashing->isChecked()); + } + } +} + +inline void DemonstrationWidget::slotClickedApply() { + using namespace BusinessLogic::Hash; + using namespace BusinessLogic::Hash::Function::Pattern; + + if (m_rbDoubleHashing->isChecked() && + m_sbFirstInputData->value() == m_sbSecondInputData->value()) { + outputMessage("Hash function coefficients should not match", "red"); + return; + } + + updateFunctionCreator(); + updateAlgorithmCreator(); + + bool tableTypeIsChain = getCurrentTableType() == TableType::Chain; + bool functionTypeIsFamily = + getCurrentFunctionType() == RelationshipType::Family; + + if (functionTypeIsFamily && (tableTypeIsChain || getCurrentAlgorythmType() == + RelationshipType::One)) { + m_complicatedFunction = std::make_shared( + std::dynamic_pointer_cast(m_pFunction), + m_sbFirstInputData->value()); + } + + size_t bucketQuantity = m_sbBucketQuantity->value(); + try { + if (tableTypeIsChain) { + m_pTable = std::make_unique( + bucketQuantity, + functionTypeIsFamily + ? *m_complicatedFunction + : *std::dynamic_pointer_cast(m_pFunction), + m_alphabetPower); + } else { + auto factory = getCurrentFactory(); + m_pTable = std::make_unique( + bucketQuantity, *factory, m_alphabetPower); + } + } catch (const std::bad_alloc &err) { + outputMessage("Not enough RAM", "red"); + return; + } + + setEnabledCreateHashTable(false); + m_pbFocus->setEnabled(true); + m_pTable->signTheObject(this); + + /* + * A descendant will notify an ancestor of his own destruction when using + * delete + */ + deleteModel(); + m_pStandardModel = + new QStandardItemModel(bucketQuantity, (tableTypeIsChain ? 0 : 1), this); + m_tableView->setModel(m_pStandardModel); + + m_lblOutputMessages->setText( + getColorTextHTML("The model was created", "green")); +} + +inline void DemonstrationWidget::slotClickedStatistics() { + m_tableInformation.m_lastCoefficient = + m_pTable->simpleUniformHashingCoefficient(); + QMessageBox::information( + nullptr, "Statistics", + QString("Maximum number of collisions:\t%1\n") + .arg(m_tableInformation.m_maxCollision) + + QString("Number of successful inserts:\t\t%1\n") + .arg(m_tableInformation.m_numberOfSuccesses) + + QString("Number of failed inserts:\t\t%1\n") + .arg(m_tableInformation.m_numberOfFailures) + + QString("Simple uniform hashing coefficient:\t%1\n") + .arg(m_tableInformation.m_lastCoefficient)); +} + +inline void DemonstrationWidget::slotClickedFindFree() { + QString result; + if (m_pTable->numberOfBuckets() == 0) { + result = firstChar; + } else { + value_type currentString = m_tableInformation.m_lastValue; + while (m_pTable->isExist(next(currentString))) + continue; + result = toQString(currentString); + } + + m_leFrom->setText(result); + m_leInsert->setText(result); +} + +inline void DemonstrationWidget::slotClickedStop() { + m_stop = true; + setEnabledInsertingProcess(true); +} + +inline void DemonstrationWidget::slotClickedFocus() { updateCharts(); } + +/* + * Base GUI + */ + +inline void DemonstrationWidget::slotClickedReset() { + setEnabledCreateHashTable(true); + m_pbFocus->setDisabled(true); + + m_complicatedFunction.reset(); + m_pTable.release(); + m_tableInformation.clear(); + resetAxes(); + deleteModel(); + + outputMessage("The model has been deleted", "green"); +} + +inline QString +DemonstrationWidget::getColorTextHTML(const QString &text, + const char *const color) const { + return QString(m_fontBeginColorHTML).arg(color) + text + m_fontEndHTML; +} + +inline void DemonstrationWidget::outputMessage(const QString &text, + const char *const color) { + m_lblOutputMessages->setText(getColorTextHTML(text, color)); +} + +inline void DemonstrationWidget::setEnabledCreateHashTable(bool flag) { + for (QWidget *widget : std::initializer_list{ + m_pbApply, m_sbBucketQuantity, m_gbResolutionOfCollisions, + m_gbFunction, m_gbInputData}) { + widget->setEnabled(flag); + } + + if (getCurrentTableType() not_eq TableType::Chain) { + m_gbAlgorithm->setEnabled(flag); + } + m_gbLoadTable->setDisabled(flag); + m_pbStatistics->setDisabled(flag); +} + +inline void DemonstrationWidget::setEnabledInsertingProcess(bool flag) { + for (QWidget *widget : std::initializer_list{ + m_leFrom, m_sbQuantity, m_pbMakeItems, m_leInsert, m_pbInsert, + m_pbReset, m_pbStatistics, m_pbFindFree}) { + widget->setEnabled(flag); + } + m_pbStop->setDisabled(flag); +} diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h b/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h new file mode 100644 index 0000000..d274746 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h @@ -0,0 +1,233 @@ +#ifndef DEMONSTRATION_WIDGET_H +#define DEMONSTRATION_WIDGET_H + +#include "../../Validator/validator.h" +#include "SourceCode/BusinessLogic/businessLogic.h" +#include "SourceCode/BusinessLogic/hashHeaderFiles.h" +#include "hashTable.h" +#include "ui_demonstrationWidget.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + +class DemonstrationWidget + : public QWidget, + protected Ui::DemonstrationWidget, + public BusinessLogic::Hash::Table::Pattern::InterfaceSubscriber { +public: + using value_type = BusinessLogic::Hash::Table::Abstract::value_type; + using table_type = BusinessLogic::Hash::Table::Abstract; + +private: + struct TableInformation { + public: + /* Qt containers */ + QLineSeries *m_pSeriesNumberOfCollisions; + + /* If successful */ + std::pair m_lastCoord; + size_t m_numberOfSuccesses; + size_t m_lastCollision; + size_t m_maxCollision; + double m_lastCoefficient; + double m_maxCoefficient; + + /* If unsuccessful */ + size_t m_numberOfFailures; + + /* In any case */ + value_type m_lastValue; + bool m_lastInsertion; + + public: + TableInformation(const TableInformation &) = delete; + TableInformation(TableInformation &&) = delete; + + TableInformation(QLineSeries *maxCollision) + : m_pSeriesNumberOfCollisions(maxCollision) { + clear(); + }; + + public: + void clear(); + }; + +private: // Event filter + virtual bool eventFilter(QObject *target, QEvent *event) override { + if (target == m_pChartCollisionsView) { + QChartView *view = dynamic_cast(target); + QChart *chart = view->chart(); + + switch (event->type()) { + case QEvent::Wheel: { + QWheelEvent *currentEvent = dynamic_cast(event); + + qreal factor = currentEvent->angleDelta().y() > 0 ? 0.9 : 1.1; + QRectF rect = QRectF(chart->plotArea().left(), chart->plotArea().top(), + chart->plotArea().width() * factor, + chart->plotArea().height() * factor); + + QPointF mousePos = view->mapFromGlobal(QCursor::pos()); + rect.moveCenter(mousePos); + chart->zoomIn(rect); + + QPointF delta = chart->plotArea().center() - mousePos; + chart->scroll(delta.x(), -delta.y()); + + return true; + } break; + default: { + return false; + } break; + } + } + return false; + } + +public: + enum class TableType : short { Chain, OpenAdressing, Indefined }; + enum class RelationshipType : short { One, Family, Indefined }; + +private: + /* + * Constants + */ + static constexpr char firstChar = '!'; + static constexpr char endChar = '~'; + + QChartView *m_pChartCollisionsView; + QStandardItemModel *m_pStandardModel; + bool m_stop; + + /* + * Business logic + */ + std::shared_ptr m_pFunction; + std::shared_ptr + m_complicatedFunction; + std::shared_ptr + m_pAlgorithm; + size_t m_alphabetPower; + std::unique_ptr m_pTable; + TableInformation m_tableInformation; + + /* + * HTML tags + */ + static constexpr auto m_fontBeginColorHTML = R"()"; + static constexpr auto m_fontEndHTML = R"()"; + +public: + DemonstrationWidget(QWidget *pWidget = nullptr); + +public: // Custom slots + virtual void successfulInsertion(const table_type *, const value_type &, + std::pair, size_t) override; + virtual void unsuccessfulInsertion(const table_type *, + const value_type &) override; + +private: + /* + * Business logic + */ + TableType getCurrentTableType() const { + TableType result; + result = {m_rbChains->isChecked() ? TableType::Chain + : m_rbOpenAdressing->isChecked() ? TableType::OpenAdressing + : TableType::Indefined}; + if (result == TableType::Indefined) { + throw std::invalid_argument("table not defined"); + } + return result; + } + RelationshipType getCurrentFunctionType() const { + RelationshipType result; + result = {m_rbEquivalent->isChecked() ? RelationshipType::One + : m_rbStandart->isChecked() ? RelationshipType::One + : m_rbFNV1a32bit->isChecked() ? RelationshipType::Family + : RelationshipType::Indefined}; + if (result == RelationshipType::Indefined) { + throw std::invalid_argument("function not defined"); + } + return result; + } + RelationshipType getCurrentAlgorythmType() const { + RelationshipType result; + result = {m_rbLinearProbing->isChecked() ? RelationshipType::One + : m_rbQuadraticProbing->isChecked() ? RelationshipType::One + : m_rbPseudorandomProbing->isChecked() ? RelationshipType::Family + : m_rbDoubleHashing->isChecked() ? RelationshipType::Family + : RelationshipType::Indefined}; + if (result == RelationshipType::Indefined) { + throw std::invalid_argument("algorythm not defined"); + } + return result; + } + + auto getCurrentFactory() const; + void updateFunctionCreator(); + void updateAlgorithmCreator(); + void deleteModel(); + void resetAxes() { + m_pChartCollisionsView->chart() + ->axes(Qt::Horizontal) + .front() + ->setRange(1, 2); + m_pChartCollisionsView->chart()->axes(Qt::Vertical).front()->setRange(0, 1); + } + QString toQString(const value_type &value) { + auto convert = value; + unsigned size = + std::remove(convert.begin(), convert.end(), '\0') - convert.begin(); + return QString::fromLatin1(convert.data(), size); + } + value_type toStdArray(std::string &&value) const { + value_type result = {'\0', '\0', '\0', '\0', firstChar}; + std::copy(value.rbegin(), value.rend(), result.rbegin()); + return result; + } + value_type &next(value_type &value) const; + bool checkBeforeInsertion(bool); + + /* + * GUI and displaying + */ + QString getColorTextHTML(const QString &text, const char *const color) const; + void outputMessage(const QString &text, const char *const color); + void updateColumns(size_t rowIndex); + void updateCharts(); + void updateTableView(); + void setEnabledCreateHashTable(bool flag); + void setEnabledInsertingProcess(bool flag); + +public slots: + void slotTabSwitched(int index) { + if (index == 1) { + QSplitter *splitter = findChild(""); + auto children = splitter->children(); + QList sizes{dynamic_cast(children[0])->minimumHeight(), + dynamic_cast(children[1])->minimumHeight()}; + splitter->setSizes(sizes); + } + } + +private slots: + void slotUpdateAdditionalInputData(); + void slotClickedReset(); + void slotClickedApply(); + void slotClickedMakeItems(); + void slotClickedInsert(); + void slotClickedStatistics(); + void slotClickedFindFree(); + void slotClickedStop(); + void slotClickedFocus(); +}; + +#endif // DEMONSTRATION_WIDGET_H diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.cpp b/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.cpp new file mode 100644 index 0000000..0eacc6f --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.cpp @@ -0,0 +1,284 @@ +#include "testingWidget.h" + +TestingWidget::TestingWidget(QWidget *pWidget) + : QWidget(pWidget), m_currentComplexityName("everything"), + m_currentTopicName("everything"), m_file("./QuestionsXML/questions.xml") { + setupUi(dynamic_cast(this)); + + connect(m_pbConfirm, &QPushButton::clicked, this, + &TestingWidget::slotClickedConfirm); + + connect(m_pbStart, &QPushButton::clicked, this, + &TestingWidget::slotClickedStart); + connect(m_pbStop, &QPushButton::clicked, this, + &TestingWidget::slotResetTesting); + + connect(m_rbAllDifficulties, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedComplexity); + connect(m_rbEasy, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedComplexity); + connect(m_rbMedium, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedComplexity); + connect(m_rbHard, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedComplexity); + + connect(m_rbAllTopics, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedTopics); + connect(m_rbDiscreteMathematics, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedTopics); + connect(m_rbHashFunction, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedTopics); + connect(m_rbHashTable, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedTopics); + connect(m_rbAlgorithm, &QRadioButton::clicked, this, + &TestingWidget::slotSwitchedTopics); + + m_frmConfirm->hide(); +} + +inline void TestingWidget::hideCheckBoxes() { + QCheckBox *currentCheckBox; + for (unsigned i = 0; i < 9; ++i) { + currentCheckBox = findChild(QString("m_cbIndex%1").arg(i)); + currentCheckBox->hide(); + } +} + +inline void TestingWidget::showCheckBoxes() { + QCheckBox *currentCheckBox; + for (unsigned i = 0, size = m_answers.size(); i < size; ++i) { + currentCheckBox = findChild(QString("m_cbIndex%1").arg(i)); + currentCheckBox->show(); + currentCheckBox->setText(m_answers[i].first); + } +} + +inline QString TestingWidget::getHTMLQuestion(QDomElement element) { + QString currentQuestion; + + element = element.firstChildElement(); + do { + switch (getTagsEnumFromQString(element.tagName())) { + case TagXML::Caption: { + currentQuestion.append(QString("

%1

").arg(element.text())); + } break; + case TagXML::Text: { + currentQuestion.append(QString(R"( +

+ + + %2 + + +

+ )") + .arg(element.text())); + } break; + case TagXML::Answer: { + m_answers.append(std::make_pair( + element.text(), element.hasAttribute("type") + ? (element.attribute("type") == "correct") + : false)); + } break; + case TagXML::Question: { + throw std::invalid_argument( + "the question cannot be nested within the question"); + } break; + case TagXML::Undefined: { + throw std::invalid_argument("tag undefined"); + } break; + } + element = element.nextSiblingElement(); + } while (not element.isNull()); + + return currentQuestion; +} + +inline void TestingWidget::configureInput(const QString &value) { + hideCheckBoxes(); + resetInput(); + + if (value == "choice") { + m_swInputData->setCurrentIndex(0); + unsigned seed = std::chrono::system_clock::now().time_since_epoch().count(); + std::shuffle(m_answers.begin(), m_answers.end(), + std::default_random_engine(seed)); + showCheckBoxes(); + } else if (value == "integer") { + m_swInputData->setCurrentIndex(1); + + } else if (value == "floatingPoint") { + m_swInputData->setCurrentIndex(2); + } else { + throw std::invalid_argument("the type of the input option is undefined"); + } +} + +inline bool TestingWidget::showNextQuestion() { + bool continueFlag = true; + + auto checkType = [](const QString &value) -> bool { + return bool{value == "choice" || value == "integer" || + value == "floatingPoint"}; + }; + + while (not m_currentQuestion.isNull() && continueFlag) { + + m_currentTypeName = m_currentQuestion.attribute("type"); + if ((m_currentTopicName == "everything" || + m_currentQuestion.attribute("category") + .split('|') + .contains(m_currentTopicName)) && + (m_currentComplexityName == "everything" || + m_currentComplexityName == + m_currentQuestion.attribute("complexity")) && + checkType(m_currentTypeName)) { + m_answers.clear(); + m_testingTextBrowser->setHtml(getHTMLQuestion(m_currentQuestion)); + + configureInput(m_currentTypeName); + + continueFlag = false; + } + m_currentQuestion = m_currentQuestion.nextSiblingElement("question"); + } + + return (not continueFlag); +} + +inline void TestingWidget::setEnabledGUIStartTesting(bool flag) { + m_gbTopics->setEnabled(flag); + m_gbDifficulty->setEnabled(flag); + m_pbStart->setEnabled(flag); + m_pbStop->setDisabled(flag); + m_frmConfirm->setVisible(not flag); +} + +inline TestingWidget::TagXML +TestingWidget::getTagsEnumFromQString(const QString &value) { + TagXML result = {value == "question" ? TagXML::Question + : value == "caption" ? TagXML::Caption + : value == "text" ? TagXML::Text + : value == "answer" ? TagXML::Answer + : TagXML::Undefined}; + return result; +} + +/* + * Slots + */ + +inline void TestingWidget::slotSwitchedTopics() { + QString result = {m_rbAllTopics->isChecked() ? QString("everything") + : m_rbDiscreteMathematics->isChecked() + ? QString("discreteMathematics") + : m_rbHashFunction->isChecked() ? QString("hashFunction") + : m_rbHashTable->isChecked() ? QString("hashTable") + : m_rbAlgorithm->isChecked() ? QString("algorithm") + : QString()}; + if (result.isNull()) { + throw std::invalid_argument("topic undefined"); + } + m_currentTopicName = result; +} + +inline void TestingWidget::slotSwitchedComplexity() { + QString result = {m_rbAllDifficulties->isChecked() ? QString("everything") + : m_rbEasy->isChecked() ? QString("easy") + : m_rbMedium->isChecked() ? QString("medium") + : m_rbHard->isChecked() ? QString("hard") + : QString()}; + if (result.isNull()) { + throw std::invalid_argument("complexity undefined"); + } + m_currentComplexityName = result; +} + +inline bool TestingWidget::checkAnswer(const QString &value) { + if (m_answers.size() <= 0) { + return false; + } + + bool result = true; + if (value == "choice") { + QCheckBox *currentCheckBox; + for (unsigned i = 0, size = m_answers.size(); i < size; ++i) { + currentCheckBox = findChild(QString("m_cbIndex%1").arg(i)); + if (m_answers[i].second) { + result &= currentCheckBox->isChecked(); + } else { + result &= not currentCheckBox->isChecked(); + } + } + } else if (value == "integer" || value == "floatingPoint") { + QString answer = {value == "integer" ? m_sbInteger->text() + : m_sbDouble->text()}; + auto iter = + std::find_if(m_answers.begin(), m_answers.end(), + [answer](const std::pair &value) -> bool { + return (value.second == true && value.first == answer); + }); + return (iter not_eq m_answers.end()); + } else { + throw std::invalid_argument("input not defined"); + } + return result; +} + +inline void TestingWidget::slotClickedConfirm() { + bool result = checkAnswer(m_currentTypeName); + emit signalReplyGiven(result); + + if (not showNextQuestion()) { + setEnabledGUIStartTesting(true); + slotResetTesting(); + } +} + +inline void TestingWidget::slotClickedStart() { + bool isOpened = m_file.open(QIODevice::ReadOnly); + emit signalFileOpened(isOpened); + + if (isOpened) { + bool isSet = m_document.setContent(&m_file); + m_file.close(); + emit signalContentIsSet(isSet); + + if (isSet) { + QDomNode questions = + m_document.firstChild().nextSiblingElement("questions"); + if (questions.isNull()) { + return; + } + + QDomNode firstQuestion = + questions.firstChild().nextSiblingElement("question"); + if (firstQuestion.isNull()) { + return; + } + m_currentQuestion = firstQuestion.toElement(); + if (showNextQuestion()) { + setEnabledGUIStartTesting(false); + emit signalStartOfTesting(); + } + } + } + return; +} + +inline void TestingWidget::resetInput() { + QCheckBox *currentCheckBox; + for (unsigned i = 0; i < 9; ++i) { + currentCheckBox = findChild(QString("m_cbIndex%1").arg(i)); + currentCheckBox->setChecked(false); + } + m_sbInteger->clear(); + m_sbDouble->clear(); +} + +inline void TestingWidget::slotResetTesting() { + m_testingTextBrowser->clear(); + setEnabledGUIStartTesting(true); + resetInput(); + emit signalEndOfTesting(); +} diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h b/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h new file mode 100644 index 0000000..b674109 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h @@ -0,0 +1,71 @@ +#ifndef TESTING_WIDGET_H +#define TESTING_WIDGET_H + +#include "ui_testingWidget.h" + +#include + +#include +#include +#include + +class TestingWidget : public QWidget + , protected Ui::TestingWidget +{ + Q_OBJECT + +private: + QDomDocument m_document; + QDomElement m_currentQuestion; + QString m_currentComplexityName; + QString m_currentTopicName; + QString m_currentTypeName; + + QFile m_file; + QVector> m_answers; + +private: + enum class Topic : short { + Everything, DiscreteMathematics, HashFunction, HashTable, Algorithm, Undefined + }; + enum class Complexity : short { + Everything, Easy, Medium, Hard, Undefined + }; + enum class TagXML : short { + Question, Caption, Text, Answer, Undefined + }; + +public: + TestingWidget(QWidget *pWidget = nullptr); + ~TestingWidget() { + if(m_file.isOpen()) { + m_file.close(); + } + } + +private: + void hideCheckBoxes(); + void showCheckBoxes(); + QString getHTMLQuestion(QDomElement domNode); + void configureInput(const QString &); + bool showNextQuestion(); + void setEnabledGUIStartTesting(bool flag); + TagXML getTagsEnumFromQString(const QString&); + bool checkAnswer(const QString&); + void resetInput(); + +private slots: + void slotSwitchedTopics(); + void slotSwitchedComplexity(); + void slotClickedConfirm(); + void slotClickedStart(); + void slotResetTesting(); + +signals: + void signalFileOpened(bool /*isOpen*/); + void signalContentIsSet(bool /*isSet*/); + void signalReplyGiven(bool /*isCorrect*/); + void signalStartOfTesting(); + void signalEndOfTesting(); +}; +#endif // TESTING_WIDGET_H diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.cpp b/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.cpp new file mode 100644 index 0000000..7fd8842 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.cpp @@ -0,0 +1,112 @@ +#include "textBrowserWidget.h" + +TextBrowserWidget::TextBrowserWidget(const QString &xmlFile, QWidget *pWidget) + : QWidget(pWidget) +{ + setupUi(dynamic_cast(this)); + + connect( m_main, &QPushButton::clicked, this, &TextBrowserWidget::slotClickedMain ); + connect( m_next, &QPushButton::clicked, this, &TextBrowserWidget::slotClickedNext ); + connect( m_previous, &QPushButton::clicked, this, &TextBrowserWidget::slotClickedPrev ); + connect( m_textBrowser, &QTextBrowser::sourceChanged, this, &TextBrowserWidget::slotPageChanged ); + + m_textBrowser->setOpenExternalLinks(true); + + unpack(xmlFile); +} + +/* + * HTML theory +*/ + +inline void TextBrowserWidget::slotPageChanged(const QUrl &url) { + QString value = url.toString().section('/', -1); + auto iterator = std::find_if(m_htmlPages.cbegin(), m_htmlPages.cend() + , [value](const QString &other)->bool { + return ( other.section('/', -1) == value ); + }); + if(iterator == m_htmlPages.cend()) { + m_textBrowser->clear(); + return; + } + + m_currentIndexPage = iterator - m_htmlPages.cbegin(); + bool isMainPage = (m_currentIndexPage == 0); + m_main->setDisabled(isMainPage); + m_previous->setEnabled( isMainPage ? false : m_currentIndexPage not_eq 1 ); + m_next->setEnabled( isMainPage ? false : m_currentIndexPage not_eq (m_htmlPages.size() - 1) ); +} + +inline bool TextBrowserWidget::unpack(const QString &xmlFileName) { + QDomDocument xmlDocument; + + QFile xmlFile(xmlFileName); + if(not xmlFile.open(QIODevice::ReadOnly)) { + return false; + } + + bool isSet = xmlDocument.setContent(&xmlFile); + xmlFile.close(); + + if(not isSet) { + return false; + } + + QDomElement infoNode = xmlDocument.firstChild().nextSiblingElement("info"); + + QDomElement currentDirectoryElement = infoNode.firstChildElement("directory"); + QStringList searchPaths; + while (not currentDirectoryElement.isNull()) { + searchPaths.append(currentDirectoryElement.text()); + currentDirectoryElement = currentDirectoryElement.nextSiblingElement("directory"); + } + + QDomElement currentPage = infoNode.firstChildElement("order").firstChildElement("page"); + if(currentPage.isNull()) { + return false; + } + + QStringList result; + QString currentTagName; + bool isExists; + while(not currentPage.isNull()) { + currentTagName = currentPage.text(); + isExists = false; + + for(const QString &name : searchPaths) { + if(QDir(name).exists(currentTagName)) { + isExists = true; + break; + } + } + + if(not isExists) { + return false; + } + result.push_back(currentTagName); + currentPage = currentPage.nextSiblingElement("page"); + } + + m_textBrowser->setSearchPaths(searchPaths); + m_htmlPages = result; + + return setSourceMainPage(); +} + +inline void TextBrowserWidget::slotClickedMain() { + if(m_currentIndexPage not_eq 0) { + m_textBrowser->setSource(m_htmlPages.front()); + } +} + +inline void TextBrowserWidget::slotClickedPrev() { + if(m_currentIndexPage not_eq 1) { + m_textBrowser->setSource(m_htmlPages[--m_currentIndexPage]); + } +} + +inline void TextBrowserWidget::slotClickedNext() { + if(m_currentIndexPage not_eq (m_htmlPages.size() - 1)) { + m_textBrowser->setSource(m_htmlPages[++m_currentIndexPage]); + } +} diff --git a/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h b/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h new file mode 100644 index 0000000..3dbe0c4 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h @@ -0,0 +1,50 @@ +#ifndef THEORY_WIDGET_H +#define THEORY_WIDGET_H + +#include "ui_textBrowserWidget.h" + +#include +#include +#include + +class TextBrowserWidget : public QWidget + , protected Ui::TextBrowserWidget +{ +private: + /* + * HTML + */ + QStringList m_htmlPages; + int m_currentIndexPage; + +public: + TextBrowserWidget(const QString &xmlFile = {} + , QWidget *pWidget = nullptr); + +public: + bool unpack(const QString &xmlFile); + void setFontPointSize(int size) { + QFont font = m_textBrowser->font(); + font.setPointSize(size); + m_textBrowser->setFont(font); + } + +private: + /* + * Business logic + */ + bool setSourceMainPage() { + if(not m_htmlPages.isEmpty()) { + m_textBrowser->setSource( QUrl( m_htmlPages.front() ) ); + return true; + } + return false; + } + +private slots: + void slotPageChanged(const QUrl &url); + void slotClickedMain(); + void slotClickedPrev(); + void slotClickedNext(); +}; +#endif // THEORY_WIDGET_H diff --git a/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.cpp b/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.cpp new file mode 100644 index 0000000..97e1fe5 --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.cpp @@ -0,0 +1,154 @@ +#include "mainWindow.h" + +inline void MainWindow::appendStatusbarText(const QString &value) { + m_timer->stop(); + QString newData; + if(m_lblStatusbarText->text().size() + value.size() < 150) { + newData.append(m_lblStatusbarText->text()); + } + newData.append(value + "; "); + m_lblStatusbarText->setText(newData); + m_timer->start(); +} + +inline void MainWindow::saveResult() { + QDate currentTime = QDate::currentDate(); + short day = currentTime.day(); + short month = currentTime.month(); + short year = currentTime.year() % 1000; + + constexpr short sizeDay = 5; + constexpr short sizeMonth = 4; + constexpr short sizeYear = 10; + constexpr short sizeCorrect = 8; + constexpr short sizeTotal = 8; + //constexpr short sizeSubject = 3; + //constexpr short sizeComplexity = 2; + constexpr short size = { + sizeDay + sizeMonth + sizeYear + + sizeCorrect + sizeTotal + // + sizeSubject + sizeComplexity + }; + + std::bitset newData; + for(const auto &value : std::initializer_list>{ + {day, sizeDay}, {month, sizeMonth}, {year, sizeYear} + , {m_numerOfCorrect, sizeCorrect}, {m_numberOfAll, sizeTotal} + }) { + newData <<= value.second; + newData |= value.first; + } + + QByteArray byteArray; + + while(newData.any()) { + byteArray.push_front( static_cast( newData.to_ullong()) ); + newData >>= CHAR_BIT; + } + + QFile file("save.dat"); + file.open(QIODevice::Append); + file.write(byteArray); + file.close(); +} + +MainWindow::MainWindow(QWidget *pWidget) + : QMainWindow ( pWidget ) + , m_timer( new QTimer(this) ) + , m_lblStatusbarText(new QLabel) +{ + setupUi(dynamic_cast(this)); + + /* + * Size + */ + + QSize screen = QApplication::desktop()->screenGeometry().size(); + move(screen.width() / 30, screen.height() / 20); + + /* + * Signals and slots + */ + + connect( m_tabWidget, &QTabWidget::tabBarClicked, m_demonstrationTab, &DemonstrationWidget::slotTabSwitched); + + connect( m_actionTheory, &QAction::triggered, this, [this]() { + m_stackedWidget->setCurrentIndex(0); + }); + connect( m_actionPractice, &QAction::triggered, this, [this]() { + m_stackedWidget->setCurrentIndex(1); + }); + + connect( m_actionAbout, &QAction::triggered, this, [](){ + QMessageBox::aboutQt(nullptr); + }); + + /* + * Theory + */ + + m_theoryTab->unpack("./TheoryHTML/info.xml"); + + /* + * Testing page + */ + + m_lblStatusbarText->setParent(m_statusbar); + QFont font = m_lblStatusbarText->font(); + font.setPointSize(12); + m_lblStatusbarText->setFont(font); + + m_statusbar->addWidget(m_lblStatusbarText); + m_timer->setParent(this); + m_timer->setInterval(1000 * 5); + m_timer->callOnTimeout(m_lblStatusbarText, &QLabel::clear); + + + connect( m_secondPage, &TestingWidget::signalStartOfTesting, this, [this]() { + m_numerOfCorrect = 0; + m_numberOfAll = 0; + appendStatusbarText("Testing has begun"); + }); + connect( m_secondPage, &TestingWidget::signalEndOfTesting, this, [this]() { + saveResult(); + appendStatusbarText("Test ended, results saved"); + }); + connect( m_secondPage, &TestingWidget::signalReplyGiven, this, [this](bool result) { + ++m_numberOfAll; + if(result) { + ++m_numerOfCorrect; + appendStatusbarText("Correct answer"); + } + else { + appendStatusbarText("False answer"); + } + }); + connect( m_secondPage, &TestingWidget::signalFileOpened, this, [this](bool flag) { + appendStatusbarText(flag ? "File successfully opened" : "File cannot be opened"); + }); + connect( m_secondPage, &TestingWidget::signalContentIsSet, this, [this](bool flag) { + appendStatusbarText(flag ? "Content of file successfully set" : "Failure to set content of file"); + }); + + /* + * Manual window + */ + connect( m_actionManual, &QAction::triggered, this, [this]() { + auto *manualWindow = new QDialog(this, Qt::Dialog); + manualWindow->setModal(true); + + auto *centralLayout = new QVBoxLayout; + auto *textBrowser = new TextBrowserWidget(":/ManualHTML/info.xml"); + textBrowser->setFontPointSize(12); + centralLayout->addWidget(textBrowser); + auto *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close); + connect(buttonBox, &QDialogButtonBox::clicked, manualWindow, &QDialog::close); + centralLayout->addWidget(buttonBox); + + manualWindow->setLayout(centralLayout); + manualWindow->setMinimumSize({ 800, 600 }); + manualWindow->setWindowFlags(manualWindow->windowFlags() & ~Qt::WindowContextHelpButtonHint); + manualWindow->setWindowTitle("Manual"); + manualWindow->show(); + }); +} diff --git a/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h b/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h new file mode 100644 index 0000000..ded194d --- /dev/null +++ b/SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h @@ -0,0 +1,29 @@ +#ifndef MAIN_WINDOW_H +#define MAIN_WINDOW_H + +#include "ui_mainWindow.h" + +#include +#include +#include +#include + +class MainWindow : public QMainWindow + , protected Ui::MainWindow +{ +private: + QTimer *m_timer; + QLabel *m_lblStatusbarText; + + size_t m_numerOfCorrect; + size_t m_numberOfAll; + +private: + void appendStatusbarText(const QString &value); + void saveResult(); + +public: + MainWindow(QWidget *pWidget = nullptr); +}; + +#endif // MAIN_WINDOW_H diff --git a/SourceCode/UserInterface/FilesUI/demonstrationWidget.ui b/SourceCode/UserInterface/FilesUI/demonstrationWidget.ui new file mode 100644 index 0000000..2b163f1 --- /dev/null +++ b/SourceCode/UserInterface/FilesUI/demonstrationWidget.ui @@ -0,0 +1,972 @@ + + + DemonstrationWidget + + + + 0 + 0 + 805 + 460 + + + + + 0 + 0 + + + + Form + + + + + 0 + 0 + 0 + 0 + + + + + 0 + 0 + + + + QFrame::StyledPanel + + + QFrame::Plain + + + 1 + + + + + + + 0 + 0 + + + + Progress of inserting elements: + + + + + + + true + + + + 0 + 0 + + + + + 50 + false + false + false + false + true + + + + 100000 + + + 0 + + + + + + + + + 501 + 0 + 250 + 250 + + + + + 0 + 0 + + + + + 250 + 0 + + + + Qt::ScrollBarAlwaysOn + + + Qt::ScrollBarAlwaysOff + + + QAbstractScrollArea::AdjustIgnored + + + true + + + + + 0 + 0 + 234 + 1020 + + + + + 0 + 0 + + + + + + + + 0 + 0 + + + + Resolution of collisions + + + + + + true + + + + 0 + 0 + + + + Chains + + + true + + + + + + + Open addressing + + + + + + + + + + + 0 + 0 + + + + Function + + + + + + Equivalent + + + true + + + + + + + Standart + + + false + + + + + + + + 0 + 0 + + + + FNV1a 32 bit + + + + + + + + + + false + + + + 0 + 0 + + + + Algorithm + + + + + + + 0 + 0 + + + + Linear probing + + + true + + + + + + + + 0 + 0 + + + + Pseudorandom probing + + + + + + + + 0 + 0 + + + + Quadratic probing + + + + + + + + 0 + 0 + + + + Double hashing + + + + + + + + + + + 0 + 0 + + + + Additional input data + + + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + + + Coefficient of the first family function: + + + true + + + m_sbFirstInputData + + + + + + + true + + + + 0 + 0 + + + + 100000000 + + + 1 + + + QAbstractSpinBox::DefaultStepType + + + 0 + + + 16 + + + + + + + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + + + Coefficient of the second family function: + + + true + + + m_sbSecondInputData + + + + + + + true + + + + 0 + 0 + + + + 100000000 + + + 1 + + + QAbstractSpinBox::DefaultStepType + + + 1 + + + 16 + + + + + + + + + + + + + + 0 + 0 + + + + Hash table + + + + + + + 0 + 0 + + + + Bucket quantity: + + + m_sbBucketQuantity + + + + + + + + 0 + 0 + + + + 1 + + + 10000 + + + 1 + + + + + + + + 0 + 0 + + + + Reset + + + + + + + + 0 + 0 + + + + Apply + + + + + + + false + + + + 0 + 0 + + + + Statistics + + + + + + + + + + false + + + + 0 + 0 + + + + Load table + + + + + + + + + 0 + 0 + + + + + 50 + 0 + + + + From: + + + m_leFrom + + + + + + + + 0 + 0 + + + + + 50 + 0 + + + + Quantity: + + + m_sbQuantity + + + + + + + + 0 + 0 + + + + 1 + + + 10000 + + + 1 + + + + + + + + 0 + 0 + + + + + 150 + 16777215 + + + + Qt::ImhNone + + + 4 + + + + + + + + + + 0 + 0 + + + + Make items + + + + + + + + 0 + 0 + + + + Qt::Horizontal + + + + + + + + + + 0 + 0 + + + + + 50 + 0 + + + + Value: + + + m_leInsert + + + + + + + + 0 + 0 + + + + 4 + + + + + + + + + + 0 + 0 + + + + Insert + + + + + + + + 0 + 0 + + + + Qt::Horizontal + + + + + + + + + Find free + + + + + + + false + + + Stop + + + + + + + + + Focus + + + + + + + + + + Qt::Vertical + + + QSizePolicy::MinimumExpanding + + + + 0 + 0 + + + + + + + + + 0 + 0 + + + + QFrame::Box + + + QFrame::Plain + + + 1 + + + 0 + + + + + + + 0 + 0 + + + + Output messages: + + + + + + + + 0 + 0 + + + + + Consolas + 10 + 75 + true + + + + Qt::DefaultContextMenu + + + false + + + + + + Qt::ImhNone + + + QFrame::Box + + + QFrame::Plain + + + 1 + + + 0 + + + + + + Qt::RichText + + + true + + + 0 + + + Qt::NoTextInteraction + + + + + + + + + + + + + 0 + 0 + 500 + 250 + + + + + 0 + 0 + + + + + 300 + 200 + + + + QAbstractItemView::NoEditTriggers + + + false + + + false + + + false + + + true + + + QAbstractItemView::SingleSelection + + + QAbstractItemView::ScrollPerPixel + + + QAbstractItemView::ScrollPerPixel + + + Qt::SolidLine + + + false + + + false + + + + + m_tableView + m_rightScrollArea + m_rbChains + m_rbOpenAdressing + m_rbEquivalent + m_rbStandart + m_rbFNV1a32bit + m_rbLinearProbing + m_rbPseudorandomProbing + m_rbQuadraticProbing + m_rbDoubleHashing + m_sbFirstInputData + m_sbSecondInputData + m_sbBucketQuantity + m_pbReset + m_pbApply + m_pbStatistics + m_leFrom + m_sbQuantity + m_pbMakeItems + m_leInsert + m_pbInsert + m_pbFindFree + m_pbStop + m_pbFocus + + + + + m_rbChains + clicked(bool) + m_gbAlgorithm + setDisabled(bool) + + + 861 + 45 + + + 858 + 225 + + + + + m_rbOpenAdressing + clicked(bool) + m_gbAlgorithm + setEnabled(bool) + + + 887 + 78 + + + 892 + 219 + + + + + diff --git a/SourceCode/UserInterface/FilesUI/mainWindow.ui b/SourceCode/UserInterface/FilesUI/mainWindow.ui new file mode 100644 index 0000000..c2c2b40 --- /dev/null +++ b/SourceCode/UserInterface/FilesUI/mainWindow.ui @@ -0,0 +1,261 @@ + + + MainWindow + + + + 0 + 0 + 1093 + 548 + + + + Hash tables + + + + + + + + 0 + 0 + + + + QFrame::StyledPanel + + + QFrame::Plain + + + 1 + + + 0 + + + + + + + + 0 + 0 + + + + 0 + + + + Theory + + + + + Demonstration + + + + + + + + + true + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + &Exit + + + + + + + + + + + 0 + 0 + 1093 + 20 + + + + + 0 + 0 + + + + + &Help + + + + + + + + &View + + + + + + + + + + + &User session + + + User session + + + Ctrl+N + + + + + &Open... + + + Ctrl+O + + + + + true + + + &Save + + + Ctrl+S + + + + + Save &As... + + + + + &Options... + + + + + &Manual + + + Ctrl+H + + + + + About this &program + + + Ctrl+A + + + + + &Theory + + + Ctrl+T + + + + + &Practice + + + Ctrl+P + + + + + &General + + + + + false + + + &Current + + + + + + TestingWidget + QWidget +
SourceCode/UserInterface/ClassesUI/Widgets/Testing/testingWidget.h
+ 1 + + + DemonstrationWidget + QWidget +
SourceCode/UserInterface/ClassesUI/Widgets/Demonstration/demonstrationWidget.h
+ 1 + + + TextBrowserWidget + QWidget +
SourceCode/UserInterface/ClassesUI/Widgets/TextBrowser/textBrowserWidget.h
+ 1 + + + + m_tabWidget + m_exitButton + + + + + m_exitButton + clicked() + MainWindow + close() + + + 1044 + 503 + + + 935 + 524 + + + + + diff --git a/SourceCode/UserInterface/FilesUI/testingWidget.ui b/SourceCode/UserInterface/FilesUI/testingWidget.ui new file mode 100644 index 0000000..43f26f3 --- /dev/null +++ b/SourceCode/UserInterface/FilesUI/testingWidget.ui @@ -0,0 +1,381 @@ + + + TestingWidget + + + + 0 + 0 + 716 + 545 + + + + Form + + + + + + + + <html><head/><body><p><span style=" font-size:10pt;">Testing window:</span></p></body></html> + + + m_testingTextBrowser + + + + + + + + 0 + 0 + + + + + 16 + + + + + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + + + + 0 + 0 + + + + QFrame::NoFrame + + + QFrame::Plain + + + 1 + + + 0 + + + + + + + Choose your answer: + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + + + + + Enter an integer number: + + + m_sbInteger + + + + + + + + + + + + + + Enter a fractional number: + + + m_sbInteger + + + + + + + + + + + + + + + + Confirm answer + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + + + 7 + + + QLayout::SetDefaultConstraint + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 0 + 0 + + + + Choosing a topic + + + + + + Everything + + + true + + + + + + + Discrete mathematics + + + false + + + + + + + Hash function + + + + + + + Hash table + + + + + + + Algorithm + + + + + + + + + + Choice of difficulty + + + + + + Everything + + + true + + + + + + + Easy + + + + + + + Medium + + + + + + + Hard + + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Start testing + + + + + + + false + + + Save && Stop testing + + + + + + + + + m_testingTextBrowser + m_pbStart + m_pbStop + m_sbInteger + m_pbConfirm + m_rbAllTopics + m_rbDiscreteMathematics + m_rbHashFunction + m_rbHashTable + m_rbAlgorithm + m_rbAllDifficulties + m_rbEasy + m_rbMedium + m_rbHard + m_sbDouble + + + + diff --git a/SourceCode/UserInterface/FilesUI/textBrowserWidget.ui b/SourceCode/UserInterface/FilesUI/textBrowserWidget.ui new file mode 100644 index 0000000..00a05c7 --- /dev/null +++ b/SourceCode/UserInterface/FilesUI/textBrowserWidget.ui @@ -0,0 +1,91 @@ + + + TextBrowserWidget + + + + 0 + 0 + 400 + 300 + + + + Form + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + false + + + Previous + + + + + + + false + + + Main + + + + + + + false + + + Next + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + Times New Roman + 16 + + + + + + + + + diff --git a/SourceCode/main.cpp b/SourceCode/main.cpp new file mode 100644 index 0000000..531ee0d --- /dev/null +++ b/SourceCode/main.cpp @@ -0,0 +1,11 @@ +#include "../SourceCode/UserInterface/ClassesUI/Windows/MainWindow/mainWindow.h" + +int main(int argc, char **argv) +{ + QApplication app(argc, argv); + + MainWindow mainWindow; + mainWindow.show(); + + return app.exec(); +} diff --git a/SourceCode/resources.qrc b/SourceCode/resources.qrc new file mode 100644 index 0000000..bb6e571 --- /dev/null +++ b/SourceCode/resources.qrc @@ -0,0 +1,17 @@ + + + ManualHTML/info.xml + ManualHTML/Pages/demonstration.html + ManualHTML/Pages/main.html + ManualHTML/Pages/menubar.html + ManualHTML/Pages/theory.html + ManualHTML/Pages/theoryPage.html + ManualHTML/Pages/testingPage.html + ManualHTML/Images/demonstration.png + ManualHTML/Images/menubarFirst.png + ManualHTML/Images/menubarSecond.png + ManualHTML/Images/testingPage.png + ManualHTML/Images/theory.png + ManualHTML/Images/theoryPage.png + + diff --git a/TheoryHTML/Images/2.1.png b/TheoryHTML/Images/2.1.png new file mode 100644 index 0000000000000000000000000000000000000000..9192e8257d94a37df25083721ceb7fc996916519 GIT binary patch literal 12761 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≫_>@%YE(xm-O^jpd%qoL^cppH1ssw zn`LBVcvH3r>eRmgvu`tQJ}=IdpEfMAv`hQv-~n5qAN`$w!gwR zAtFNIF_B0hRSq@BiBq<2-V{T}#P8tl9vU3nh!7DX)Q%&{iya23_hq@=7MI49ti)>@s6FnfqK+VPT=-frezu)umZySJ&-ybjjxlKi<1!x!K0%=DDA0YzhWtH}Ya* z_m^MVMx<=ypzRt4ZGJ(<0mQ|{*$tGlGBT1(2ts26eIT!PjYD&^@Ca()ty{N5HWBO* z__P?xxvuVK)JLogC9npxVFNWaWo6@slGy2OSv`J#Ek-_Q9#ZfGY5NbMh&o0Ru1O=BhVo&;891swI zf=k(U^?7CGDnkh>S))TqLD`9k>T8`+a+IZvLP?MS~UDk|DpqaiLP*1DG<$bRI8;-5c%zIpRz^2=+@{mQNr-9i-a z7(4-qnmdOsf%2^crj+< ze?el_{aiOkPEO7oagJ2O&yeJ)_}MN7l2#1@0=)3+`}aoQKimti{odKxIm%V`oQaUF z+@&5(f8fB%XG33gw%`tk<^(aE7_s{fL$(&()~)}bqC}a%Jr!jfDe@$1muk7j$WUVx ztcWDh$RLDnV$3%Z|DMXq%CCKWnIWl4%F4+&+6+6gjF8l+fB&}9(o*&T za%UM46cps-==e-Da=iXA*A_0qFI=8DU!NxKJs{BR!c z%=}Za9zUg*wXkpl2Sr5tlY^RYL_1g|Izfi5O)_^u(}??#b!ZLjKxnT)5aGO!aB@=4 zyN-rb_;n3J^-8JRtLtAPd-bwjyx^z2r}#EG66HSl>C-DHpjdrFb8{MHkv8OvbGkWK z`wFczasJqVF<&#KjBJFi@FO!-$vugT{Pf!1&^nm_mwqpJ&PYuK3y4fesPJ810}81q zDq6hvrj6ZV&k!lE;DaN5bqsau$V3ZN((zPuQ>eMfWzh+lW6M|W3@f*`wY%lr)4ebWQ)I7Rjn6oh8Jrwj8P!ef3&^=bH|y z!(+XpqfM9<^3&?u5yp*JADW0Sgi+L$+ z>RBKBY3RCdQ|wziUnbbCugc4PV2Ugxc-W5VXICiE9vM%TF*7wcKf9S4DHs+TYtUe} zy`21t2bRHuBSv6HD>lVk7vob@{OQ54B|Jq}I*gG3)60JiYZQ2E0OrH0Yz!FeExO)FyAOIImR6mFx}-lNWtebf zlsvc|-Z1gyb*QK|8G6V!F6cjeVhD>f&{T;y7sDtPrO zHTm2-z=oc5Px1r|5YdRgh9vke!PytqK^4{>aD2`&9QkuXL?lHeLTye^iyr>#TTs$= zIG~9!abk|&dtceO$Y0NJhpN>9A52L2p1Mb906~4BIniBMlAQjjW7} z&KH*+rw+nqa#2jxwiVK^zj!4Q8Yu}@#Y!^2UhccJ0Q-v7BD=m4+m>~X64UzKKDuj8 zCH_H?&zP8)3NzdF(i{8L=YlDu)N(g~CF0eqlTV+DPcTYdd*_F@c-*+5HT*^R5;IC^ za!LxRR^T?spKsAP1G8Hfxt!Gm-<6PLkgvl36CE$@X@oX ziXiGDufOMGBQqOVwjYkLMn$q6S&yt*nQT$2r?oaV)^IA_i+s3=h0Ths9P#$x&)&XI zgnMXbFxt~cY;0x9>XU>SE?d48VhcUsH}2CK_F_}Vj!o6o)q&fZX&0>e%fyG&W#I+EmxdrVDY=5K zf;<&n1H~r^Y91IE`25-Zbh`F)9mX2DSJquid3i#mja^+`9UYI&X%$GM&gZ(J1Db}06+dT<_iTn1 zPLy3)S>fmBzq9jTf1ZhAxxYW`jGilYc6N~I=~VPVSKIb1^&Jh`0MjANd2MYCi;V{n zJ~iN#{PJZ}ZBCsZ)rRglm{IxO<=xF3UL@V@%h3r57h@TB$ zxMw5>-qyGG8=mRvu5)N=c3^+n!y3L*6iX`Xptv~2=SF^t4nvZviHZZd;jk`(cUM(b zS|%oeX{xDFtfDXvoI6gVps46KiV01@u3w{I+k#iiM*sXth>us@zZYcUxlLQ4?FiEvcoG+#?uUdJyt3AwlDr5Oa}wSZbY3~2 z{K%2O8j27>>@e@&?+K$3%ZAL=5TNmz?b4kdZUPCviBqqO$djMnwm5ie6Hi2&-7`JpE|WZ6lDnI4$p>f zu8nb*ARbMOL4?>eMhd`Z)6v#W)u+A2*M>8b@?ASEAh3NfoZ?u?Ml`gvSO}P^f6X9-Mbw`9W&(&zIK;PBd39dkb23sPI{7HayHkm zQ}kP@|7FU~8UkJ(g|jRDa2ldWQ^bT%4bt zPG!YqG&>#eptZ(lVl8$~t;@dX|=!`p);cBb;?L zHIuI~S%1#%!_)HH3_+M86uMd?W5)5sma;KYzMR zbmxJGegXve^ISvUad>zbaT;>}ehQ196FdpoY_#s6kU!VeWuU0w;sMp*jCV>)JuNLQ z&CQQC5n7BmpA&yj?iIx$1O;cO9v|%U>Kw0P-dZ#8O z$-QT6MOuSjmzI>&)YP;Ses3sltg;^c`ofP;WI~~+OrT~qezJ9h|-gkfkysaDd0$N89B`J)JMs99%uu;(I?G)?0 z&|GNM;j=vX`tM(dqMemnyI{%?Je5IDA|k3Q>#5JbVoXd)5kXvow6^sVT`;=*tl{-V zK6+#fC)T){_WJefv}r_9+q-vulh=T_!bCez%FjCN@#Du~VSjN^u=h_|cap7n5)mV? zvcDorQEsg^$u0qs)m&kjtgNoSeEG6AWWORln3>u0#_i6G_)-uMHNWjrjU?h5H{ic%ECZzYl`w^N5Jd;Il}C@P_Yj^x(L7 z1z|0+CPY336#t!r!?b0KnDW%a<=#R#m|Ry-HcU-Lq%Uq@|_ln2&)03U=kciI?)68|$zbYfps? zfL`_pAXCdm!xKP*#vW-ae|HD!OtL<$Wp}O-*jG!u)UV&a=h z>H0fAs-s7bBD~;s96VuK7b>$hIyi_cr;DLd+l$-Y;s{Vh&tj|hD;;HJ8_wGI?+?Kq z-bDOYQ`W0`J^p=Hh-_&oH@n|=K-l~vF51i6n_|q^6M=Wh)Z8V=UkOP`IFk^8&4Au; z6;&_-u!b9dzr6<^=-p3oI*1@{aq%8l41g2#0?<)TF=sk);sk^avL`9xC~`NA!pu80Sa7xdRTe>QQMoG2LcoCDhVHSs!ewv`c%Ye) z)Zq~kuL=uGT*d&&k%)uVZNxcv-0Z23K>rvRd{<{bA5o4BFS8S%vygfa5fOpEhL_z1 zC`mb|qocFU0tE;ek#>y|WbIvDPho`KzP$m@%mNp)3@=~)3g|)+mo)ycB`cNC0f&y& z*V8)y%?2MEPO1h$Pm>|q)6;_+iWPT0YQsrW5LQ&=W2zvMmV#iIO!nHI?+1N;U{+qy6E3tO|VO?Af!O7gSMK@kB#p3f7=} z?pz|CW5TgL+I{d~i%#6f5BC`05nq`S#=_@ZTwO!Z>7ydTPU5Vdc&{w9_4oTM{2hc< znWoQVVQE?S+tt}Qm;$Fnm?fq-rfqw3LG&f#0KITm>%>Tm ziT*Iid#q86+CF?p0X;!#Y}&NRwt5jGEMN-5Lqn7&>G7nOzrTNTywn#sXJh0>9g$Ze7WP~Ggg6Y4IPw8hkoPclK+SQeMjVVhry&02L&`p29j?g9){-4ME zF#B@x_tDXAWH1`@wC0CgU1u{7SXfxR5Tjy*SE+VCHuej&$)}*?w6wEL{GG3Cbd{AG zA*$|D$}_=zoW%HT9s6;`K>+zqUGLR`@8Ewa1HL7aSkh-@0lA2Pv4T}WPZKzcb{E>j zz1`iT4<%s309pIo1G6RQ5Rt(KXbFvj!Y58#E%z$EIcx3g>}-8hQ9&UUU=FJT0Bly;26J@? z2KW~}dZ0eEL4nIyJBzTnnlO!}jSV>RKwsZeZ0*BldYb6)$VfElM@C02t*j{ZB`xh! z7+i!H%&6gul!C{uj0%Yhv@tX5N><#7+P*aVYks`z7XSp^jWoC+=jBLedf&p41LG+W zKOz&A^x}oBrR5vYSakn?@X8TtpqXK3;nqXGfNkgH=AsLHj7C!y)DI0kFOW8%UK{op z0c%~~)XWUw`?0Uj8%`=^s!E^f^E3I)_=5%%un?wVhBTR5D;Dw? zkR}eI7<_<9A1-1TH6FTMS9cD>FPLrFhK8i|r2__za3V0(@C$SV*T?R?OFcsZ5(jf` zdr#kRfZ+@z5jlBs^Ns^=uqlJrb`*ybr@@G|<*#9228;7*;#ut1M+6q_r3~l%8K_tv zZ95!;T%#v*lMMkLuy321nxJj2K-J;cumB`_Ub(c-$`f;fFx>@T{l~9go?D==7N!l#N>j8`L4XfuhCmye5U1kSAa;tSmzHkyJ~1SEVL3`;G&d-o2z1LlV@ zW2db!oX`%pGBxeY(&n>1dNC9UAp%o2*r?hzGWQmG zX6E_YgTDNi@=1z{is&Hv^CV)+!OVi@rGvpWgzQ7SOa|HvuAcYO3}tFdp9#ImvORn{ z_{EPYPlDLSk@bdF4B*lSO^GUuq6Qqt9Z-5M$P>zBfuv;Y+8mTer~-rfLoR@SG83|NwG=n^A3h@o5LhS-#p6oegyZ=iRx%p61Z zoy6EsCjkBLFgrQ}a-<2ehk#s0?U?ILQpkJ5^f&TjS`pg(Z2yAxbWPVWKG{ORe zp5l9!x{S#o<#KWcP(u*J2@{M zzLSx4VcSSr=A2wyG9FW={be3U1P^`aEk>%N>>)H_=5QAE@}yM#bLYrAYoUj_yPw3= zw{>+*cBE6=eCfEaa zwOJ#z1d3jm-a^4~^aA9Eq^xU>5KUG-qKWMf@ z`Fng+MZ#<0FTRI9B*m*v+0VgyW+&Te%!eKq7Dm#ubmfbEYKBLW=P(T08jsZNAZdNf zFDSruLKwZFY%fbY*qTCy2JapO0jsL20)$%OQKTa;8a~lQgO6eRL{MT)5zyJ8rGZl^)lYPLRG=v%8 z&RENnBjpH=iK%_xEF~x9RMJ1JTkD6r5Xfa7igG-mJ9Kdh5p9DghukvvT3p4l* zZ$x>~pl^%AEW_03gKFrUW2kK2B1ZSClw_(vG|1ouTJH|tOmCUC$W7@wcmD{Q_^ zMQ5LZ3u4R-cYvbs5)xU;&krdAQp|>NH3(!JEkVi{Crf)wrC{7G{6&7I_VZ83EUWSr zT({xdo0!KChaUpWZ9PMS*{^h{LtGYM^TQDOh=~(fB1xFX!{Bh5TZAIYK1$^nw;2OC z8JHwwBF5|5)HkAFx_`rkeS=Fy0RuI*R0U*iI$R|e`2z^4GxU5F`DHm=$Xh83gfT7x z60j|WD9QlO{RLY9C5i$|iAmC-+`o1iM5{bGe#`J34!t0uC+orQ>^N-TpU`tZjCHrG zlf+y`cNtu2@23_K5rMk{gTrlc$_yPy05g%;9;6_0^eAPFi2pPOb}!`_SIexgnAq7h z+s&c+V1U~#D+3-IjGQ~a^cA50@9p4}Ljkqa&0a-o3_)zM9suj8gAFHWJX=AgO!@(` zUdUqT2m>s8DjX3lUXeQvN`JJ^%nb|MwWhWwIW^VwPrsBzJ@kb$4I{SVH~zA- z!b+8uSebuo;+2XnmR0NrxZQcP$JQN&G}2X{f;P9oAR%1?ol&a_eW+xEftRs0)sq-{Q+=DI{sW@egBqReoM+Dt-TT#aCos_4Q7Q}i9@F-7 zB9xGkZCIHXZ-cXvZ>(OrkwVaBf+i8craWCgw@BXtoIKboL>;Ar74RrVts3MRD}dE5 zKEkAbLBea>9*u|rHE*yB)<7p<93OIxF_}Eo-R=OH%f`m$f`}qWd`y&0b3b2Su2|pv X_iB<;H52_T{)RZOpi0V?yXOCYUK<^_ literal 0 HcmV?d00001 diff --git a/TheoryHTML/Images/2.2.png b/TheoryHTML/Images/2.2.png new file mode 100644 index 0000000000000000000000000000000000000000..1eb085c79f72ae069a5da77c58a6374536406950 GIT binary patch literal 47425 zcmX_o2RxQ-|NgB_Nf}8}$R-LQDunD!%6t-K3z1PM5{ZzJk?a{Fijam8k)24!ZA%%c zZ2#k`_xHa)@AG+|ad+L8DgWdC3H-yR%d+aSBvRr1?JE~H?6Gb|ZD8l$qfyiBuCG)pgAM~_W=s5T_kW^i!u` zGNS_%6Xy%f6;7V4wEPggx-jdfntuKI^~tURA#=GD$*beL_U{+qTVGjp8F+p3{Ig3X zg@qo=zw>xDkw^^xE^x%MfnH_vG22hWBW8K$3Qt#W@p%6H`B#pe`z2UE&S}LK?XIe-l4h*;Se#2wPG-x?(@MToUcPLQEzkeqgwI-U zW22gpk=Me^pfUcC%IO3W$@kump}PB?SKH@~KE-jT1jH24MjYl_QM;^;jb9pVT zT`_!@Ui(sXgiU=dj|s-}F z9y@pLjNnPuFEFi~nYkhubvGo0A;$Wp+xIx0GXAmE6`% zv%O_5@$vChp1FQdipk%eQ#+vZk80en~6#JQ24_if2O)0sE%m8PSUTr z%dmaNjtb9THtzzc6)fL0G~{SJl010o`an-m>@nNuEMsh*r4K)zPPsNHh>qLF*0w80 z|64;8zj0c{Nw43LeEJP7Emztz)QM+GdU}WE;N7xQWgb7dVj4VV1}O513Ja4je0crZ z_kcm3q3cus^z`(!M`s7$-hQwcN5-?K?CXBvcra!I$=96rK3!cXORB&H8=JT}sem6? zW6ALpgJ~f{6K}C zjg2j3=R|uZ&A+P#(S?SFo;`cEBbRIGcv#V`Teliwgfxx#wNo~IOvSRKt35m-E8M)^ z&q^K|dYA4zJmen~q+Idk%lGbQibh68Px8#Fyi*>B*Vj=lnbGzoBD*7YOKbSwzTKIv zd*@|G05$U&1qCPThW%1*0;D|Bx6}s9kl1L zVc^H&8_U0qBYg`BrUQ2$vRIXBZEt^8T>J#9p`^6UKxF`1kW!SLJ@Kuppp2eGVm+@? z6J-D8xl{Ijlnr0eU+Ye{B#l{ESXyK8v~j9F3Xkk!g)QYDDL>#kZ1VEz()wG0Bep z`ZPms~3FHl`OYaaA~@#?*75x(?u5bw1Vm~d${p8 zr`1b|r?f7TU|T;LePZ8J`OOhl31RDnx+zYl*G?C1BJPeCcZcNQ_H64Zv31eju$@tm z-W4fTqYx2Vs*|pgaw1lO%~ti}W9jB}#GZ1lPCC{7{mQ+yf?{INUB*79oc=x4P1hHH z`jiHTXY#p4iB=>)$4ezil5fDmx=b8|7rKDAg`x8%xraYy`uzT1+# zFm6O#JCF{U7}(#(5MSZF8fR-|-4u5$ST+4eUnT!pUT0>hUIu28%=v~IN~X!{j{UDr zddyjvn3%Mx5FzBNcNMXB;CMtR-OZaf8TilAyISeJyuMf@AhxoysJmjE^WU3W)BRP9 zw`bpzHpUZo!glDBt5X&43miV2ed)PfH=kbC5!+7!hYlTT-GfCT>1fN#`Iclc4Ft_ zv#Gtulya%cd)4ByT~~pbS+N3fn;ovJORh)VM6KI6TFv+=`>T8&V`*+~*ep*JF`KE+ zg+vik30hp9u2LAm6AsV$lX~Ai<=x+ZJfbm%_7>{v&6^bVW%5C^SRi9Ge=1#ejf(4w zI(n=$2Tu*_P%4o9r~X9)iT=;x&#?-RpKUWvvt$K96;7l|X49qmh>^LG4@ALiz@D;s z+N9*>#*g1%ixx5ylyRGO@v8QglMCU{Im}ic)O)2B;$HuFT!Pxn7Qlb&xvmsXlAwjG+6l5Lz6G^pm=crEoVgD=+LBY_N5iJk&FNFlG zFgIEZJ~CW?R1;Y7YfDQ@qSHRBOUD?~Kj#^}u=1nV{+M|318x|fu*I7DbZNM%=(3P$ zg?r9Qim0$~k<(CZ@teYnb;P>klXY93>|apeh_c5^N}Gwv=HTKA(Ai|4gUUKrb?@)b zk&cBaC9ryXdsFWdZTa*`<3ftWl>y)Pw6e0YL{Q-~$v!I~%R}nOH!(6Wxb`vOxN%w< zc0!lc8ucWn*AW#FAK^HTp-q(3)GShNcBl~^=augtIEiF;2Cfv^NPNTBQ&|u=j`(nF zBvKh4J%0(bBYgM>&_sL~*#3RT_b!n~_{b;_H3*+1b^<{XWd%!J(V1)T^K?&OXy_~F zk%p%i-tAL8Y+Ty%=FLrmOvb<8D;XIaEHs;(>VAgAvTp9^&_nE6w`Yhu^bVxxxy}vO zQ!(&aasFpvq4(raW6H>5%e zyEOSJkALS$>?$sI8y)X%$B`RLS5fy0SLKBt%!8&kZ)U2v9x zS~-%_J+-R6*jm>i{k(<*kL`QV!E*g1vhsIdhgMxxWLqo%) z+>L>Gsx@_M0V!=tl!( z{XXkWiaiC+!|#uJuef)gqJr7{QKs7v|d@9v-a{dTC0#3t8}h=gZylUcGvinArF6k(707b8~ZF zpXn6$=;$aa#jZ~JVu1P9v$7c(8KSjL7k%~SutEj}rYzFlz3uG}g3}!OUmgB3V%4J_ zOfG!zfUZ;1b&l@saO;J0DEOvI8(4(tmsO+qICnng)6WTPjsr^N+gURK6uvsZ&N7OXsi}tw&elJ>+-x;j8^6plX;c~;aVBIR z=W|~PinnMYJ9g}_iV0gM+kS{XY%a}f_UZ&9Z@?`?silHZjqCTGs4uxfaUE^NZ72iY+!t)g_QYxPk}ws>|Kme}Z@%Ryt-J9V*k zhpC|PL%w3WZk-c9I?a z8pj{lmPhs2c!Mul^4gEay7>JlHEePLS#EckT^Y&#BAZc?SdKgUGxPgp2$^pWq>~Y| z@8J+^6u!Q2Wl_}=V5;eAnbOe$v#LGRQKwyW<4*qMia6sl2w;?BP|%mDdC$#?vT{x|JgS1U&Y!7}&nL@J%~ul?B6mj4 zQM|Hsmgw+phN)*l#+}wy7AFcrLa0w>c>KiLjlc1w*q9Y|@4(3=AL@Jetju{;BH7D} zbWhMf{{7=??%O|;C~Os!oSj+Pe&WebZM*V=c#AL91eIT#ZllY{RM({vjM$}E3Oq#B zKc;g^J6SWCCGd+}#xGQ;W?G;R2F}F9#Nxes_wwwqTv=I>Z`$$Wjo(%f4fOXPB_voa zIsY70FWlQa`0kE%p3I%s!}Sj^2&(>M7Hl9{JstBqd=nVz6{gyL=G&O~?tbBK{Pc&#_vB=0oCo(vPPoF+@ob@ADV^yltOD1An z!XpFe2;#!hlE?K&#l0dk&CJ~@m1H&6)4CVp4hGjzdU$!Yzy5u05{=B%)U+auV!yO^ z!WIMazyPbtP8LZHmG>>la@iKufxD3?sS0tw+St{7Y7C?5^E)&)2Jr0e{{o10R-l3Y zu%TXu|BhR8Tc*3I==#U_f>Rh@7<@*%RWPci+GwO%QqJF*kR==+^3J%3qkQ>y)xXO!I&!Kr%bV}de`mD>k?oq@Nvx6e}FcmeAD^{mVSLJEsFLGW+Wycaqu>#nGy5% zh&jSMAeGmNor8m@e&k;%LkX&!XiFJ+dFmrM)O~JlZsyNaj*5wm{-!!t<$Ytd7&x^A zc<*lAZS;Gcv_SU+Eu>n_IOlLf)Q3->q8Uj#PcVm&kEq?Pth^z@d)J=a5s2xk)g054 z0?UmXH_mU?j>vj$|AkNLMEeez+d^#h2qAYms?^0hR>2auJ8rz%Re} z@aV--r3=>kxG@;bJ=S0S*(@C%9$s-;pPt)FY2+}U+--?ur%dxIpLNp{gFpgxQi`T- zLHQ53HJ!tS+t@VT=hKj^WwT>mpwp2r-$FyU!QuI9Qeis7UEm{aDs7>XE9OD&1D7q< z*OrCU&yK$V^OmU|&qa0ZM=$D`y5|+}L_lcmei*t<0AP!XH2YuO=;s*#KGs{r(pDsh zYHDhFM{Zg)qrL&IXZg>x-uSm~s=<#>-Jo^F&hY25zVZ&KYiXH5)bJTUS!|3ILDFXL z;-0z4y=y#+-s?14{K$0u_{a$7six#j-V<${g8F;On`8paZERHP48WlX8kdF{UJC)0 z@kGKd>h#YG4h2U-g6WEO$9d`qMqF`rroDWLkxx&lgif@bO{2yCUVJ+3-M4gURt={) z=ZjEi@BFsz?tN)qb5}H=)emd#+&Pb?oqv#4G-f1)l1?K*qR?mE+jOB5nUfNhKKs#LRgY7Z_sgz?duc3XdbdO^iR&j=h}S`~`o z-IId_RcmB+M?X8vsC zO^5LzviyJlCAk+iHa7P5_Lk09tplm@mIus^HpQ3eDT}J_Hquf-7b-nTN)wYDuDSnc z{?{*Sx5SwP$_>uft~Ed4zAxb(m2x^^Vd+=y-_W&iG6%9F*J=iM`x^2H&WAf_y`P-VFSCY^97P}DGvVm%kK&g2Rm7vPe&ipBk za_2bmkNzs59(E0@QVeBxPu}c6!U9{<-)9!JV)Zd|+jj#@z*}niGk%X2q6%&y{Ob-= zu>O>An|jC|bb3TUR`gq)Mv=q?2M2G=#(dbT&?%cE)xd-peTshr4yFX@fGBQe)=>** zSI~QvaD=oHT~+0yBG~gN3oPvn#gnHXN64?}l8VO1t!4`!Hv(H^U2jWMt`I0A$7Vfw z(w?aqOef<+%5Xgu2t>e;R7&fc+I7?@FRFoyIgG1x*Z3T$q$Wb>zth z2+dND7faFFD{&>s=JG|fuak?m#R?fD+Orq354 zIxxHXxo2x?Yn??%?@u^Hy zsAy#F2ANBH7#J8199UcWW$VPi>#5fMpJ~j7eT>|JF)>|Sl#3shUcP*(L*O^}<&B>RUM6I7cj<1?4Sb(qrmJhX<9+xkcc{ja5uCvv)aIHF)YEW?;z} z1&yuRGn&w!CJI+Ntud$(y>Z@_sC>4aIVJA1<_(L+hoUxZ+SK9%WT`1xyM2$q!^1{m zo-za_drWVHOl~W(RGs}}WN4VNWVRDyyEAGNIh0Nq^T+ziPnrUa9ncvpHcaM^9!>>*_6E%9uEvKfm;}2kPbV};ZxpEv2n|llNhCy z6p4S;S_w`LV-Ff6c|1%ec+X+Ia%X=0=d@kK&B(3XgUS zY50cLCgK|cxcx7$Zg>UJa!Lqt1Q+=Ow7&p(;Cq!AsF`j(e%wFanwt0I2{`PA^RhYU zt|0lBv9eGBN|lHiz4rjFwzdfuUATxL%<=2XW2iSEeC_S+L$}dlSRr~@g?nL4jDelq zlPt{62I(pc+Bf6W5>GH?s^L$soF^Wp58Z2dW>8LLyT{z{?rxdd#>OXTq!2@#!OHej z8DP~p1&20KQquQn?UlN|A{*|aME*pVj^gURgM!Iy!@x%=kW=TxB3rQ$?^dF z9*|K;Ydp9=B^R$hKl0ciEbz_wsUeyidP`-G`sJ>D#KSa1AO1EvTKfTCo>2soArnW; z#4jAaB3if8^So}ARZ&#D({Q;taTUq;{=Jez($m+kWxNTd#b+PZGA(X=eEhMrk01n` z#)n4{CJ6^Pic3n=)z!CB@4NbsU~<5>NwNEhuj{F)HG*9>cyg{aO_@%E#@Wu!&hyWY zO7z8iYJAIvV3PI5hK5kS9s_zhT@BMsQwksX5OeUPr>KB{njXk1(l0-vWd((VoOBs& zL^GX4^Q~}q(xA}+EA$X>4YkB)W#J8RMVT9TF5eVTQL4OeKYk2N^-I98r2hESD!#;* zU`Tu?mJ#>H!7U~x#=&6$;sm6_{cBa*SXdqjTQ=-J?p)o~C4S;W0yDnq%SG&f{KE3G zl!U}RCXoyX9tj81z~7e8>&#@7?F8qY2@37WlHL1g@07uMSn6iKZ>5Zc)~ z>AbM6U2`aM~bqNM2EKd2#Wu(ep+KDyIHNgoP0iMgU)+bNAEHy(1QfM32!mX%tQA zh1>TYc}HWDB$=C_0LUFS_>WplOG^>9nSh3r&H4GrUvLH(`F;!zzWICSI$Q897UNgfJy5*$bM)#lpJ#3jYD-t8 zIdH-qoeiuuFw9U7aZlN}B_|)AU`|pdK_+lfW=3==1fdE7WK7LY(Y42XW zd}BzdBLp$__tz(|c&u{4K|xSkdI#S49TpIfIH@%9@liSOER@e{SFQ~F`{H(d(GLog zUC6#;Dv>;ICS(c8u(#9+%#YKxYhyXY!}x3i4&6e_$VfnFw5>6q*S_vfG|$8%7v6>+ zQiN<=N`%Vm#{m))Gj}#`-V6#Q50Qrp)z;P`7mDqH)b#;xA z*z_~hVs{@plW@{2I+vhPEyR!+*#c-DS}CY35W>)Nam}nW%r#Qie(a#3sk=rn!eQM= z-LwplJ+9E;k+^6y&mF#cq8LNgG-kk8SbxeTkd(5aRbYT{1gu3r8kuK}0-i&Pp(>Fw z&mshU4Z+uHeMMe_2}=~YtbtMirqi}PgE|kWM#KP;8%c}kE)A3js-hyr$FV`GR9pYSj!j&ozp(w9H( z2e8N|oEAxMuoY|lD28BU?D20M96nCS=3Huu1Ei=xa)KiL8z;WCSe1q8$oN2Mo^4#N^}~mW3{h>IbBDZTYwT-=g=|n(&JN zLcm23h!Rmgv$L%;H6Ec5-qg({Zcb;X(}s=)h+OMS-wHNtrb17|#U{U&|GBww>nrco zhQGhcTCdt6e9Y2Us*e0o+u6QFU2|K@j?7_R%k16(W0Jov?GRPHD~eMH1{Xmo!! zjbyz8*V-yB{sR5>6U3v-9~00pkg%;e`ndp_wbj*s6PBdJ7)TeEOk~fO=k{3W4^jM# znOm~~?NE(ZP?q4882tCMukf?)&`E+qLruZ_VcGz%h!QkDIr-eS%K>6Rety10$v!;F zzgqSc;}7D0ND@f?&?I_?RGzU zg>7D5%K$Q8%Uu3da+xy#qCU0Ac{HaJpySc9Ts*@XVnr?kS!g7lPIX`Ku=%& zZ|5G!B={E7GBbZ08++mU?Gq^HvG?I}XldN0>F6hD^>PJSZryzyp?-F4a!R@}Zmqy+c`;|G!isS$N|~ zsP+h%8iP;f=jTV|fHZ8^|7sO9##fBBe8i7t?XITOYDI|@v-?bp-{^rLJrRjKXPSMMS=;DCrN#~xMe6Iw?fT?BX|~DP-rNL#ddWn-Y$@V2Pm6_7c}6bpU1Y z41;2WA}eHA%#*qGxa(vGICFao3y!~KixhHGf}-BZ)s^L#jUIA?yqXY1G%U1w6uaLb z^8dz6(gnoKZU+YkTpiQ1DF_b)j73vi33?V-xGMNo9QF_?MGB;wS;ts)4B!e$$yssc z0T2t8O4@tnUlNmWDKW9%5O|^SqgiDpC$k|^uP@HocNf)s`69)^;ZIabAa*tltE_>6 z|1Mu11Az-&Dkjy>AFNnZls*s+u*UDX5!HXm9=5ldvWbjsL)k(If`JIw=uaPossmB; z_TSDyTG>hVKNA=dQi);*-irLlP~Ca7QJI$v0QfJGWiABL+5EsIP_&VS}idn~tIg8IB8; za7GGh2G%5bG4a2P7v)X{J$oinpdn<#%$<^wa#~K#Lv|w~a`UE5c3)qXAZupX{a?NE zMqZ%CDW>W{5VNxrcmX+B`uqFvL(n&R&1|i)nL!3=dw=~F6|_TTiR(Zgo0X;Y^>klZ zaKaK@b#*P94ol65GHHtNTMWxCIH9jaeE0*+77IS z3im-OoIZUUAOS+Z@1<*S?uOR~G5n59PUdJozUq4`t8S0U9}pO&JeKG>SP!n}yh6wT zQTbP1e?l>vat#j*gw5D}cDLGB;WTuH;gmeuZbq^V$^^0`^ZSmyNB#rC|MBBTh2+u6 zJ=}z_&8>N0RuWd7pFsH)?8g=s7PJ)mAz6s&AP3bv7Id4i4_s;wWqjm-*{Xj=0Z`E9 zy*(C3(%ZFbm&_dxc)qHSYJdWsUt9Gu&CB^$YZ4@RBv0FZdZHX(d3A#J72hVN-Q0H> zg?@bd_CbO7DHI}*+x5O-rMEV3CqLlwRhz`HR^~iH_FKG0P+(2;avR$bBV~mNz@TR3 zZXx`fNdeMs`@j#okD}xbrO;6*3oetHiG=PX!w&f6C{p8GK~wZ zE_W(PPQHMuqZqnhStL0ya2uu@s_is1{g|AA%@>j)@6^i^W;q%vK~x)W#t-~?exGcz+)Rn=4X82+=h&F$FQkB&4D zO{tYq>NK>aYdK1?E(rC)MZ2MeBNZfzdAu^Oc1ktIvNG9y=v;q7KTK}XZ|u2{~@q@)s7Zh+8nz&-hy7)MxhG# z0Nb)US01FM{RW%W^`STRFaf-b4i8r=@XgN7D$g6uTj&u2;meKh1;(w^-D^Jf^BI>O zp?0YV>OU$jZU&)GNU6G}2IjWJ7wPFy<21sZhc#Lr&^P}kc-53h>%NMz&q?fe>3JjO zba{Dx-@wj6i6}nSm#+sy!32T5<4*7F+Tu(9t*=t*;6^ReZn%lt;>r5 z@ANT#;ZfE4TKvKK**|}TfZ#ssrAW8yzmO>W@6Co;JCK)Vf+{xwmU-6l3Nfs2tvQrb zfzcCNd$l7=8y#xcUitj_^PK?n7*P1`36jE2Nd6$-SpH)a!Ym#Nlk4xQXRtc}MVf|* zTp5rlEI}J|+HIAFKO1;58TAX9m(gb`&^9gtiZ3aNHUEzkMDj=z1*3Efz5(K(O1@yU zT`bj)AUm=1LKfT;-xesLoo{@6)(!w%Ef{KdDeE98cRrqUcwo(KRg~uqER{j&^RIgR z{{0)o=jd-8;8{nYL?~do-ug@=B^AtB3t_rv=3*Lks{t@-GInu`?sxrVuDJ^{t^Uia z)}}3OIxG2ZV9I;XC=(pCI>@Ey-Q;TY$ugx-!x~Bh0|PobI?o)a5s2s1<1eRFJkYNC z%dZJ_={BOdgLja3Nq>TU6c2xbz8%f0%hmcUcX@u|Cz=O14geJEcVE7gpDQ%KKEQhs zW`qh#{d#gWcC2ih=>0o)wo+@FYaS61No8Bd$Vb0J%%PWu>X}9T-0$y3`Hw)vlS=+% zLfTZ~hc)5L#OK0`DOGQ@b0uU`i`+Xcwova&19(0VBWM!mX_TMi3wbCgpds$)#VwBP z)`SG;&Q^skM>NzAA5_DccWsbqfVv+>Bh48CKbClM4rbRjH!4QK{Ra+wR7mo$sPY#( zawM!O!^^@Vjfb1c^ei!Ue>bV}estf6GyRAL2Jpb|74EaQg1ytvIuWB6xqEVQQpYzq zBqZI#N`-QpRF9IMs)$QFgL2%E~+t@Ryt76kPVrcFoxUr26n_X!#RnMGO@m z-+j7*aN6V50aI6*(yf4v-QCBiYAJnud=wnS!@?^!T*wKVGzJ5HDN%k*| zjx3F!u@X>;g0h%)^5&LhckVyAGv7Bc9r=&+Li@~H{`(X%wersvVcD2T&V34a?d%m* z`toJl8OX?MLv=KQDl#|7)#yeMo=A*xuCu%h+~CnT1p6`t6bNQ;6C5IF%-6^H4sklY zZEh~WAcTodwZ2XvX$vY(c*hTpU^)b>!3tRe^=MCCWH_x=i^BhS;LD&o&LheuBFUrZ-&+HLlO#}-@*xJ2O!N!Ll-^F1J3 zCofL8%!8#aB6-4tWpr62uPRMxp!AQiXTz6pS08qkG4{>Zmw&6f-I3o6Gs2nK(hVdZ zV?DhNV4?-mSsAM7r^d;rH-jYZ|7h3At6+&dv22Z(%dl zh>NSH+}Bg1VDhaqw@yI^#gI%s%c&BnG+#SV@4h(4`RjSaHF<5+wrZwMQfy#w@OJec zJXIs=A*h`X-x)A8<7c0aX32&=6p6zS(m( zg!|p+&kH~V=p`TrpXg;rgobKhUwQRf*bBg?Dkv@ivq!vK+Q5<~dIN1Lq~Rj9y$_&N z$AgYMBZKgAkzD13u+{&FS=5-r743j8)8IN#fN|PA)UDvd{3+h6OADX&vbM*(_gxD zseYYSQv1}YQ*#FkF+UJmEc$4jr2>go5>1gDXkiOeh_cAfHI;qou zxKq_NgE0wuPy_ANduY3Xh-~%fxauI(k)XcAeUCWDS5ptfHb`9^f345}x6{MV?sM=# zM!hW9OtRPyT4m_a@$-<*4ZiPLE_eH$Qf2_suruk|VChr-FzfT@bK#s*Q&Sr@Y$(;U!Mr^$05?$G2c5}X+?e9|JR4!l z#t{RjZ2tuZc!`GJ_-!>#JJB=h=wqUO{&csQ4pM(NBcnJRtEUnlXn||*EUE_a07VcG zy6VPqt%44MxWJ@bY_+Rm$G#yXF&s?dl%1t~AHk>YCKy-Ot&EjuObnfBun;4F8N^88k(7d0|QIlzVEZ| z$Ki|>GhzH>>Y60#dF}?8QF<1Z8-IS7NH)@WCw&2dgP6$u{c8v-l)cXIg*VZ+RL%bF zx7M3nN!_&|q%g8*E|b)&t^4DTUaZC7IP}$z{oUN`Y;u(wf{ko$Ifs(l0&N;Sz)7D3 zZLTEV`qdgiHpd-Rix>O;LV7jb<5*X8>P{ziF0M-e{GhhBY}o>FFr8kOI72`%+Uj3j zYIww2BFPwMA_XQW-tb0|Y`A!M0(X7~dkXi~x&5Pe69S{N5CE;B;mZRY#30MbxcN?_ zAl&=EkD^VOe)Q*AZ_#~-s)9LfxVbxt)#T}avirhmSR~WtWH*I*v^s@1o>wcLgdfBB z*v0YA+?c+C1;?oC1?(7=18hHNKXBoGkD=mhzVUh3VDbEGtAG0EC1T6}P>|C6P%U-u zb2KBst~TK$M2ZC-#+aG)XE`_ys65tnALEYYe(t;to>_MhMFd379yHVvijEjag8r0r zKp=H>G8>S2BRNc;G0Rz>sdO3BFx9xVgdXpE4`PznG6&|rvTZUfWu>J%n1tnxsW}s2 zkil7-6VFyMw#&fhbsau9g8vvYDP&E=;G5H)9=)5ejIye0*})X50-HC~=$dw(Z0N<} zI7)N-TjvG~8Q?@zeFuO#fME|tO+%QGJEjsK&J*Lc5vneRvXh?kyRLPH9X)b{#~{BK z%CL?z#Tj4e5l|FZ@yr|Ndex2}=oy6L9bPOEvTw$9iRt*wbq57 z_u|DNNGee3W4}>Y{I_-I{&Qu{mf(&-`MT3YBRyKNY%pF-4i2*Ae|iR4(UiOF)Ei8M zHD@{~(M2J|@yA_)FInh(Q5wqPtVYkL&Q3xSKr@6tWr$2JrFi}LjPe3P6V!}`dmRH* zUkqlN2tBMOrO?9S!tBNT%ye+be1iHy;AJ6D)wz3kfZnx7uc8!k??=WWI|o%7X0~ek zyF*M!Q+{C4HS(Yyj1I~)=Fe$DTA)M6Lo(@h`QIZnRFY30^ha!_Nu~x1?3zbcX)!!} z!e6?X8U)XkyCLnUre-s~)E*i$(=iDK>Rky5uJ)P<&|Ch(vPyLZ1)upv&3 zfJ)yL=l%V2;X5FkOh=ubo*q2aDbM+=m>5Qb%}V;f<>@R>aO<=AOfq)%_KDUS3O_)y78Kr|4Fib@xQV6+&h66{&W6wJ$}TnS z!>E`~MM<0z1MmfxJ32lt0cHaH-nWT~S$a)XRWmbbOsIexnEZ41t>4?!ri3Bi%4!_# z3U)|K8=IWGye6sWVNVi3%L6WT%>SRje59tPmQiz1{CliBXu?m7UVz5)+)PEEbo^lR zT5&OKNurp>faglf%U$$+IkfIdfW-jG_0H@5eyS|Yn6Iu3ZZOzf^Y8vfabvNF>{(H* zhWGEYF4l$O#=yL7?AjOxl4BMEmerrE^Ut`Z1!-{%E)S%({z z6coNj!jZav5o0m~J13^AldmKgciG155j#zf2L2A^022^3Xt6`c(6Ujd6^j=ji_Z z`*#WGviwbptV~!p5WRkvBb{N0UYP9USL5$Iqonj6cL)i?-q!ZRbRm7sdzjL%oK#}| z`|L^2p)XrUD?{VN-n?^B3xa3>j_ez<(3n9u87E-c;)xXX)*XpFY~%*+7bU}(p^Z@L zp)UG^?888L${^qPM1SOwW5?{<(jcvQ0sjVkleMHm?@JZ`2KY2zTeJL|7yTQ98L@}p zS-JxLS~yhe7;mo=%5iPqSabH`Xe^b?hUHryuPrr!*`Ie07jL26Mtf z|JvbY=r(WNTK@87G@t%m?lc`75s2gm8?|TOz6Sk4O`}5d&6T`!mkqYt_Y`--jEM&A z#MOB4pUFOsUs7@j)f>arG=3T+gGV%8nRX?3IYUZg2X)WA__V#z-KM` z&K1RqNJ4)vy~0)*f&MyTaF$RDLFFMn>bg6b4*uOz8D~7Sv55&PTtQ}L-7}MHc7?lo zxo5wF`7>sqmtnF4lEaEBFQgU$yg(8k2iO7gYs@T6XwCTCURYYvKn;hPiZ}w-dfLE1 z96KK=o^Mul0EMkY_U@cqX*B=_pqQO#vVTRbN~$pB#^QGGkASa)9;wE9FMHSxD6HXmTko)w|{%VM@2&;?LPA#Cf)4} zeAVq1*^seZC)!3(c#ZWRXhnjuhVY_i&r%t`6A*w|`1s#v@Qs|Cn|tZK z>WO}ctGj;^NG>SohcOk6sD0`}ZDLeXI24NY^#fw53U2=NT$wzN?;#02cZK}IW`i~pV=TY#PY z?S~KF&>2uGMy*RCV`I;Qb0pXseGw5VO6=RS=g&3Vs{#@7k`fXv!Mh--m&mF^KEx+2 z3a4xx9j9?bXZ~B45Paz;x}t%rdtfGmQMlCY(yo2`Jm<$-De1WAVd#Dw5Ls4sJgWTx zl&cz+7jTd8*|~2J#6Z=G-iW?Y>G3mwi)<|A2cUR@E7(A82-e;n0BNOWSJ|KI|k6C!Q(s>vo{0>vZxu! zXY_mu%Zy`u_v00;B>ruN^y@EQAnVkD#W<{$L~3r~+(AvvuWF2uIX9y`DJcmN*xnxo z@UiwR4YpIrxROgBHUjO7S&9Ac67_X;V_0QK^trm3JDa;XVXCke17$P4aqG@2ouX&f zTY-!)J3R!+ymlxJbn|JSL9|*B-(_OHgtZ6lFklzJGFk+XFJ@B(1A`duIYUGAWCYgZ zqZb42+)=!8fV_JG zY36M%_r$kvnu#YCQI&Wrcn=)Q3?W?0Ym9xxk#Hg~Bucv8&E3EO%^x?y>W5Ry=}bO= zb&X9;9z{a>u+<>rLAZzJ@=alW0lS|vTEWJ}HFEzQl_5QpGhBqb%C^(hVUM3%6QXKgTuN(n*C)z;Mk{19FZ;_e?nTKxUzj~UoD zzb(|DiX{#zVbVl~TH>TJ0DZ~Rr%4K?Y{{9KmmM8_zI{4u6S}M*lS3S&glV7}`0+Sw z&~kEe8askoySfg-TZou~#8}@%()kAyWiBx=GL8YdKnwQ2mKS~b!UZR^FTz11;@k1R zVz~&2Fa&mqI2l>Znu%eFuu`}m<+;1xXZ2SXrd1EP3I5e()^>NGdkFt1$1rWa=as#y zf()9S>J|ZF%9)s)e2Ha7L7%nZ#qlQ_jpM_h^UUK(y#HIW)*EXp9w-73VVVKB>NaG< zt`fo|QVZ{BfB$3K4?)4fKj-Ir;dSY(j}_s55suS5b}*FKi}lqcks|*=g|OYX@7(e7 z^3seG&GuPen~QNwse@`>U|2Ev~~RBD*0m=k%8@p@Tt_#mp0$p3b?hNlR}CczOI% z<6f|*`BY(qyA8iDJ^DYu3}+4qLh2nm+$DvypZ@m-8V$fTBU9R23unLj;&bmDBk`!i}-{8UVHi3NVIO>0wv%j&vwh96ptX5}d=g9do z#8x`u;o4*eZ+_e?0q2lvlrEd2T10xF?xZkgZEpHspl|^}Jx6^3!@yPHs{AqFmM(mQx6C?(4Y7q@;;ki;z`DoiBHf2PffER;n=L=w$Z zVMFr5`~xP_XLxE-6sg1Lc?RFmd>97@(ot-$@eUQae?=yXM^Nwwa0ERA;>O;_rs0`2 zB?1v{9dxz2x;jiGVa!>F%*^^hk>fm!(b}-{=|VmLcmxjE`<(`xUH_rAr2W#;(wLiI zgCDW93z64f=_PK^X@{Z!$E+oQ8QR}sXE+3%86t53ki1rR!)Qd7PiO|oWUsHQ3B)Qt9am;J;#{Vr^@S_bSjZ2@ex!jYgQ}Uuvv_21iGg z#)&9Q$cy~+6XW9#V=%arzjxWIoZf-gcY*SCCe;hlXa{L>pp)$S|HX!K8dGzzk7cah> z4$(s=B4ot0nAU&K5Vwr7AI2sJ4bB`kClOuV?c0N~p|4O-5wL)PTN)TJ8ryz;%2uVX z1L_o{Z)uHU?Y{)I;lc2L(8nN?(S5lh9&c*+M%W0EZa4=D5_ot^7#oJl`i~LfM~)1< z&~k1Qt9*vqm@KNKeFP_+nPpzWLxs<;!J(m_Krf(g;Es#uPSgQyh%wU;EOB|cR9Apn z4UQr95yyHtSE8-ohp_?iC%+(GPhl(P39~3ls9H175u7VnhoEaV$9Q$plyC)9jKJ-i zvZ=YbGiCj@aC+{%S6R7=Uvk>1=K1${v2PF8>oF=#*y7;=`G zH2owJbv2&dRU0G3gJWX$nnTL^Cwew_8^@#_mSz7!j2`$}KpT?qgg@FtZ& zS3&M72F-%JM@iN|L&ZAdT<-+_$=P1X{%;_JS;MvG2Jbp_G{A-vMv?pQ5&@vZckkYn z@mVGM`ud`wh8&dcYiS9)ww;%dx9!o3ijmhK_Z}7^pKVCt>2adsUX?TI)4sg#5e+u0H9t!zpR2K&l@4r-MYQ;c? z_h7U>IWLm9u>s5Z9)SdktzMrZVg&OD&MNu;`SKAg8)h8z+neq4y8n8Ja2RlX0lJos zKjbUTB@U}X41ic-DWA3Lc*#xI7Oiu5!^ig%VAKMy9i(kTq5-s>bf59fy(Rp2K?j;$ zoSl1~+Z$mE34^%q30}CQ(8z#P?}I&RL?J;a13~lmy-NcOwx&Tl905)(<>P@t5__`t z(856tqge^D8EY#{;#_{kfUW9YT}a1$cq__sf*zh9#drRR<+whX;V+MrMmHJU|KUv(m25ja8!d@dICKo({+xw+1Nfm&pWFaLjTr`L zW`TZ6oi5_p$&X&jVXH-vG+>Rw;!`9lmUh~{e&b#tesRZ~`a>1UfxKEpcxMS!oW$Yl9 z3>XIsWPl#oH#8z@(=iSj_wzd25aDM;Y7hs4mh&S+LYmO_ti?w?sgk~~p>tJ)?HlJo zZ^oI6l3@`|)To!&rZp7J&Yj!arMo3P90YWm8<!yvYH8_6~uUi6l_F$%b+r^6)d)BQV zUvqML_A* z1_cfFP{ku>fk?(#8N?rE9wuh67g_1Y?0ZDD)en&U+n~+~f&Z16M135mqiCc4l?WEO zA}l&sO~>Ad19 zFgQH7=~TJxaYn~V7bBG@SLlJ0J#XKFQHWXRK782oNkIYT`~k45fOyUuebv4p17T=P z5VpLVoy|KvLfg@-Tc@G;2IMdu%Q3tqh0jLJrh^Bk*j4rM__;`)AZjkZNgl7(FD)%C z?vEu}DEdJ670OlzMJ{3H#GYjv(FIQ+HJ%fODXs~dA{bvmuxVZzmGGTgfCiJ`-onVD5R==`hv{2xeB;*_3f zl-3=bzV8657UU9pDxq@wk2a)Kps=@PhNgzc)v~-qF$@_O{>`Nf@prnw~+N4T_rib_)zGi^P@J zt*zm;F(|^$+0~eG%PJ$Rbcu7kc{~|74Ay&2A0Q|7dyASxYc5xoOTx_jd<6$LXO~5q z0NY2E#XKxu%Erw~QYffHe(I_p8XN8Kx7n_;4+8@O0ZM*mJUE+t`Zi8KUx}w*n4fq6 z?E;1(oRx;B;xk+&gz@Ua1zEps3foQ}*PU`~;Q9;>XD>5z@K^oa2ym?xRwNb!%T)jm zwT0mC*eJv@@g9xb4ORyX47vd3gC2~Kvq2D7JbnSa2`{yXHR2lr+Nz+u9UC9t{^rB? zsIebEG}`~8QdOot2m2nfYR~kc2Vl{NxHsVUGcC6`m8Z6?%5#H~6ruYZQono21lcgs znS-JJJ6V;m^qeqW!-jt17v)L{j%&VKx;;k^dfF_)Rx0hr?`-#4F}UHwgHu-9Wwt%_m2#5Py%Q0 zU2p2kH4t(rAch$j1CC1qVSNsN-h%c6GXwR|rpjQ@wW1n0@N^v!n@Fo3Cz{Nd0xM6E zE*nG4jDu8tDv3CJSi*UauDYY67^T`+juYh2h&^uxz&f8MAykR}_nL&mOL4I<06j(Z zZvQAF)roptsx%irg*K#h0cbetWltT(0NTWXKSq)1WjBhvi6b@~fbpvDa)EOTw)mRW z)YNDj?iIPDhGU%zPnBi5-vsZJ!^@Byp4aNNhRTfa%O5=MYylt3`~n7wl(%RH zH9f%R!L&6c_FtlDo^65?bZ~t9eL4F>&}P1cp?6sJnzd@p0cyaswM}VQ5*Z_ ztA!84S0RF~(z*aT#ciIuRgGT0pzUehkrkeoXOCH#moND1z0rde`DW6yKeyzx;Jstm zrp4ng5))15y3)^bst%2uaa9Gt#g!|2jo=5pC|;SsDx z&(;1zH#Pr`Zc)Z#$@8?eBII%2CUpxOWmKX8k0vJV7*GGT-rruAt!S!+=&LKg=-EhP4vR9wNia zhByuf*34OdbDB%SE~~X(xb5J2{DjuzaXS)TGpEgh@NP$%DH(C)4f$7Ao_s+Og4fi* z`f}2<1uumH5D9wg55WY~jX0o>P^m~}P^#e9L?B$FoYs-|QGr#WSx>3hP+EiT`HH{0-ODbWRs z)*b?3hKK=`$7p;i!Ol$LKJwkoMEdSs@yG3M9x*x(51Z=xsRu&J& z1MP<`#A{4w7Uw7EgjB1`gYC7n!gyj^?dvP&zsks>v7#YfA`M+8NT1o=ly<-<2YW&>$6Evwxjdl-NlkO zR^u%hd=wgWg*kFovVUiIZyC74WyUVW=rj_BOIuStOKYo)EBCH)SO=U=Q!+F(?7FE# z2gya_w%M-fT@^msx7Q-#q`vE10{!s?q4BcJbm0JZJZ)7>DwURBSXwXP_1AA?hEjCR ziuDrHSuhidCU%UfFw<9@tTh6xAj={-X{_aspFaa36+8x3n`}g8xhJYO?=Ya<+;Q>VRFDDX`@ADT&3~ry2c+p>WfBa*}+!XqbF|c-rda8JjU<)huFn=w}CY- zRvojwf5P#`dnwgffqh@WMZG6SbGp(UtJA1z9y`s-9zEQ(q>D}~i<*W8^Msl2r1e&w zM_VX|sfkRd-X8Pkhc-s{mosnplb94f)Y++eS}HQWuS7{un@_`I1~Xg<5$Am>+>Rmh zrNhemK2NoZ34O9XokGMxO}=Z_T=zRFKqU=F&X}6j9PYYX+b+9SOl1t0B&CyvEDwzw z@^p-vR(So_dH!A?d3+{LQ_6c9=3C_aAfv04=TlFAWY*>0@p)0*m~ek}C+?1Z`0MxY z;W3wH-Fl`wYLwN_q3Kepe{B*?{la`F(V)MO+09^SpAm~Xd^K)b7Af4FyeFKa=~%U| zH!?m7mc$vz8Tv5v^}~MWA{CTt@vr@1g>5X_(8la97_i#_6Q;b@0n=R=CEXy=PT_&= z{?}y%x!Hj@P7{EiIHp?GCB<;BY}o5`kVnPyk78c8{CysDwEM{O7Cl z8$FRZP`>tHCm{u-Ykyl`UzsuIBR@+G@Wm4KtNoI1c>;&%wY`Lv$j9ONgOw2EIzI z^jX3=Wm=O^Dx7HBVrZi=$l=Cj>kPk9PmX-pl5&?a4!OpVIp#*kYg(_x2bTA=a+;n; z*?f@qw690nnfukKtTju>rQm+`kSRdx#4g`Ym^qPCBF-nhq9myEpKg42bVEF8d*a`& z5AfCE5%(FtA-{*B=d%%`MjdUN6Q@y-HbfF|6UfLzZiuGt%(QtirZWhX$AG&dA|ehb zmRNrryWq+;7%T5_l9Ct@FDCN_{0BX=uT+cb|>$uLP}>-5@@pey0H}S6pr3v@+VY) zI;IZzK_dKJ_K}gp&<_7WJtfxiEkGo5ME?O3|KFVE{`c4X-(C3r_u2gKv-y8bv21ak^Y7{w1~oj8R^u zkLlR4qn0#)c4Uz4b6~R^tqO2K|`ivA6RZok%hUY8( zJ{r0%-u++Pi$Rq{`mENL)t-IKPhGxCmrEUM8QDB|+AN_)AYMFxi{`qPk152!GYaC9 zfXq$9@99oB-Su5F0OBsIfOH{QjlC}ePx>BsL%m5tv$=)rFit0 zG8F<98QeSoUkOS<4n=FulqmT7J>*Rm!mQh9G2-KsIXO!En}JR6eWiKV6<)zR8Ke4p zFouU|vjAn=`GSJ{&6U(|QxugIo7%LI7$w#e%Yw`|xTn1(J?7DjMx__ty?d7tMHEG| zbg~g5gj)Og*MlRA{Hwf)n;nt}$_3P~G}c;%)* z#meMwZ|?3ixJ3nDTvX)kDR(p0FzPfz;N#uh-Gz^@={O$YzMJ3v6$4pKQ#2iD*#(-C z{u>JaU{o>_;t9u(53v`%ebYFBw}*PWfFV>ageMvJ=gJ&?m}MqCax9RI0fV)8ZmZX< z(tZJ$<`8Z4$-95g?EM8mHrFw*Reg;oFtsN#h}2?U!I#18!%JQ{@5e= z$E4yr;S&X7YvpGb91eqJLi6K!1NNl3xmkR*P-St>ng{Py1f{6FcQ5&aZn<_{>5^tp zYNbrm*}!YY&IL%zTfSmPLBjao|5sCpzFABx`JQ3aF>8_&9AmcmE(2X?uS8+?i^ZUW z;bwZEUB6)In9^$bTcQ{I&yRzlPjU8iaRFZIl{M)pplMK7?ST!UKwifp>mQ#P(cRNC zLer){+U;I{8epj%%%*vv{r}Ie!5a>`o4+;CUeJ1K4gTJVI0PnU-aI_+oTf#|ty>lj zM*>Uwi-|(U5~lP+V3461Vlv(`xQ}5ZPhVm?9Z&Di`|a=5Z2PlO19Yk=Sv=J!VP~Rl z6RpWywat5QT!$~%*i7*6w%rxghr=)J?%ksV{As`g{Le?xE8NwzJ#|g5bFR-vuHlv> zL-)91ZS(88XePW}6!s{hSX11tmNt4KH%X&Gu!%;4%zrv&?e7<)h|SVk{Fb6xNdkHw zr)CVi5T@BOzPtGTF)g`Lh(+VIlf+XC?N(D$^XvP^p*s#F2^X{Z$Qh>esi5_DYBJ0o zz3-1(XDNx^!9m_vu3cM1nGYi6VgobR>+2f_eGEr9p9A=9m`*7jxk=1AGjouh-ppfR zf`V|0J%*+{=oi8&aeRK@0pH)I)Hz#L1geVLO!F0Ko?2MkNhb_{lcxtS0si>;R6z5K z9{kZwSYi=UTcsBU0!hX0_W;w$f2p5!`t)HY4sD&STfXu`*$y3YAkS+FS9eXSe=PfnM}wFsaAnQAcQ>_biBkjVd=guU$eXks^=X;rvkWuMA<|5fHId$2lsF$ zeEf!u8-)?Q!jZ3RyFhqTI@6hU9J@OnZXv3mDPw*vjk)BQB_&ba!^EgB?gQ7NF?}jq zs59#+U*E%ZFk|!tLGfF{;_Dr=nDZ&>={aS*CER8LLt2S37)=DuDcKjI81B^KRo_wU z?bvbX;=g7?oM3{&y=gSyXd?#ODcE6FFaIw{5ec)>s=ux^g@8%MeMklxZ397@h1hOd zZcg*h*Kt#JNW)UfAwpc5A}mogU{sKyv>gqs+wMx=|)WXhu^s&`kUbYCo4uFmlvd=E5Wa-g7Sb&$>I7{-!_}o(&Ti5p}Z6f(s~#@$&Mkwh z@#+tfahUAE^khj4t5O-8?c^C zL(V-JY@5{Xj&5!3&4Z`FMv!H^OqYbFy?c885e~Q^uL}=65H6la{Yiw&-I$B_E zGrNA(5P|JhKg*VBf~%2^nSV)FOz-xtA{RPJ7Mn7jbhTV0W@?0DrxCwH#@S5WFX#KbRn=|R3kdnhS8?LN1eb{L!Ldzuu zt@I8D1x-V&>X{jTrq%m<3`hz2NZ|Mgb_&I6YYE99b87y-GprCqcD~*+Aa!HAsS6#fKv!k>**HF*4)lCl8gW!+sb<*_4XOY0F8Z2=#O=F@g2i zwkMh!F>IPHm^k^2U}jEvMvN>qp5`;uP_A73d$O1r4KQLCHLTiM+tRwhHSOZddxOrb z`>*wdAnvC5k8OpA0A-=XD z5e1CQPu8XAE(Tzzzu3wIUq38DiEJ(!1@)k-q%y+&U`W8CXDUdw{L^G zH|0^|M-GY$YZWlo;F#-cr@LEWb3gaf*xCOtgdwt}Df-D}BZVw+vRwRiQBGbnPkfw+ z!EP^%V1NX>X<8e->+os9sIa0yf@#_FqGY*zEH^z;k3r8h4V0)J`8C7)%7X`aVCybk z%1Rok15$Ky`Ty0x7ajtd+enG^_e>m6zWN)@2a+P9lPF$@ zqpS5kUGe{Clbvj!h44WDMU9gxpcqFoMGugQ)M^>8`}XbIIi@NTHUSXLY&t-t@6VJ> zLFnZ_fOmS&6hevu+nQzN=Kcj5zgQ-B#il--}d00v^!+38>W^+Mvh#=WBRhhb0xAM9~(bxn3@#2xMk)? z@c@^l4P(|L`NY7UjC>-XkXec45`IKIoU8+Xd>gA0{TJm$tO~xYBg*9@{$1Y3Q9*tQ zNbG*=gejGr$8bQ_)zixp$%sic%dIoO?3>Dy4Kt|AON8w69p(9(^h_J@mbGVd~bJk>9^}<>+ytu><70b(6AW;H_=KjlBF~9?%B6c)?%t*db^v2qSI0@G@2TIe#$YU z*aIFXlpJEZsOCC=rbAn!uX|osDafqxE)n}awJ!<-Xbw7_<{wja&Np-PWpA|T4r)~4 z{{Q}t!u9^u;>3jP@I8tV>iJEXzW^1O$ZN{y0KZJGKeKDnX7j?#tWxw>Q(}WXIbsB_ z)uz_=h_4dEh`{uN4_Gy!GIZYQ;QMlkQ)WI-%rTiUcijw+sW)yoIT3yTm|7Yc1%!lz zywe?AiZVvtVy2;S4~2-v>y}97&NI-HIosBtSoTkqY`bLhtX^GqUw0VP^Q7y9vRUt^ z?i?^RxXZ1GNgI{&+6IKn4+sa`(2B29j=a?D_7#K$l{Q0UR{~lH*7jLyNJ}+QM#?s zV&*!mzF4}Egbra8$a!>gzLN1ApkJ?{shj`K{*0*k=DW#xl$}wm?6vzfkcPQVSUXu+ zEvyM502H*=pO0D{q$r73s(#XpcQH#N9Cc z0p|3x12(nMm}_rekuw0I-TaB~qywzysd=E5w6z3{{Jd61i}O+N>VEIxQFSsQ`}L1f z!%ctugq&}l*$omZ4fYv}>mJrIU3~u`aTvd{wq18KER$x9{fE|c#l9%_roo;h9R^bRv>+0Xglj9tMfAo`^r!HO73+yk#JWT)XgFQi zpyf0hn*^OOMx5jPny)|go+SRL-i^y4)>0K>&Z$22_4Z2D6FSG){+7OCp*k9J$2G5Y zbz1Gw^ZnqEHB^?Ngec}|A-dd7wT|wRS`b%!?OO9l8;BRHYHgG9=`{pLfpxh_Oeg7f zH?F^b{80bbP6O|hmU?nQvOh0!BXj4m>_blCFjU{eJO=mRE>^lvB@^i4Y%J+jij%J& z(D&+=H)k%h180UyTov^8yp*21ApObeEzcjzb`kD+&n{TJR1#CPD^{G;q{43%0in&p zj2Ypn1Chp(5^~bEIbQ&=x^eH`tZx$rSw8M^m3l>}l3PoJD+9qvY=47L!Y8ljMYj;F z?gy5M7F*w#`mSD`RGhvs?%-JAldkPPW0d*FRJ0wMM}vFF%V%-i+@4K( zxEJ|y)vo^FbWH+dm{w{SLb7n z$nwwuwepKX>+|#AG|6IBJe&t6j#zZ_$NOL^p&F>A$AkAXGN-~CxCv6Ffqi8!+S}v_ zWX{O~=$O578261*w;g(AOWg>Q#qP(gBr6-uWoaoP2&~R@U&o zcNnQjcf2rzT%?-|x+8k1jR$1J@WzbsFMK4?j6vQiFZXVIei@*ttI4+D+*}{()wKPu z-O^^BX*0!O+K-9zK+pVQ!*RI)k5W)KZ#)&wjyKm~9Np@HJ zNWoBGX>L)|dJHpF`Ez$;Y(54^|ST%MG~_oo_h!O{4$~9 z?TuOJiHZ)@(0^D*Z8YzH&tIeA{rio~fhrHG&%cdrdqhOnahOqCEVej++ugXq41(kB z>EeDHOT&)Y1^B#Tsq})2AeP$9JAJI`eVbLQRw)m_{bjneNkPb2(Ite{rYN>-B6tro ztV)fAAKRBrpR-%v>X2%^UGcU;;-0b;e5rKjUkc!>kXi3aLq=cMm#8kK35q&b+Zy4W zHHAL4%8Gk4zgleRZo5_FgF&{4nJF+|ca-ur?OmNxE!F%@kg*t*>UO2O^fFqx`Qa=2N63#*C(vY&sFEx%<0=zVwk7 zYEJ{_hHEmzawS7bHvy>ta9_!Xgas}xx)^%8eXQ*mnm|v5bE-&X!hHAW@r;alOw}M- z%0F}F@3&Dy`R>$1i7!e^O9O){l>ld4J2hEu-@Wtx%JUrtj~?wes}<$hD?Czq_Su?k zxCp!N%IfMdBbul8*6W$Pi_=1>lP;{ntRmSk0g9{twF(8stB1SKc)#2+aD!Wm-F0+a zTpWa?PYtd6t4-siqKoI(v}!CCTE&=5P3)``^B(UA9tt!#^&pKIYVgh99ksl?-qMz# z^XQwmY`R!J>S|3vSP!TVY(Olsd~l7H?TmHy$W2jP-;pPxAl_M!YpF;WyvduU@BXqBQbZ+yLd`*t>| zy6`^fUb}sN95D)QDh1WLb?cZo3Jg*^cI=pNWEEYC8sdB8x*Luy_AD=W4+>V$>A6+@ z`tLd&_4vS+ei~VzqV%aB=^7onhKo5E|LNA&Wgz`pYHGn<__!bOAr+cPHg3E&F561V z*d@o&L)tLWc5;N7R~G^}RK3ljjd}-*JMwxmaKpYAI||X$bg=-Lz*1 z|Mp2UP@q9Zmhk$anFpH_?+JgSp$JM=;1tV-qrjK39eR&$1gI+Lq&kamQ@{ZP-+F!C zV#}l=BK4h^F!v&`SW`>tBW zyipxN(Je1iAvJR-mg=DCi~|6D z#N>Ne4=`m>v!*B-ThrMwj*bMcZPFItjvnzpg%S3SU@=Rn08>Zm-%41yb}nGlaD9FH zN8;otd{|A#aY{2W9Q7S#Z_iTZPhY>*`NTT`PmCQmE^4qHgCx?ME+z{DyZjX|&>wlv zDyibBKK}>)f=^5VPgb~7SURS&^a9xM5jM+&Wj?8?v|f==%fFk^Ky*V=YRGKSoXM}g z1E=sFxeT@iMY{BX%O9N{(os(=_w1@G%{BWW7Wy%_0X{!+`0y8&j*N1o5QiaYucY0R zgdV0EVsYS|ar+|gbL@!SciyTh%C&EQj$V|p2#;e7?!Nv$t3RVPF7Y<+pQbbxLjZZ4 z0LUfsU*yY-Sy{{Jx_;$~3z8pdlix_|#Yc9AgAydw>C@f*+9Ifdj=TI;b$=J>TZC*- zO!cQGJpr-ENsjp|q}=DY3tIqX4K=k|cDft~CLvhm&xoR2`DeZD5^mt36UBa(Zy7z% zjWI1%-XY?_M44A_-_kV3`gQl{&lEjMd^H(mAIP|Pc_J?B5Oh)BfF51@9a#;k#dGC& z?+U-HY3gpMo( zvwBw*PTNq&vpMx;3{u|DbPmxjZPvn97wDB;6uBTcekQIS@dqdPkGDL2zY7m{aUE?Y zO)UmNy}#Gn@)z-$c}%!IA_o6hSFY5h%P@~JRaC&`7rPF1`UBim(5a#btkA16wciaN zU6G~XyZ7k-cyeqi2(`7)fTa=TVR&HvcwO-q4$C}YuU>MMH{-q5)VFoC%N$mMtnd#|lxwL(ca-3!xY>>En4idzQf=zp!( za6LWX?%yyf-WsYB>xI;U^t>a;YL3oaRia*ZxT%bOMVblaqbJ!2XMEYV(Ht%o8fj>1 zwtLp%QxGs+knk|gLvbkhUcYkX>)THVD=pey*4RIP@nV6yd-31+$k`lZu|DFhk$U)D zssYP|dnjlx9<$XeLqER>7!7AtP@hvPyuDdK?E&L>#w4nuyd2K`a=$=f9@$Y6Zw3kk zXr@#xds$DG*t`bciA&!gk6Ovehki^T^%^@!Vjfb|{ zN^ip_Y&Y#*T-K2zu zAo7U`Xj{rSRLKe))j)*xLGJ*Gyu7?fV1iH)RMMF1?2RjCXQin#q}s z20tPgeBGnZ7!BQMl;0WGK`?LxN#=Mq0)co*i-|PVg#h}NC{p?QcPXfd;?1n=#{C() zW+Rv0efkU;GQ{|G8kH>oFv+ON;K#>{VD$R5vQML)wiy1ed3VW3`Z_7=$JH%cx8?zq zLWu}TV2FW$_v)kEHtxtrLebjX9XO#Ugr4Mk5)y;D zPr1fz=gJ}N^I5aznvrxm2kXZOe$;fKm=Tv&H6M|9q zJmW}3NU!_sxr#CL zNh4F?Joo}H_0caoN>sbX5{jrG5|2^?*b{V+Y-G+b!6k(o$U|L@?y=}pBtS;G^TlRf z_>(73&WtqLO{`67%S<&==b7m<&DLy*M~zuZ?@VahawxEsBuO4$ZK7f6vO;tu+c7SH&4r7&Wk`E}GZfJh%#v3-a8$Z|{0OkSPfz9Bz_VQTb3`kAuYvbOMBg zql^Ozw=y_lac#fyCihcPuvgr8^>3;nUr`#TQAljN7EO6q{!hJmKu={4;o=U5%y{gI zr2)Z&t^l#M3a|@XlIJRpmT;K#Fg}D?hfAC(MbN<_6GDo;4&D zn^`SIQMz_)Sw(hk?yR2~p1b>V;26u1-=mK*slZrP*#oX`&k!~?Jc2!6_z1Sln3TgeCegbTOp+pIL29_Kp^#P+~%)IbI4 zTf}GY;YQZ$Sv|6h{c2WY61eh}UfXxFiCFJqv;eCG(3;wb>chDMdS!4_ zkBf@7Ka!*xvg4sI*=X^j)5np;Q}q!Ea6A)!DvKRob(Toxtll8yik2P@!x;aga>;{2f~In`Z^fpY(N@3+O;jPUNgdyl17 zphRtw3@EOsSV?)VcVEzq6n@!3rKzAD{sviiPme%uW`Yb zV?Of>UfDR!KW^Vu5058The~f@ED2XDyWHUkcOSDW14F}??+7&3c7A?hr{KIC53KfY zNe73c0W@w!0^IQ9Qm+4N%H2=TJmJwAxHAQv#BMO7Yb+P}%>kgGAdx^PEqSay&BM!U z6!tXF{QrIZ`gPCVy|1`vlIwU8A6Yx0qaK$!WK!}zl^5HqZ z{YEmN4`E=X{LoK7z+h5LK!+F9{d7`fbC^eC019+4bgQ3`?r?c2+ct&vXa9;P+${`Eqe{8N(k zaZ73`(OKN)i)r`)M+XekH79_xJ}djhj`eVr)F*~~h5@&GUpkwP?0q~L%s00KxBL^+(3 zx?*KspRz|YtB5E*m{naA(_S0X_LGF0nvlx-_fJq*?%dgykDS9t)`#;rm!Ho@z@OyD zZcmasd_4r>i`P*5v&a@rg+nxLVujJ<0qsME+d^S4ycT>$cx&GB(|kI3-s!<$IDfi( zd145!i&M`WX;;LHp>iM&d?02k-*NF)e$*`HWwSyye=5qPq-`9wx^27x8n@WCJ-E^w z3gKv7w0z8W_i>y4 zPy~bsFvQS!OE?Ruxy-SKiFwR6T9x@?4=2HJU1`2;k&+8vdUXv;eD~w1xaPBmygo+!*Qyoboqs1yQ!#`@cbaQZ{B>F z|0mT&;O2ogN`t!TIA{hru~A#k_2t92p;Aml3R9|~LrIQP13#EKk#@0fHIDraQ!Y0A z1bo`CVFPxJPO!-;^K0>2dcYEr3D0e;q4$ZfKXUI@q|ePt1cv0s_CUO1Ovkc)8#shJ zW0t?w#_(~U=6ZFvJT3!J4*wBqvMC;y2gtaOFl=ZpYcW1|SFz3=ePM+2sEzG(F^lUO6dNjfuIJH#{toY5S`p3=8Ed)zN+p9aslXKL$yKK?FWIKc$) zfxSIU!95-vvtvDm_6fN(SNdUECxxNeXU_ZtV+$pNz@+j0d3J?|RZ)a)z>C1_iE|-V zIv&Jb5!u)&K`nM>CTpC|CX^@A=}PDIT2yuXKR4Yt|afsz4Pggs2Y(Ptzhg`d6qm@dZW*X7wiv}eeSd1&yq2Cc8(0?3D zx@hQXD@#A6yrcOC5U_cDdwFK-^WS;RJ#}461jRg3q8WI0i9z8u(F182MfYUIbNy9H zk~_xfaveJG;!>*YKav0CG3UJ%)=fz%ym4IsoFMc^Bl(yq;(V2)OkNpX{LF9f6>l|C zfrNbAUfH9lgwkMl-aL7(gJtQ^M@3QdS0~+FHr2!+;Y{+og>U)nkkzv)XMP_2;>{ba z_33FvPoBhfnsfQyy@+Xd<;SJ*b6CEZ7Q}usj~rZ05i1DWSrTiNJ`<@9bfBX9&at;= zd`1vYeLki6T$5kA^Ym0{>7iS%9nqRENbBZqALq2bo~Y)))P0tgF^OmAyn#z;nH=U# z%b->yev;cpryTFOZU6rL?=pty(qPPt`)MRIvAEC0TXMf&$NA@HeFE$f9!!3d?-7sJ z-nF;S4w6b;5YyPyl%~$6fCT!irrkH7Ip!mHMB~q>^wG_h5ql zN4>f7*CFYDmG$vEfz~SMI;Jv90BhQtQ>Z^8tNLQIe3jKqU%pKLvG4A3u%F$JCNEmU zmnC2ZeV<8>qjI$NW#HQ96ZW^8 z2V9mzQaaT8picv4t_z`%>BI8BTehkMMTIM1DmTKl2Ke`nMQiTU1v1nS8-DfP4!t_5 z=CVSf`q87$`@R{j?vcJ?!SZVNYf!&AZTcIYebWSbVVnFtVEST8dKY)o7uy|>32L1_ z5-uhnOp6Z%+zcKlqxXJatc}^nca#B*r}Vy_gY5i-N$J{eu)ajEd?FJvHiA zkU97IrEA5kVpwiYnyv8?b9t>X%P$uf@01CnP+@<@r&meXLa^u27hN#;ZrWlV)rON= zJNBBmnRuXxFbHLs+u2Sj;pLOU!fm)Xb?wnZ^ZG<-o1~ zvh}SuMcN*oo(He|9ycRSXJoP}A;@iLqe<-Ojy<6Iruj*Iq?ewZYQ1?4R_PMYOW4<> zdA(473CaH0X*k0#RMIcoq*1JXdS$zzm5!?uOBuU#pC&v~_q3sMmOr;`82YFaM`;T~ zVFd%;MJ2!b!;Du?$;{;kuW2DO^uBukwXquh1cL2 zeEt1?3{O`OR!%5jpH(!*()Qw`kjh5JMu$$ zh8;!>qEvj8bSC4^!LGbof@D9Zi40ok*a|20!ZqO)7dEb67MH_yRGTiZw+PY1XFg#4 zeW{8WP0;J~q#Zjd}D03BVlJ zPi$CfXk=9p7H~szXTm7*OFH~7Y z<${BG^^HffGMyZkm}v2MACLEBez5ML0@so%bkKHQN4jk6M;cd$K|-{ZwOmt0gQ%++t=Zmt(s|V6h`R%xEh#;}8fK;Ft?Fl*UfGM= z<)$4^Fz+$k1uMNZS2B91Er=P-oAqnsxqBGP(5rnnY;)Q|2K64-CUwO|=S0&Oq+@dj zb7n(;lyz7;^rG`MS*oBW<2s5>Z#RuwIsX4PWtph|`5E)h#CmtJEH~$;jnzax`;`wz zzts;J@7Jj6yD4{2~va$&3@aX>~7>n?{_Fg4-KdBF;{9v;21EFesWOX^Vdz+iiKCF zv$7H__VgIOCCKPArWuF7Nf85Db~c$m(cp?bDt)|KKLHWW%4uais4qTszZ^$vA!Y#j zxGtf~CtJSq)v>GGthxSpd6ISHNfzxWMOSW0T;?t0$~DF}5n#1hrV~;BC@*tvvR};H zY}Y`KL?sa1o5s1?hQeR=QHJ@3rB4`!y57~HwelIxNUhi!z80_u zCnl|Fltuf46s+?`_cOffA*TJ**f%;o%e-lH!o!GITR$IriK)BZp}dnPpCfIA9k2T~ zhhhMSek2&0(pAxt7H}+bu2}vu+Ql4_U=)h)sitiv8ORTF5A}C z7A`f+F|3Mij#i6=QRfr7*+y9i*de}OKKU_s-n{kTA=o&ieLcTzN$Od=ZM&OM<+*XL z$jiya?6)jjJ{9990VNsR^4OI!zfzl@srQ9!PSfswTqy}p6$FgSI!g`~ip6+6W>1&9 z6SH^s?!*g4H*db8p@+zN7_$C9 zrhM+K+y$eTs4I^OwycYPB3zHM4Zqy|fcS8t+r=(hC#X+xLH~pOX4jCl#*6(v)duGO zwFkL#ABf~_xV`#^`t)Vqlg2K^dWIuZ!!FYCL$w!?o+{0~X>MvFC82APpq*a+>~QCo z&l0qrQyrg4{zSXNkbwCkF(=u5^VD@sHQTF>)NDN3M@fn8vV8^#)*09@D!t)G)IYC} zw_h&4tvn&%*|%ATLMLUbt^c|$X|3A&$Va;l^b6@Qbzy0@Ta{m?TvL4I*2C+XVuh*F zLhWhcq1Q50R3@!U-#IC0&G)m%AAB4ed-wZ;VIKD!$A7%|;qT#97b?#`TXp;B`irl} zK5-N#azIjrub{op1!l*dOp{ruxtPrVx|z^R%-kn>M#(@ zW2ZA-V(z=1402oNOx>$jQ=iH9eO^~*tbJokkxqdDXbbm-zJx*kg%QyjBSw6F;OrlZ^x(Y3 zeW2d4o#f;ezq;@hlWnle+HGp>1E=&~ld~5kCJUUgs#@P^<&mVMTJ8t!zUuN*aCiHQ ze>^nEIYW^DN?CI{=I169+?$Ls>Lc_fhvC^YbEjNh`QRi78lO5c}SmQMV5zWF3G zMOmPnVf}^-xy2;c+m&F~Pi^C*w+`NyHq;PN2^RbN^3Jht`JKJ8vNC%QDAmTX=)B@1 zPp5Cy7hg(Kh5Y`l-fWloEAJ>XbJnbgaeejL1zl?u;0hq$F0Uj6p8zsN)9^Nx8n{xG zl$7iW4(>fe8)*$OX|7=#qmiMZqJn~fSnT0ZX7k<=e*-Notpy#`=7F`piLaM2VpjJ9 zfADM6FWGkOE=7$G7~qBe$<+$)8twzagkHr@VZ2o;!kBzb+G{Q5y=w1Yc>6H-E$aQb zJxfL*KMI{fp#A&iXdEk#5Z#?wFEzo)(QzDSc6M4ya%L6t-Ez;}!ZL4bY#WKheuj_F zS1vL9rbp-LzK(@gR(}%9tsc&$v0A*ifd?XjT3e01DJkr<9HYe^0G$lSogXaB7Tg&s z39vernp#2|HLu4)QW0Yf3*1!Qp&#RKA-JK;*a&fO^oTs>?U&K&vZe|A^jL#o{^%F4 zUhU|UA|-iP2q;#6`@^;qCzg45q#CKtcT*k3FL=J6okw(Lqd5#v5#Q~`+~WZO;~}lT z&~I7_22HVg2br+SyTfejhIM1cj1lqGV6qnZ9{)#0@RgydU~!4Eypchy!hFs z-%F1~_CcsRcHI}vZ%J(>9;;9nq7tSDIpTPhJH`@g-p<_NB?i0(599v(G{=wMM2QK* zxcb?;y=Tv^<14|iVC1H@;^i0)cz8p@Vk$A#Lq9A%bU@6b^?l@DDnw)+YthU?NI7BJ zkhgD8aaENc)iCXuD@2pgj)L45PoNJ_Iob6r(G>rFxT{h>Ef;b;w{6h?vpzFs%orc% zkBppszq29OT*E=YzrRkRa&AVCeoW#j%#U&c*oK085|bMPgZJ#Ao9>~g_?dC>*`PtS zMjJN#L8MndH=g(O`m=L^-{tE@r=hfs6df6gym2GLc?i(E!6Iu|<|IvZb#+6-L-(Lm z#ti7v4%CtCP+wLC%z)?JY#Cj#<3f4j;BL^w8)&dNUXTB-i2>HzuO#2Ir=7L+C1udT z4Fd*TAfqGWR8qnzL7#Ly zO%CA6R!9}mA7atlE6g0)QZk?ajW+Ex>jfwuEA}2fa{Tx>>aD(gO;R|C{px$DGcLriYYP7eQ7b)L}%HvS#v16-!eci7r zgqTzmL1WqVG!>hX>>~H=LvXOn-JSPyk8itS{DeV+(o<4)h_mD|p#Q#l0B3&Lk*(po zcVDMmpgy-7ZaR#g?Ku-yXeA}r<;$Pp67g{8gFK2$8sbIn?k#U7OgM{hKwf@J88&ic zr;Z)n+*H%}u&z@ePHk-~_+`bxJ$Wq_hAw+Ka5NI!P^2|>K;M!;wiPDxmF_l8Gd3=| zd^w?@ASPmSExM-AWt{fv>T2R!w62@n`?X_898fBR0cPNi37A{2OS{&9^e<-*%gfD$ zvp8n0=~|>}#vf0zWk>YNm7h2hV8=%1?Dw*oGa}+1ABJ^7mlyM=O%q~bdVg3Z=Ylqa zjX}pcsLAkx!_6!#guOW0k+%+SnJ)PD^{WuXh!>+;XPQ`r9gs+VZ}2~7c$woX!!vpl z8XNn*u1-ime7~PyXeSlFNb(SWbgp1IdWMCE*S>o<-DDhob*LRV;{g#9=b;b|^+2%o zr>VH_zh4h7HoSRLzASvhY=!p45=-OGcW-)}jq+M+j6y0i8&CZrt3J+pb z6CM%q_pS54n$JHUyPxZg2@tL#&YONFr*!k;Z>qK}bP+8n9mcIaA&^jODf)eU^fRQE z;xS}oOHtn!jUOs!y3oY)YHXEtB?9?}G`=z76a|c04x;+})vIeV(^Nw4yrv(>*8Kq;D0w&)?gIWAM+6$1 zl3!O0Xt2Zv&*c~Yeq%%XOKAswe1f`?oM=Oz%u7v4IgKu3woDv};*y5Cf*Ad-Lv{*7$p~=FGvo{tgN7i!Y}q z=f+FSGpe6G`-jQUqy+21-A-|gBxS?U6;ZI>Z<}%62#Z ze)f+W`HbFq&5GU?cbNm*NKK1^?${uHT5qzqcN6%3Wo2c(wU@iQ=#*y59LMw|zAiZ> z1wD9pQad*{w})vq5J&&HurAai;zUV?xYO!TXRfZIh*V!FmKHRb8D~%|cns%I^45O7 zJ9Vca)5)az;lrs@rr?c#GF^OR12O;6qeqF%b9=Vp@!S>_l~wSpqu)|uz%`&8S?jxJ zAQ~x@7!)+Jty_s4C9yv^cQEL)Y*64I)i1o9*I~C~CBVwFO-4l%%ASx*jV0cY=siPb1MSDl4B|^WGkj z@WYoYU|bpNM3>YjOt0nshN{5KxoT=i8}zBh;X;Iv>+vGaG(QuIa;6`c@8My3u7@Sv zIQve>2H$Fm+P8e&r2B9bRXy&!^z`sp!r189v(XU~2lTTHaG-A@*8KhUX!*|#&GY8n zmZx-|@Tc+W#eaW4{x@$)lH%qL))_n)znhm+{TZY|W4OfcL2FzQj_T^_@)zyCjR{|TYuLQ3qEx^~q^`8-ngc~kSZyo*A>5;5^A(yQKS>FK*eLYz^- zV)aT9G53y528bG#+fSc9B^`!C<_=w}Vfp}co}mD#7+Th8%LuRg zgFAN)LFWD6`bkndchjb3j&Jpp&BYAuc4>ZCg}_^N2DRa~Ndf{g-OX02+Q`jED2Ffn zYyQpu6xMFy;%xC@CAsMt889Ho=FQzZfk8882-?X!o@||g&;^sI-)3xbU!>?DQoV{>(4{@v9q$WgF=5g0QVN1YeSq83lXcv#?Pq?IBW) z_`F6h2|Cz~uIf93GE?aKA}00$L)N9YKypFQPwu{EBks|%9Xld6b`$C+Ni@aa6FlK9 zN9yV8b8L8|c0GBYwTeMSl*(piX26pAdU_kQO*J(&r^k)|%UwsG`onerKb<3!U@az? zNB&GbKSc1|2mGvgz6o57MT=hX;Bhdj&YibYP0qxmm_FVmswY47!xbc(gFv=Ho=?9I2tbddfxx%P2cSxsElEN^}Bmm=t7QPM`;p5CED2RzKD^q1G( zKaD@8h1mA|`SW5hDf7-RC{@AKckTLB1P~FQ;`fBgmij*1Se&9Y_9^T9K!>hguSMUR zgQ#*eEh)kY%BM9p_j{5=k@*pyTDOuC<)uVbij%_XgU83`jWY0jQo!4j|dO1&ou!O;X;g8Reeq$ulAuOkx0V!+?>ZYDN?_?L9)&4*_}Fc zK(nr|9Vxv_v8;hx11UeAg)Hk1-aE>b#Q~phw4sZ5wYE#aK_Bn%6?`5Qu($Vc?fsto zls!#56J}^^SvX-e^tgCtV$lW0M52n3n4aM)3G>}sK8u%^GsUm2{rd<{pXH?48n&Ih zTiI6ukXpqW=o1lnUfDrul)ExOQ9uqFG-$5)JrX+`Tia~ECKswUgP+4kjhcX| zw{}J`lhrmh!x_vO7qy6wqf1juhy%r$t}A_h(`a%RO#he0#?Y&W_VZheIx!>EFx3BN z``C8-JTAZf%+yBF^``};B_+%*su}~;ybINv921a2{L>mb^xx|V|2)~*d*sOE%%0|E zW`VsC2UMT)9U8fo_E)lY#%wV$qstL7(6^m6i&D&<8b-_h%u4lfsqyhEa51)bUWcgZ z$UeW&h={s3Z^kf(x^DQ268*af2$)p<@x!m>WEnYuUD?~&Wvx{R8HJ-p*l2Vwv?F~d+WH{$Lf>u@+~e}ouRdH(_-D+ZD)^`W6U!yd^_1xlLoPE?C)i`Fk)alg z!tK0*f;x}WOQWf0L=h=qO9W&In^C$e7|6fbR1lq5qsd@6dPaiHi zERVu4?n|M|a8WJNVGU3SjERYeLN|L()YqJHSeU5cMH0cVkiC)F~+ot3wu4`nZ`T%4iriU0N- zl7N)!H*TzA&cx1&3ZHBBW+7KwSE`q;tLe&>x?ZYFyJ*y!y13LJB*5yKqz}O!i*9I6*su@A8{3!gA0t ztcxL@MyfQdZm9Hx4d&W`xw*8wV##8}cG-3d`>3lYi#&WRzgx|=B?>`B)NinMZ|-Gu z&pT(B3`9YfiO2G`ZLK|@ZI|ci86DntruV^5Hg$D%?>yQc9J6ZRL4)+Pw0&sTKZ6R?^iK>oGfapB3IX8g$S!pUE?w+3b z6Ey?}cSx`<8Kgg%`X?oY;R8c7C8i<3N94S_{$8L(UsN}b?$@4*pSX=H9jxegygtAo0An7{yTF5kCJl&+GcCvtLlhG|Q#eBT7&NFU?6)ZUUZaomKO zZIwh!Mg_c}Nmz7SA9Vf2=byaib$@;gZz+5wx)U{(Hmx=syZ7*6CyH&a>Pei3H>Dwc z46k+SXKC6#Yc3da&u-mD!me)IxbZ`fS2%}}%A6n!_Qiro#v1r9d&^Ck(hVUN&B_Q- zw(BqJSG%n?hY7v@pKaH)^G?ia-Rd%5ZcgR?$VfiqwcYb3IypV%B9`8m`mEd6eGUtj zFTcoWPM~8(5Ao~lr+9j59cnd_YrA;b#=5|pBdM)QWN~D>(&^sB7>`ua^Y)!P5&LdC zKmIH2keKpMO4>GSsVu!Jnk2itWwDgEzug;pC@Y8kLpZA`JMuqAwIm1NZ)Eo+!Jz6V zzgf`Nlq9W2yY*!oy$Ln?@qfju3j<~3+qGU@_oVXy4mHSu-BuwsxX%_Wjd?;`4H`lkO>>rk+J|{+yDCu4|2y&RWDemH^Fk(l>VsAbo(&M ztZAqfaug2=w50Y@-Zd`?T-D1@NKqXq`zUUNLV)iP)#Pu44hDF@nogfSSVw13OYLIh zlshZtdAruF+O}=G#z|$lSX+{R^I9NS9Wq$TBCUJKP)C!M<{k3hFmuC(v3W=Qq>09n z`pW|N%BL3Pw%5Zff+c6r9-V~rmH&?3df6HvaX8aJ>lXD4QH0XMY_8Scjxuf9V8RhF zZ;tl3aj~-&A3$wev7_VBgoMk=qXLKtfd(9h+6jSs0HKNPRvUlTMJ+i|-D5~Ejdr@u z$?lPLqbFv!e)4$FpNcbGXM$MNTQxuNeO5l8NPSZF;O_JRck3f=TW~C zVL);z&hz1QOZv72@8_A$p51NSDZU~pfX3pJB7^@^RJ)u!vivFAAj{+aKuo{0mL`gn z&EAvCa?>>}_bOn~joY^uDc+JH_bq!kXkuU0-`*}1B(=p12I8SOf9K-BDT!>Tqs^E( zXU?g~|J|4=2{RhpP4vRI^m{F0wBnfejTbd7@U1-L5ilx+Pi--qn-}ej{?7(giJI_< zx#}CoHabPQ?Z@0+?pvFS#|wZ?^=JG3`%2*RVjjaR|L%2udXeneyD?#572KWbgjX06 z(;6vUQo}o@|K*HXdZ3Y8h+svBvH|4OX)DC`Q?;)3X?zo;o ziolGu#Z-4A)<0FKkL|H1F+RQvlL8N0E_F`KDHa>%@s+XW@EN2tG z%~U8x^ffeg-t$mVurH}D8KXsWOnrXy=JeSPA@DCi(0gvbnm5wY0UOY)M^%hj?$j5p zl*GegQbHr|OT_n|8XAV){ngct5%}DE#Tqpel~YG@iM{lKeD12xQx{jZRie^a`eUWY zLx;`IUAH05d%wNzijGn0J+O)b1Is>^RoGS#Dv2M>7M#{Jx>t1y}m76<+dviZObIN#ZyFBDTUi|pO<6eVL+ zAxcyOuauW((HA^cntk^f){+!l2TE~mX5&}4ZdgX+O;ic2Iz2T?&yhb%%?s` zPfeY_)1GYOTYo`?zVM5)d{EJ`7OP65O-vd2pSLKTxuu=eYVj$}j4h{}m^6RO{{gHX BhsXc` literal 0 HcmV?d00001 diff --git a/TheoryHTML/Images/6.1.png b/TheoryHTML/Images/6.1.png new file mode 100644 index 0000000000000000000000000000000000000000..c4b92ab895226ff16969065c0b7b42a41d622926 GIT binary patch literal 42054 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 literal 0 HcmV?d00001 diff --git a/TheoryHTML/Images/7.2.png b/TheoryHTML/Images/7.2.png new file mode 100644 index 0000000000000000000000000000000000000000..a5e9f030ad51aedf352a7b847c1a65b792b11b5a GIT binary patch literal 42118 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

DVz2&;BjPF>L4iKZzdVgYU| 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 Q5}%Ped*Mvn>1&Vv4=e~JX8-^I literal 0 HcmV?d00001 diff --git a/TheoryHTML/Images/8.1.png b/TheoryHTML/Images/8.1.png new file mode 100644 index 0000000000000000000000000000000000000000..5343bb503d2bc3672ee1f7861da5c6d6f4dc330a GIT binary patch literal 1479 zcmV;&1vvVNP)pKX-PyuRA@u(n^`EdUmV9LLa!TSy+D+Z zeJ$Yvp=8U2B}+|-P-==SS>7wMM-d?x_99CztR*S388{!Af%B0WI3JmT^N|_8 zqmLRI8Yd?wR8kUNeH3=Fcfv)@1SFD)(omM}LrN2RY| zeSIBcaCCGeBiGW>N=!_gpP#42ibu*vn8JUdr>6%eR&afNO^g3TZf-6adPqnJmA(R; zualCJ$jIyK>&eIu4i0Fs;`zgKEiVHD17Ggrm&1UMtE;P=kDQOppb#Iox3{OKr^)BV z#YHSt3kwS*{HZYSV`^$Dwo4TimBPZptgI|EGczOr>gwuYVPPVXh}8LcFz+KmS65dk zATTiS=H>=zor{YL!m_e5Qs?KPkmtI*yj)@<@BI9nC~y!VZb=gUJa~6^cO@kyB$s}l z&CN~PNSe1k;#da7-{1f7@sTLY%ggWhI59Cn`}k(ael8LpMSuPJg-L!$RaF&jB+cJ^ z3=IvX@kc&l#K@n+!^6ehNWf<(SXF5(5ApHwl6;)6rl$5E429H#gHEeuP4vYg|SsvitZ0P>7Ei85x|9a#K-J@xS#EXJQ{8pRTU1&-%Ew zw&v#M29E$TM`Ss*wY7G3b_h*OOzP_DpbQTW+uGVfF*P+M3T>?XXlQ6)Ua_&UpY<^< zEe)AA!P(jQ@bIv*vXaIx3T{{$o0%bzJUTj}jg=qViP$82dwUspu9;eEL3WX^tDUwJci0$+jT?)3DOD0g>vP;iy5udiELT9T8KiLPi^^Rch54;^`W zdR|^$66N^#7>bRJjYuS_uCC6^%p|%jh<${2I=hoyi>itOdMQw|OeM!&wkzVL)r hl>zD_$ESFH{s(xpiHdKeOxyqf002ovPDHLkV1m6`($4?@ literal 0 HcmV?d00001 diff --git a/TheoryHTML/Pages/analysis.html b/TheoryHTML/Pages/analysis.html new file mode 100644 index 0000000..7c97a8b --- /dev/null +++ b/TheoryHTML/Pages/analysis.html @@ -0,0 +1,139 @@ + + + + + + + Страница 8 + + +

+ Страница 8 +

+
+

Анализ хеш-таблиц и алгоритмов поиска

+

Общее описание [2, c. 285-318]

+

+ Хеш-таблица представляет собой эффективную структуру данных для реализации + словарей. Хотя на поиск элемента в хеш-таблице может в наихудшем случае + потребоваться столько же времени, сколько на поиск в связанном списке, а + именно - Θ(n), на практике хеширование исключительно + эффективно. При вполне обоснованных допущениях среднее время поиска + элемента в хеш-таблице составляет O(1). +

+

+ Таблица с прямой адресацией, как хеш-таблица +

+

+ Хеш-таблица обобщает обычный массив. Возможность прямой индексации + элементов обычного массива обеспечивает доступ к произвольной позиции в + массиве за время O(1). Хеширование представляет собой исключительно + эффективную и практичную технологию: в среднем все базовые словарные + операции выполняются за время O(1). +

+

+ Недостаток прямой адресации очевиден: если совокупность ключей + U велика, хранение таблицы T размером + |U| непрактично, а то и вовсе невозможно - в зависимости от + количества доступной памяти и размера совокупности ключей. Кроме того, + множество K реально сохранённых ключей может быть мало по сравнению + с совокупностью ключей U, а в этом случае память, выделенная для + таблицы T, в основном расходуется напрасно. +

+

+ Когда множество K хранящихся в словаре ключей гораздо меньше + совокупности возможных ключей U, для хеш-таблицы требуется + существенно меньше места, чем для таблицы с прямой адресацией1. + Точнее говоря, требования к памяти могут быть снижены + до Θ(/K/), при этом время поиска элемента в хеш-таблице + останется равным O(1). Нужно только заметить, что это граница + времени поиска в среднем случае, в то время как в случае таблицы с прямой + адресацией эта граница справедлива для наихудшего случая. +

+

Хеш-таблица с прямым связыванием

+

+ Время, необходимое для вставки в наихудшем случае, равно O(1). + Процедура вставки выполняется очень быстро, в частности, потому, что + предполагается, что вставляемый элемент отсутствует в таблице. Время + работы поиска в наихудшем случае пропорционально длине списка. Удаление + элемента может быть выполнено за время O(1) при использовании + дважды связанных списков. +

+

+ Пусть у нас есть хеш-таблица T с m ячейками, в которых хранятся n + элементов. В наихудшем случае хеширование с цепочками ведёт себя крайне + неприятно: все n ключей хешированы в одну и ту же ячейку, создав список + длиной n. Таким образом, время поиска в наихудшем случае равно Θ(n) + плюс время вычисления хеш-функции, что ничуть не лучше, чем в случае + использования связного списка для хранения всех n элементов. Понятно, что + использование хеш-таблиц в наихудшем случае совершенно бессмысленно. +

+

Теорема 8.12

+

+ В хеш-таблице с разрешением коллизий методом цепочек время неудачного + поиска в среднем случае в предположении простого равномерного хеширования + составляет Θ(1 + a). +

+

Теорема 8.2

+

+ В хеш-таблице с разрешением коллизий методом цепочек время успешного + поиска в среднем случае в предположении простого равномерного хеширования + в среднем равно Θ(1 + a). +

+

+ Если количество ячеек в хеш-таблице как минимум пропорционально количеству + элементов, хранящихся в ней, то n = O(m) и, следовательно, + коэффициент заполнения равен n/m = O(m)/m = O(1). Таким + образом, поиск элемента в хеш-таблице в среднем требует постоянного + времени. Поскольку в худшем случае вставка элемента в хеш-таблицу занимает + O(1) времени (как и удаление элемента при использовании дважды связанных + списков), можно сделать вывод, что все словарные операции в хеш-таблице в + среднем выполняются за время O(1). +

+

Хеш-таблица с открытой адресацией

+

+ Мы проанализируем математическое ожидание количества исследований для + хеширования с открытой адресацией в предположении равномерного хеширования + и начнём с анализа количества исследований в случае неудачного поиска. +

+

Теорема 8.3

+

+ Математическое ожидание количества исследований при неудачном поиске в хеш + таблице с открытой адресацией и коэффициентом заполнения + a = n/m < 1 в предположении равномерного хеширования не + превышает 1/(1-a). +

+

Следствие 8.1

+

+ Вставка элемента в хеш-таблицу с открытой адресацией и коэффициентом + заполнения a в предположении равномерного хеширования требует в среднем не + более 1/(1-a) исследований. +

+

Теорема 8.4

+

+ Математическое ожидание количества исследований при удачном поиске в + хеш-таблице с открытой адресацией и коэффициентом заполнения a < 1, в + предположении равномерного хеширования и равновероятного поиска любого из + ключей не превышает +

+
+ +
+

 

+
+

+ 1В данном контексте автор, упоминая таблицу с прямой + адресацией, не применяет термин хеш, так как, предположительно, в примере + оригинальной книги не используется хеш-функция для операций поиска + элемента или все операции вставки элемента являются инъективными и не + нуждаются в решении проблем коллизий. +

+

+ 2Все доказательства теорем представлены в книге автора с целью + описания минимума методического материала +

+ + diff --git a/TheoryHTML/Pages/binaryRelationship.html b/TheoryHTML/Pages/binaryRelationship.html new file mode 100644 index 0000000..37fe6c4 --- /dev/null +++ b/TheoryHTML/Pages/binaryRelationship.html @@ -0,0 +1,149 @@ + + + + + + + Страница 2 + + +

+ Страница 2 +

+
+

Дискретная математика

+

+ Функция, как тип бинарных отношений [4, c. 96-100] +

+

+ Отношения эффективно применяются для описания связей между парами + элементов, выбранных из двух множеств А и В. Функции — + это частный случай бинарных отношений, на которые наложены дополнительные + ограничения. +

+

+ Функцией из множества А в множество В называется бинарное + отношение, при котором каждый элемент множества А связан с + единственным элементом множества В. Другими словами, для каждого + a ∈ A существует ровно одна пара из отношения + вида (а, b). +

+

+ В графических терминах функция описывается таким графом, у которого из + каждой вершины, изображающей элементы множества A, выходит + ровно одна стрелка. +

+

+ Например, на рис. 2.1 изображен граф, представляющий функцию из множества + {а, b, с} в {1, 2}, состоящую из пар (а, 1), + (b, 1) и (с, 2). +

+ +

Рисунок 2.1 - функция из множества

+
+

+

+ Пусть f - функция из множества A в множество B. + Поскольку для каждого x ∈ A существует единственным + образом определённый y∈ B, такой, что + (x, y) ∈ f, мы будем писать: y = f(x), и говорить, что + функция f отображает множество A в множество + B, а f(x) называть образом x при отображении + f или значением f, соответствующим аргументу + x. +

+

+ Кроме того, можно написать f : A → B, чтобы + подчеркнуть, что функция f переводит элементы из A в + элементы из B. Множество A принято называть + областью определения, а B - + областью значений функции1 f. +

+

+ Для уточнения подмножества элементов, в которые переводятся элементы из + A функцией f, вводят понятие "образ" или + "множество значений функции". А именно, + множеством значений функции f называется подмножество в + B, состоящее из образов всех + элементов x ∈ A. Оно обозначается символом + f(A) и формально определяется так: +

+

+ f(A) = {f(x) : x ∈ A} +

+

 

+

Свойства функций

+

+ Пусть f : A → B - функция. Мы будем называть её + инъективной или инъекцией, или взаимно однозначной, + если +

+

+ f(a1) = f(a2) ⇒ a1 = a2 +

+

+ для всех a1, a2 ∈ A. +

+

+ Это определение логически эквивалентно тому, что +

+

+ a1 ≠ a2 ⇒ f(a1) ≠ f(a2), +

+

+ т.е. у инъективной функции нет повторяющихся значений. Иными словами, + разные входные данные дают различные выходные данные. +

+

+ Будем называть функцию f сюръективной или сюръекцией, + или функцией "на", если множество её значений совпадает с + областью значений. Это означает, что для каждого + b ∈ B найдётся такой a ∈ A, + что b = f(a). Таким образом, каждый элемент области значений + является образом какого-то элемента из области определения f . +

+

+ Мы называем f биективной функцией или просто + биекцией, если она как инъективна, так и сюръективна. +

+

 

+

На рисунке 2.2 представлены различные виды функций.

+
+ +

Рисунок 2.2 - различные виды функций

+
+

Описание:

+
    +
  • + В случае (a) функция не инъективна, поскольку значение 1 соответствует + как a, так и b. Она не является и сюръективной, ввиду того, что в + элемент 2 ничего не переходит. +
    • +
  • + В случае (б) функция инъективна, так как не имеет повторяющихся + значений. Она же и сюръективна, поскольку множество ее значений + совпадает со всей областью значений. +
    • +
  • + Значение 1 эта функция в случае (в) принимает как на а, так и на Ь. + Следовательно, она не инъективна. Однако данная функция сюръективна, + поскольку в ее множество значений входят все элементы области значений. +
    • +
  • Последняя функция в случае (г) инъективна, но не сюръективна.
    • +
  • Только в случае (б) мы имеем биекцию.
    • +
+
+

+ 1Довольно часто говорят, что функция f определена или задана на + множестве A со значениями в множестве B. - Прим. перев. +

+ + diff --git a/TheoryHTML/Pages/chainMethod.html b/TheoryHTML/Pages/chainMethod.html new file mode 100644 index 0000000..c514c5f --- /dev/null +++ b/TheoryHTML/Pages/chainMethod.html @@ -0,0 +1,56 @@ + + + + + + + Страница 6 + + +

+ Страница 6 +

+
+

Решение проблем коллизий

+

Метод цепочек или прямое связывание [5, c. 170-171]

+

+ В хеш таблице с прямым связыванием (рис 6.1) значения ключей (бункеры) + хранятся в специальных наборах записей, называемых блоками. Каждый + из них является вершиной связного списка, в котором находятся привязанные + к блоку элементы. +

+
+ +

Рисунок 6.1 - хеш-таблица с прямым связыванием

+
+

+ Поиск элементов в хеш-таблице пройдёт быстрее, если связанные списки будут + содержать ключи в отсортированном порядке. В этом случае алгоритм сделает + вывод, что ключа нет, если дойдёт до значения больше ключевого и не станет + просматривать список до конца. Теоретически время его работы составит + O(N/B), но на практике оно будет немного меньше. +

+

+ Чтобы найти нужный элемент, программе необходимо хешировать ключ и + определить, в каком из блоков он может содержаться, а затем двигаться по + связному списку до тех пор, пока не будет достигнут его конец или не + обнаружится искомое. Если вы доберётесь до конца списка, значит, + запрашиваемого элемента в хеш-таблице нет. Как и в случае с добавлением + элемента, предстоит выполнить O(N/B) шагов. +

+

+ Хеш-таблица с прямым связыванием может расширяться и сжиматься1 + по мере необходимости, поэтому вам не нужно специально изменять её размер. + Однако если связные списки станут слишком длинными, поиск и удаление + элементов займут много времени. В этом случае вам понадобится увеличить + таблицу, чтобы создать больше блоков. Поскольку при рехешировании таблицы + не надо проводить поиск дубликатов до конца связного списка в каждом + блоке, полностью справиться с операцией можно за время O(N). +

+
+

+ 1Удаление элементов в данном методическом материале + рассматриваться не будет +

+ + diff --git a/TheoryHTML/Pages/dirichletPrinciple.html b/TheoryHTML/Pages/dirichletPrinciple.html new file mode 100644 index 0000000..644bfec --- /dev/null +++ b/TheoryHTML/Pages/dirichletPrinciple.html @@ -0,0 +1,52 @@ + + + + + + + Страница 3 + + +

+ Страница 3 +

+
+

Дискретная математика

+

Принцип Дирихле [4, c. 105]

+

+ Пусть f : A → B - + функция, причём как A, так и B - конечные множества. + Предположим, что A состоит из n элементов: + a1, a2,..., an. Принцип Дирихле гласит, что если |A| > |B|, то по крайней + мере одно значение f встретится более одного раза1. + Проще говоря, найдётся пара элементов + ai ≠ aj, для которых f(ai) = f(aj). +

+

+ Чтобы убедиться в истинности принципа, предположим, что для любой пары + разных индексов + i ≠ j мы имеем: + f(ai) ≠ f(aj). Тогда множество B содержит по крайней + мере n различных элементов: + f(a1), f(a2),..., f(an). И уж во + всяком случае, |B| ≥ n, что противоречит + предположению: n = |A| > |B|. Следовательно, есть хотя бы два + разных элемента + ai, aj ∈ A, для которых f(ai) = f(aj). +

+
+

+ 1Допуская некоторую вольность, принцип Дирихле можно + переформулировать в легко запоминающейся форме: нельзя рассадить 10 зайцев + в 9 клеток так, чтобы в каждой клетке сидел один заяц - Прим. перев. +

+ + diff --git a/TheoryHTML/Pages/hashFunction.html b/TheoryHTML/Pages/hashFunction.html new file mode 100644 index 0000000..c50ec6a --- /dev/null +++ b/TheoryHTML/Pages/hashFunction.html @@ -0,0 +1,102 @@ + + + + + + + Страница 4 + + +

+ Страница 4 +

+
+

Хеш-фукнция

+

Свойства хеш-функции

+

+ Хеш-функция (англ. hash function от hash — + «превращать в фарш»), или функция свёртки — + функция, осуществляющая преобразование массива входных данных + произвольной длины в выходную битовую строку установленной + длины, выполняемое определённым алгоритмом. Преобразование, + производимое хеш-функцией, называется хешированием. Исходные данные + называются входным массивом, «ключом» или + «сообщением». Результат преобразования называется + «хешем», «хеш-кодом», «хеш-суммой», + «сводкой сообщения».[7] +

+

Свойства хеш-функции:

+
    +
  • Должна обладать свойствами функции.
    • +
  • + Не должна обязательно являться инъективной или сюръективной. +
    • +
+

Определения :

+
    +
  • + Если известна область определения и можно задать отображение в область + значений, мощность которого будет больше или эквивалентна мощности + области определения, при котором хеш-функция будет являться + инъективной, то такая хеш-функция будет являться идеальной хеш-функцией. +
    • +
  • + Если область определения неизвестна и можно задать отображение в + область значений, мощность которого будет больше или эквивалентна + мощности области определения, при котором хеш-функция будет + являться инъективной, то такая хеш-функция будет являться динамической идеальной хеш-функцией. +
    • +
  • + Если известна область определения и можно задать отображение в + область значений, мощность которого будет эквивалентна мощности + области определения, при котором хеш-функция будет + являться биективной, то такая хеш-функция будет являться + минимальной идеальной хеш-функцией. +
    • +
  • + Хеш-функция является k-совершенной хеш-функцией, + если область определения неизвестна и можно задать отображение в + область значений, любой элемент которого будет обладать не более чем k + отношениями. +
    • +
+
+ Существует несколько терминов, связанных с хеш-функцией: +
+
+
Хеш
+
+ элемент области значений, соотнесённый с заранее известным элементом из + области определения. +
+
Хеширование
+
это процесс получения хеша.
+
Коллизия
+
+ ситуация, при которой нарушается условие инъективности хеш-функции. +
+
+

+ Производительность хеширования в среднем случае зависит от того, насколько + хорошо хеш-функция приближена к биективной k-совершенной хеш-функции, где + разность количества отношейний любых двух элементов области значений + стремиться к нулю. Другими словами, каждый элемент области значений + обладает минимально возможным количеством отношений. Данное хеширование + автор книги [2, с. 291] Томас Кормен называет + простым равномерным хешированием. +

+
+ Существует множество разнообразных хеш-функций, алгоритмы которых + применяются в различных ситуациях, например, когда требуется скорость + вычисления хеш-значения, но с повышенным шансом появления коллизии или + наоборот. +
+ + diff --git a/TheoryHTML/Pages/hashTable.html b/TheoryHTML/Pages/hashTable.html new file mode 100644 index 0000000..39ad099 --- /dev/null +++ b/TheoryHTML/Pages/hashTable.html @@ -0,0 +1,120 @@ + + + + + + + Страница 5 + + +

+ Страница 5 +

+
+

Хеш-таблица

+

Свойства хеш-таблицы

+

+ Хеш-таблицы являются одним из способов хранения данных при помощи + ассоциативного массива [12]. +

+

+ Хеш-таблицы решают несколько главных проблем при оперировании с данными: +

+
    +
  • + Создание отношения (связи) между ключом и абсолютно любым + значением. +
    • +
  • Решение проблем коллизий.
    • +
+

+ Для большего понимания материала требуется ознакомиться с новыми терминами + хеш-таблицы: +

+
+
Ключ или сообщение
+
использующийся хеш-таблицей произвольный элемент из области определения хеш-функции.
+
Бункер или корзина
+
произвольный элемент, который хранит данные хеш-таблицы.
+
Коэффициент заполнения
+
+ отношение количества заполненных бункеров на количество возможных ключей. +
+
+

+ Исходя из определений, бункер - это условная единица хранимой информации в + хеш-таблице (ассоциативном массиве данных). +

+

+ Решение первой проблемы. Хеш-функции в хеш-таблице, нужны по причине получения хеша в процессе + хеширования ключа, однако хеш - значение абстрактное, так как невозможно + создать такой алгоритм, который бы выдавал хеш, как набор данных, + используемый в процессе работы программы или это очень сложно.
+ Для большего понимания нужно вспомнить пример о "продавце в маленьком магазинчике", где "помощница" + абстрагирует понятие хеш-функции, которая выдавала для каждого товара + конкретную цену, что возможно, но трудозатратно.
+ Для этого требуется хеш-функция, где хеш является универсальным + идентификатором конкретного бункера, в котором располагается необходимый + пользователю набор данных. +

+

+ Томас Кормен говорит в книге [2, c.288], что цель хеш-функции состоит в + том, чтобы уменьшить рабочий диапазон индексов массива - размер массива + может быть равен соотносительно намного меньшему значению, чем мощность + множества всех существующих значений ключей, которые могут потенциально + использоваться в процессе работы программы. +

+

+ Из этого можно выделить несколько особенностей хеш-таблиц: +

+
    +
  • + Каждый бункер имеет в качестве уникального идентификатора + хеш-значение +
    • +
  • + Каждый ключ гарантированно имеет связь только с одним бункером. +
    • +
  • + Количество бункеров относительно количества ключей сильно ограниченно. +
    • +
  • + От хеш-функции зависит коэффициент заполнения. +
    • +
  • + По принципу Дирихле коллизия неизбежна в ситуации, когда количество ключей больше, чем количество бункеров. +
    • +
+

+ Решение второй проблемы. Хеш-таблицы используют в качестве + алгоритма поиска элемента контейнера (бункера) хеш-функцию, которая по + принципу Дирихле гарантированно создаст коллизии в ситуации, когда + количество ключей больше, чем количество бункеров, а обычно так бывает + всегда. +

+

+ Хеш-таблицы решают данную проблему двумя способами:  +

+
    +
  • Метод цепочек или прямым связыванием.
    • +
  • Открытой адресацией.
    • +
+ + diff --git a/TheoryHTML/Pages/introduction.html b/TheoryHTML/Pages/introduction.html new file mode 100644 index 0000000..1ae6bce --- /dev/null +++ b/TheoryHTML/Pages/introduction.html @@ -0,0 +1,116 @@ + + + + + + + Страница 1 + + +

+ Страница 1 +

+
+

Введение

+

Гардероб [3, с. 393-394]

+

+ Когда вы сдаете в гардероб пальто или сумку, вам выдают номерок. Когда же + вы собираетесь покинуть помещение, вы отдаете номерок, и вам возвращают + ваше пальто или сумку. +

+

+ Если вдуматься, какую задачку решает данный процесс, можно увидеть, что + это задача о поиске и нахождении объекта. Ваше пальто — это объект, + который вы передаете гардеробщику; пальто сначала привязывают к + определенному номерку, а затем возвращают вам. Метод работает за счет + того, что в гардеробе находятся ряды пронумерованных вешалок для одежды и + пронумерованные отделения для сумок. Вашему номерку соответствует + определенная вешалка или определенное отделение. Гардеробщик же отвечает + за то, чтобы разместить ваш объект в нужном месте и чтобы забрать его с + помощью отданного вами номерка. +

+

+ Когда речь идет о поиске, люди чаще всего представляют себе, что нужно + перебирать вещи до тех пор, пока не найдется нужная; процесс становится + проще, если вещи отсортированы так, что мы можем искать среди них более + слаженно. Гардероб же показывает, что есть и другой способ: присвоить вещи + адрес, где она будет располагаться, и затем сразу достать ее из указанного + места. В гардеробе адрес указан на номерках, и гардеробщик на самом деле + ищет не ваши вещи: он смотрит на номерок, на адрес и идет к указанной + вешалке или отделению с вашими вещами. +

+

+ Весь метод в целом можно назвать определением местонахождения + без поиска: мы не ищем объект, а получаем адрес места, где он будет + храниться. Соотносим объект с адресом, а затем, когда хотим найти объект, + мы идем прямиком к нужному месту. +

+

+ Теперь рассмотрим данный метод с точки зрения компьютерного мира, где наши + объекты представлены в виде записей, содержащих атрибуты. Мы хотим уметь + переходить напрямую от записи к адресу, по которому она размещена; + адресом будет число, соответствующее области в компьютерной памяти. + Главная загвоздка в такой задачке — то, как соотнести адрес с + элементом. Нам нужен быстрый и надежный способ, и мы не можем положиться + на какого-либо посредника. Когда мы ищем запись, мы ищем ее по одному или + большему числу атрибутов, которые формируют ключ записи, поэтому нам нужен + метод получения адреса из ключа записи. Так как адрес — это число, + нам нужен способ, который перенесет нас от ключей к числам. Иными словами, + мы нуждаемся в функции, скажем, f(K), которая возьмет ключ K записи + R и вернет значение a = f(K). Значение a представляет собой адрес, + где будет храниться запись, мы идем по нему и оставляем там нашу запись. + Каждый раз, когда нам требуется достать нашу запись с помощью ключа, мы + снова прибегаем к функции f(K), которая вернет то же адресное + значение a, откуда мы и заберем нашу запись. Функция должна быть быстрой и + достаточно скоро находить нужный адрес: как минимум, не дольше, чем поиск + по записям до тех пор, пока не найдется та, которую мы ищем. В противном + случае толку от такой функции никакого. Если же мы в самом деле + обзаведемся такой функцией, то разрешим нашу задачку с местоположением + новым способом: не мы будем искать элемент, а сам элемент расскажет нам, + где его найти: расскажет с помощью нашей функции. +

+

Продавец

+

+ Так же стоит привести введение в теоретический материал, описанное автором + книги [1, c. 100-101], где описывается пример с "продавцом в + маленьком магазинчике". +

+

+ В ситуации, когда клиент покупает + у продавца товар необходимо определить ценность предмета. + Изначально стоит отметить, что цены в магазинах на один и тот же товар + всегда одинаковый в один момент времени, поэтому необходимо хранить + информацию о ценах, например, в книге, однако данный метод оперирования + информацией будет весьма утомителен и ужасно неэффективен. Для + решения этой проблемы продавец нанимает помощницу, которая + безошибочно определяет цену на товар, если посмотрит на него или узнает + его название. +

+

+ Автор абстрактно описывает проблему с упорядоченным контейнером данных, + где может потребоваться простой поиск, алгоритм которого обладает линейной + сложностью. В данном примере контейнер является хранилищем элементов, + каждый из которых может повторяться, но обязан иметь только один + уникальный идентификатор. Можно с уверенностью выделить две проблемы, от + которых можно избавиться в идеальных условиях — затраты на + хранение элементов и поиск каждого из них при помощи уникального + идентификатора. В приоритете необходимо выполнять успешный поиск элемента, + алгоритм которого будет выполняться за константное время. +

+

+ Решением является использование функции [4, c. 96] из множества A в + множество B. Данная функция описывает бинарное отношение, при + котором каждый элемент множества А связан с + единственным элементом множества B.  Данная функция в + программировании имеет название хеш-функция. Избавиться от необходимости в + хранении множеств элементов, чтобы сохранялась возможность определять + новые бинарные отношения, не изменяя другие очень сложно, однако это + возможно. Обычно, когда известны все элементы множества А и все + элементы множества B, реализуют функцию, при которой любой элемент + множества А имеет одно отношение с любым элементом из множества + B. Например, данную функцию можно применить в примере с продавцом и + помощницей, если каталог товаров не изменяется, но цены на разные товары + могут совпадать. +

+ + diff --git a/TheoryHTML/Pages/main.html b/TheoryHTML/Pages/main.html new file mode 100644 index 0000000..a53dde1 --- /dev/null +++ b/TheoryHTML/Pages/main.html @@ -0,0 +1,170 @@ + + + + + + + Теоретический материал + + +

Теоретический материал

+ +

+ Необходимый минимум теории по теме
+ "Алгоритм вставки в хеш-таблицу" +

+ +

Описание страницы:

+ +

+ Главная страница, предоставляющая пользователю быстрый и удобный поиск + нужного разбитого по темам материала.
+ Каждый элемент списка оглавления является гиперссылкой при нажатии на + которую можно мгновенно перейти к необходимому разделу информации.
+ Предоставленный пользователю теоретический материал был взят из списка + использованной литературы в конце данной страницы. +

+ +

Оглавление:

+ +
    +
  1. + Введение. +
    2. +
  2. Дискретная математика: + +
    3. +
  3. + Хеш-функция. +
    4. + +
  4. + Хеш-таблица. +
    5. +
  5. Решение проблем коллизий: + +
    6. +
  6. Анализ хеш-таблиц и алгоритмов поиска.
    7. +
+ +

Список использованной литературы

+ +
    +
  1. + Бхаргава, А. Грокаем алгоритмы. Иллюстрированное пособие для + программистов и любопытствующих / Адитья Бхаргава. — СПб. : + Питер, 2017. - 288 с. : ил. — (Библиотека программиста). +
    2. +
  2. + Кормен, Т. Х. Алгоритмы: построение и анализ, 3-е изд / Томас Кормен ; пер. с англ. — Москва : + ООО "И. Д. Вильямс", 2013. — 1328 с. : ил. — Парал. тит. англ. +
    3. +
  3. + Луридас, П. Алгоритмы для начинающих : теория и практика для + разработчика / Панос Луридас ; пер. с англ. Е.М. Егоровой. — Москва : + Эксмо, 2020. — 608 с. — (Мировой компьютерный бестселлер). +
    4. +
  4. + Хаггарти, Р. Дискретная математика для программистов, 2-е издание, исправленное / Род + Стивенс. — Москва : ТЕХНОСФЕРА, 2019. — 400 c. +
    5. +
  5. + Стивенс, Р. Алгоритмы. Теория и практическое применение / Род + Стивенс. — Москва : Издательство "Э", 2016. — 544 c. — (Мировой + компьютерный бестселлер). +
    6. +
  6. + Хеш-таблица [Электронный ресурс]: Википедия. Свободная энциклопедия. + — URL: https://ru.wikipedia.org/wiki/Хеш-таблица (дата обращения: 03.11.2021). +
    7. +
  7. + Хеш-функция [Электронный ресурс]: Википедия. Свободная энциклопедия. + — URL: https://ru.wikipedia.org/wiki/Хеш-функция (дата обращения: 03.11.2021). +
    8. +
  8. + Хеш-функция, что это такое? [Электронный ресурс]: Хабр. Сообщество + IT-специалистов. — URL: https://habr.com/ru/post/534596/ + (дата обращения: 03.11.2021). +
    9. +
  9. + Хеш-таблицы [Электронный ресурс]: Хабр. Сообщество IT-специалистов. — + URL: https://habr.com/ru/post/509220/ + (дата обращения: 03.11.2021). +
    10. +
  10. + Хеш-таблицы [Электронный ресурс]: CodeChick. Задачи по + программированию с проверкой. — URL: https://codechick.io/tutorials/dsa/dsa-hash-table (дата обращения: 03.11.2021). +
    11. +
  11. + Fowler–Noll–Vo hash function [Электронный ресурс]: Википедия. + Свободная энциклопедия. — URL: https://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function (дата обращения: 03.11.2021). +
    12. +
  12. + Ассоциативный массив [Электронный ресурс]: Википедия. + Свободная энциклопедия. — URL: https://ru.wikipedia.org/wiki/Ассоциативный_массив (дата обращения: 06.11.2021). +
    13. +
+ + diff --git a/TheoryHTML/Pages/openAddressing.html b/TheoryHTML/Pages/openAddressing.html new file mode 100644 index 0000000..3b608a8 --- /dev/null +++ b/TheoryHTML/Pages/openAddressing.html @@ -0,0 +1,274 @@ + + + + + + + Страница 7 + + +

+ Страница 7 +

+
+

Решение проблем коллизий

+

+ Открытая и прямая адресации [5, c. 170-179] +

+

Оглавление:

+ +
+

Описание

+

+ Безусловно, прямое связывание имеет свои преимущества. Основное из них + заключается в том, что общее количество значений не зависит от + количества блоков. Однако есть у таких хеш-таблиц и некоторые + недостатки. Например, если элементов в блоках накопится слишком много, + поиск нужного займет продолжительное время. Чтобы сократить временные + затраты, число блоков можно увеличить, но тогда вы рискуете получить ряд + пустых, которые потребуют места в памяти и не будут использоваться + таблицей. +

+

+ Еще один способ реализации хеш-таблиц — открытая адресация. + В этом случае значения хранятся в массиве, а функция хеширования + представляет собой некоторые расчеты. +

+

+ Хеш-таблица с прямой адресацией отличается от хеш-таблицы с + открытой адресацией тем, что в первом случае гарантировано должна + использоваться идеальная хеш-функция. Это обусловлено тем, что в данной + хеш-таблице должны отсутствовать коллизии, соответственно, как и методы + их разрешения. Стоит отметить, что под данное описание подходит + идеальное хеширование хеш-таблицы1. +

+

+ В разных видах открытой адресации используются различные функции + хеширования. Неодинакова и политика разрешения коллизий, но в общем + случае она выглядит так: для каждого значения в массиве подбирается + несколько ячеек, и если первая уже занята, алгоритм пробует использовать + вторую, затем третью и так до тех пор, пока не найдет свободную или не + придет к выводу, что таковой нет. +

+

+ Серия ячеек, которую алгоритм подбирает для значения, называется пробной + последовательностью. По ее средней длине хорошо оценивать наполненность + хештаблицы. В идеале пробная последовательность должна равняться 1 или + 2, большие цифры говорят о полной таблице. +

+

+ Иногда политика разрешения коллизий такова, что для элемента может не + найтись свободной ячейки, даже когда она есть. Если пробная + последовательность повторяет саму себя перед тем, как проверить + очередную запись, некоторые записи могут остаться неиспользованными. +

+

+ Чтобы найти элемент в хеш-таблице, алгоритм следует за пробной + последовательностью, пока не произойдет одно из трех событий. +

+
    +
  1. + Если пробная последовательность сумела отыскать элемент, задача + выполнена. +
    2. +
  2. + Если пробная последовательность находит пустую запись в массиве, + элемента нет. +
    3. +
  3. + Пробная последовательность проверяет M записей (по размеру + массива) — и алгоритм приходит к выводу, что значение + отсутствует. Последовательность может перебрать не все элементы, но + если пройдет по всем, вы будете знать, что они точно пересмотрены или + что целевой элемент не найден. Она также может проверить в цикле одну + и ту же позицию несколько раз. В любом случае значение не должно + присутствовать, поскольку иначе оно бы добавлялось к массиву с + использованием той же пробной последовательности. +
    4. +
+

+ При разумном заполнении хеш-таблицы открытая адресация работает очень + быстро. Если длина пробной последовательности равна 1 или 2, добавление + и нахождение элементов выполняются за время O(1). Но если массив + из N элементов существенно переполнен, производительность снижается. В + наихудшем случае алгоритм придет к выводу, что элемента в массиве нет, + за время O(N). Поиск присутствующих элементов также будет + выполняться крайне медленно. +

+

+ Вы можете увеличить размер массива, чтобы уменьшить коэффициент + наполненности хеш-таблицы. Для этого создайте новый массив и рехешируйте + элементы в нем. Для каждого из них операция займет O(1) времени, + а общая производительность алгоритма составит O(N). +

+
+
+

+ Линейное пробирование +

+

+ В линейном пробировании политика разрешения коллизий добавляет к каждой + ячейке постоянное число (чаще всего 1), называемое шагом по индексу, + которое генерирует пробную последовательность. При каждом очередном + добавлении берется размер массива по модулю, стало быть, при + необходимости последовательность возвращается к началу массива. +

+

+ Предположим, в хеш-таблице 100 элементов, а правило хеширования звучит + следующим образом: N связано с ячейкой N mod 100. Тогда пробная + последовательность для значения 2197 проверяет ячейки 97, 98, 99, 0, 1, + 2 и т. д. +

+

+ На рисунке 7.1 представлен массив из 10 записей, который уже содержит + несколько значений. Чтобы добавить в него новое значение 71, используя + линейную пробную последовательность, нужно связать его с ячейкой 71 mod + 10 = 1. Но эта ячейка уже занята значением 61, поэтому алгоритм + переходит к ячейке 2, которая тоже заполнена. Следующей должна быть + ячейка 3 — она свободна, и алгоритм размещает там 71. +

+
+ +

+ Рисунок 7.1 - линейная пробная последовательность +

+
+

+ Преимущество данного метода — в его простоте. Если необходимо, + пробная последовательность пройдет по каждой ячейке массива и вставит + элемент в свободное место, если оно еще осталось. Но есть и + сопутствующий недостаток — так называемая + первичная кластеризация, которая проявляется в образовании + больших блоков смежных записей и приводит к длинным пробным + последовательностям. В результате при добавлении нового элемента и его + хешировании к какой-либо записи в кластере пробная последовательность + вынуждена пройти через весь кластер, чтобы найти свободную ячейку. +

+

+ Чтобы понять, как формируются кластеры, рассмотрим пример пустой + хеш-таблицы. Предположим, в ней содержится N записей и существует + вероятность 1/N, что она закончится в любой данной позиции при + добавлении случайного числа. А теперь представим, что K — + конечная позиция таблицы. Существует вероятность 1/N, что новое + случайное число попадет в позицию K и линейное пробирование попытается + расположить элемент в позиции K + 1. Но та же вероятность + характерна и для случая, при котором новый элемент будет связан с + позицией K + 1 напрямую. Значит, существует вероятность + 2/N, что элемент займет конечную позицию K + 1 и + сформируется малый кластер. +

+

+ Через какое-то время таких кластеров станет много. Чем больше они будут, + тем больше вероятность того, что новый элемент добавится в конец одного + из них. В итоге более мелкие кластеры сольются в более крупные, массив + заполнится ими — и возникнут длинные пробные последовательности. +

+
+
+

+ Квадратичное пробирование +

+

+ Возникновение больших кластеров при линейном пробировании связано с тем, + что новые элементы связываются с ячейками, стоящими в конце группы, и + постепенно увеличивают ее. Предотвратить подобную ситуацию помогает + квадратичное пробирование. Для создания пробной + последовательности в качестве шага по индексу берется квадрат количества + ячеек. Другими словами, если в линейном пробировании существует + последовательность K, K + 1, K + 2, K + 3, ... то в квадратичном + варианте она будет выглядеть так: + K, K + 12, K + 22, K + 32, ... В этом случае, если два + элемента окажутся связанными с разными позициями в одном и том же + кластере, они не обязательно будут придерживаться одной пробной + последовательности и попадут в конец кластера. +

+

+ На рисунке 7.2 показана хеш-таблица, в начале которой есть группа из + пяти элементов. Новое значение 71 получает пробную последовательность + 1, 1 + 12 = 2, 1 + 22 = 5, 1 + 32 = 10 и не добавляется к + существующему кластеру. Значение 93 поначалу связано с тем же + кластером, но согласно собственной пробной последовательности + 3, 3 + 12 = 4, 3 + 22 = 7 также не попадает в него. +

+
+ +

Рисунок 7.2 - Квадратичное пробирование

+
+

+ Квадратичное пробирование предотвращает первичную, но не + вторичную кластеризацию, при которой значения, связанные с + одинаковой начальной позицией в массиве, получают одну и ту же пробную + последовательность, иногда очень длинную. В результате образуется точно + такая же группа элементов, но уже не собранных вместе, а распределенных + по всему массиву. +

+

+ Еще один недостаток квадратичного пробирования связан с тем, что оно + может не найти свободную позицию, даже если в хеш-таблице их несколько. + Дело в том, что с каждым разом перемещение по массиву происходит все + дальше и дальше, и незаполненная ячейка попросту пропускается. +

+
+
+

+ Псевдослучайное пробирование +

+

+ Это пробирование подобно линейному, за исключением того, что шаг по + индексу формирует псевдослучайная функция изначально связанной ячейки. + Предположим, что это ячейка K, тогда пробная последовательность + будет выглядеть следующим образом: K, K + p, K + 2p, ... где p + определяется псевдослучайной функцией. +

+

+ Подобно квадратичному пробированию, псевдослучайное предотвращает только + первичную кластеризацию, но страдает от вторичной: значения, связанные с + одной и той же начальной позицией, размещаются в хеш-таблице согласно + одной и той же пробной последовательности. Точно так же псевдослучайное + пробирование может пропускать некоторые неиспользуемые записи. +

+
+
+

+ Двойное хеширование +

+

+ Чтобы избавиться от вторичной кластеризации значения, связанные с одной + и той же начальной ячейкой, должны получать разные пробные + последовательности. И здесь пригодится двойное хеширование. Оно похоже + на псевдослучайное пробирование, только шаг для индекса задается не + псевдослучайной функцией начальной ячейки, а второй функцией + хеширования. +

+

+ Допустим, значения A и B связаны с позицией K. В + псевдослучайном пробировании шаг по индексу p генерируется + функцией F1 (K), затем оба значения используют пробную + последовательность K, K + p, K + 2p, K + 3p, ... В двойном + хешировании для связывания начальных значений А и + В применяется функция псевдослучайного хеширования + F2. В итоге при одном и том же начальном K образуются две пробные + последовательности с различными шагами по индексу: + pA = F2 (A) и + pB = F2 (B) соответственно. +

+

+ Несмотря на то, что двойное хеширование хорошо справляется с первичной и + вторичной кластеризациями, оно точно так же, как и псевдослучайное + пробирование, может пропускать неиспользуемые записи. +

+
+
+

+ 1Данный метод хеширования хорошо описан в книге Томаса Кормена + [2] +

+ + diff --git a/TheoryHTML/info.xml b/TheoryHTML/info.xml new file mode 100644 index 0000000..4115598 --- /dev/null +++ b/TheoryHTML/info.xml @@ -0,0 +1,16 @@ + + + ./TheoryHTML/Pages + ./TheoryHTML/Images + + main.html + introduction.html + binaryRelationship.html + dirichletPrinciple.html + hashFunction.html + hashTable.html + chainMethod.html + openAddressing.html + analysis.html + + \ No newline at end of file

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 %d^RfP*}>!I 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 H#zFrdmRc@2 literal 0 HcmV?d00001 diff --git a/SourceCode/ManualHTML/Images/theoryPage.png b/SourceCode/ManualHTML/Images/theoryPage.png new file mode 100644 index 0000000000000000000000000000000000000000..f409a2ae50345340ac377cf0997d49baa5620c64 GIT binary patch literal 44902 zcmce-cUV)~7C0D1K}118K}6u90tP7p0@7`?&_nM^m5%ftya(b8wf2d>f}F(lt9P%0K%nbVlCPm4&?PGn zh=A$JMPTGHfkHm;?}8mv;w31%``!xh;gZP<*%u&CUNFhY+snXbVjD>fI}nJp;q3Q9 zi*=eI2$X#+_4EN5NXad>|nmPEgsVnSePZ#_?Th5SzVtyXC4*B@X5-VmaO z_vDfn2$(6Q+U}Dj-4+ZY@bwQ20xN#CV3FLvc+v3<1BYQ~2U(ual{!>LcJZ*RRAr$D zJXCR?6TO!)6>HbU!!bqX`OM@LDISPC>M9#Tz8{=Cc0Zy4Xajl0X@hsC&hBd04|hek zB&=pWXDB{GoQ;fUBa;u)9%qaHfS>VdQ-KUwOv*03>jOO#M(sKh5*=JVYjz6)K3iRq z!D1?c{yzd=hdHwl^8ChNQ~^IK@m!qJtvv0o!Qzj4gFSEgT>y}Hk(;M{xPwZAMDMOX zww}!QY#MkphCt=O@FnF#`>^eGzNym!41N%{M^kf1shJ#oG(!fva}LUt9x<5&50M^{ zJK7~y(+CRXM;2&*Ku9ASnSzC~=PCG*9#-6~;FCux2k6ze#`GWKgLw&}E<4 zc2Q1~1~jdsT>}q!tgP^2plB7~rC2(hqvmAG4c~*`r^oZ*(Fq3yu!S1@5^MpsNm6q% zhuS zQ^(!-9V$EqUx1&^!E>A@;pcl!!fGG@K#xBlV4M8Z<8+khX=)8K0);<{z|-SrYjCh5 z%*lAoHb>=2ljsrb;7|dA`=DKeciWl`K0OwdKLdVK0k^&B&#wRQ(bX&lrJxOzpwY)G zp`;;xm*L$hk0&E9@jmLy1A)|L?3*^?mmVEBkX`1zr}&K2588EDMQk2 z6d@OC8%QoINDl}?vJJ*_kr%lgWI1XJ5bz)6wi>t6$9W-35T&3LLeRMHZ(G)2L!2(x z;J0BX5vL~!CwuaEGJIdnAq8v~w&LlXfY0)PLqVI$1^UOe?YIf*P)@n}Zaay8#kMS9>1<_M(JQ}|aV@IH@ z8DX2pHF&|A?FRbO>5^ZjF>>({H0(=`nyp5Xz&)jcVVMm%KPIMzCoVj}R!?%67RYyR zfyR-)2_9ibc<%3?PLJV-@UM|zj}<7|3BMv5b`@QM?-fmiU-a@TQG{3yNt9U%qI$*p zoL}oOrn^-XPu^;Byabv)`j^YqiJszePDg^PkI*%zTM{+L1ER;?In_rdTSxf)sgp_i zlT!>1_?Z+vWX2!(0VGcy#?haK!cGLwgtBSDPqEu^dtU%|V`b>n{w|ziSjP2xNqPlZu*IS z0U~2?nwI6VEhFk#(9?yWzUT*l&?D^LnI@C1GY69#6mj`!{?Lv2I>uV;G)M?4Wl)jY zR{ZVa8<^AVW1JgFa?n3vq;_tU{Z|MB-98Ua!-2nI7RWK_S19wEIFE2|`2G*mzJSjW zokg|jCN8O{Flf!OTTM^XKiBR&72+1vKiAMk0Q7UfKbQHw82F#nO-)6|iSXHfU85d~ zkoW(()~nf7Avm1ikU{%}0PL8e)$-<$~ z*NPJVP$AsrPzFWspDy-zJit9fo_vH1uw@Tk)eb{=S{NCif{Vj*OuRw=tC#7Fbdpx6(wh^GSy@mGEN z_3&-#uW{*mvQ1&1H7XYo$~@L3@Q}-~$NPqrN(&Ty#wr~DBE?TTf(WKVOtX?j~lE`IBDCY*@VkOpbZ*gFpk(XMTcAd_a?&>Q>ZKI(Objh&GVsNqu`f30f@;|h*vuE#Du}ZLQ)sAn8c#&1`i=MWuh9R5d0BR^bsr-G0ns#_}Ib+0uGF+7RJhu^0cC zg2PAv6z!j_px}>;`#}`w;M*6X&yO^%r0t((~yc=+#%}(^n9;j1RE4 zfa#xNU?0n0gU=U25U2#)Hivews}H@rN}%?Cu3(QQXzEfuLfPGis3|xV0NWILgs_qN z1?Nl-hn7A;o+Thc1Q4(`-M|@MIy%IyNgrjUTgt!(=QnVuv&8voW#Crt{8kdUbvnNl z0&ozXmPW=xcgE1k6CjTz!_aZM08BKso#rvfKqKQ<{gr z&O!pnz)ACiyG+BJz_qLl)OL*UD@J16w)eq zQ|~M@+n?)}PS<|XBp`Vj#*%ag%$5fZmvx1=K0y7vEeHXBv-Z$fICL92ofF-N@jOw} z*JCY*BwKG%d+xP3D22&P;ArsTR~|Qo9xa}+r&xkRU#5J@0Z@AhzTX!OF+QXpug~ol@B0yRcriBLkSd@KN@+6h&;(S7ad+g3U)yC9@$j9;< zE(@n&gnp63H}9SVeC4iet<#LxlVF!y(hG{!fDpTs%svL5F-<3=4K`{|W=c_l_}n+M zW?X=z!=BxQz?~nQ=HKFkjSMk=wkCc%Kq5RI2>te>sVY2HMC#owesLm_2!`~F^(3^I zzbpE?6d-^srbmQS!3*t)$cHR!KSH>YE)L}_1xvXc0}094;KMS6>yHNuyP3s`msPBC z{8D3h|Ef%z6a5Y+|7C5Z56Dy@P34b}TJBN^39+~o+5BnP6D*A=ZZ`+NW8D~2vty7T zf*aQB;|RH@TJz{z-?Z+^$C+L0lbzruUli3VY443|9HKr$4)gW)GrP57fU>Qj?q`L@ zc(L1K#AL&2c1<})$YngvUoYbG!{Z})ysHK8dLL`akAma-&A4HX)xE8w2*fF|t^B*A zqngv4h-uXFC~U38){VAIc;Xu3%!T5wBTySPHut|?#tT1;U_o5^k zWoht>U$#AVZrkVkYmYA!{W^cT#(O>=0Y7(`z$Cz7SnpsU$n=9V`z|e4Py3<>5vEF) zpUsGIl8^={ul4=`|C^yn>ITMol9uf@uqyZ?)QsuY?fa9W<+)0@p0Rx)3@I>dbrpg7 za<4xDolM7@fp?*bM+=`hW#D&sbemWc_r1Ywx-lxg4eCi+VDb1}NV-aooo-D_98~s9 zZS9W`j?TW@M{yh9eq{q{;^3m52Ko_}sBbjPi7KpG7KWdeTPM369waWy}m z1<+9lqtkJd`(nR1Uj-ISyow(MBfMy^cn|IOeu2ZdPqU;ndB-=KXfM{j0yw8dpspvv z>l?l{ER)go&VTI+r*Agw0BuS>LUeCA6YUcX-yFC_N8r%Z@CF!714eh>5II4>)8Yzh zLf49~fr39n(b{k*-zT%HWM1X7Z*z@6&Oj8S+LZjiExY&#VRapGiw^V;Hukx<-5VB{ zN^c&Mj=+w0sZM3~)-f%E!VeobDo@v)w}Y}3)jp>FpljH#!I_-OI60|}><$!b7w4Pn zVK#3tX%Tu!yaYQ?2ix1gzEmkdW+vAK4OjbfQP(kgbg^p?hb9j9mjItjnLVq5@r215>SMfgX>3MOwj$cU#v+E<mmhhszf7t?4YS5^Lld(e)X_8$qLoPqRm>HU%7? zP2nBg^EO-^#D>*%?Iy*(JFPn^7u&am)K|=g&lPu4dOAjBnsJPqpmFvoE*V$5Y5n ziPy{20;|58Tk%)7;=gEJpVgv_?qJ^@?ufFW2GJ2CP>hNn$AOJzJjcUtZSQHO){%*k zX;^_nX0pBv4^j_unVC{~DEo2!)mH%(vNWx1hY8gq8(6OFaw9y~sc&!u9@C9%?ojbrw}J|?^j!Fa*D#BT22f+b0UmxBSp>H&hayr582I%gX) zwo5J05+SMb!eu4r(>Ak1PPARq!0J_wqIpD1)kjC#sUYDoA`5;hNFSZk_${@8j?l@j zZ+`@ON31pLM|6E$`7pzAvo_FD;5?JZZ3JpTxOpTFdi6jZb(_qaji5FO*#Cqe=`k5mg3b=kLDx28mWY6MEcHMcH+sEZ^QN_B8b{GY}#Hg@DJyq}aq5FN5|OC~tp8DZZ#Id4v#&bk_^ap=;H#Ml(!( zdrZ>Oyz$|EI-FbtNFVpbJ!%JtvG$r2mS5YR{x(!JuW17;O%V@E!Id(-k z%}0;Fx3$sNW<#9Jgeoy_C@mSVAD9C5bhWy&bDrncZDscXWhFS2UZ%RHSuJ?MbALAt z)5_EK!q(nQn;oIeCUz#qY%t|*T@^uxG~y*b%QkapMVTlGs>5zqow zKu4IrfMr_G09k8;8Rwr+>j{S+PYfkhKPY)4afZf5CofH19K4JDH5V&5F-lPLfPP~Q z3c)j)cDKuCqdAlK$DVP>DCW5DN*I%n&~;WY8li>y8+~L7T8KCUu>CTNk(D1v+%U_m zDcnuX+1F{!1voaB+2MxSqD}MfH)wwbSSO`wQPap)Y+~0cc!K0>^Kt=H!s$V728rS;3e7LENA z^mHYdzaNg6I@G%e>iBZS#a^jk+001`C$|)9qA!4(!{uyDASI%V_(&$T^Gb?# z?T)Jg9!9Mu-&s^oU>8U7H3jit1}}@GDaJosXun<+?57hljF--rQWXA{b$VYM>9RIl zck%OPtHmBdp37_X(;ot#&Sgm02UobQIn5hnC8)DHpnhT*Cz^?6oK_7wnse_H4OV$C zU^H?AvMBrRWeMO?(lzXhva>u*9vho0w#8Rb8Nt!T(q_$;n0B#J@ru0w(ejRmQRdK3 zR^f{t298lhEK2Rn!WZtV(jwm}LIWGJB|Db{B(y zsUi6O91w)}Zu5IW2UEHKe+e8K>*GV@g#ltHs{@8T6Mk#XfD3lk4B(?Ru| zT#qYadXYcE@s-*N7;Q0SJW_TT5=8L-IP0oza!?fx`RT`&gRX(= z>BiA`_+`FmYTs|Y&QjG&Hfi+kOL=_O-OUE(R1Tw)OG&6)=ak)L3d{(=^<{2UHsbB9i z_Q}|xpykT6$N3g;E;aA+oa-VdW7rST+%4_t20EQZ4qMR)6~*EKQms-XR%;@ffyMJ< zMm7bR-JM#YR_y4)sv%Q}o@9eU^P#-m#(YKcsp^9>i|a;g#@y{%aH}ttkG0w)lq2Lb zj}qE@v3Eh(R5+izO|@09>cw$Fq>Z;lV?01a+C#C#Ef!`pzl6qE=j9|4)dxxHxb7qyr;ONhL-d!xbcaA$k- zJDqZZbWne2&)_>wVt&)QKw}>*iHyncacEyDZ3ptD^z>q)+?X4;nR!mrbf5*79F^@i z38%Ux(Zqg-t*Ygz{?cc08V;n?LIc@Mj$4ayr`OQm;-rdSvhNVa;Tu23bcnCHd;v|4 zjL|_o6d)6q4%-2jFBBYI46S@HG;~kBSdO;k=u6&B%z$@skV-LZRe=e8qbMbma{OJs z1#MRJg^hPvi@HK!Ima8rl#bwGcI#gHyTKQ%P|xLE+4kE@tR;^{8%Rg$oU- zqrHuCB5CU(YVkI=#K+^M-BOW_2SDqv+(lCZ) zh$iR&+?!k9zFh%N5R)Vvg?fODRdEtF5Y!8s6pt;O))a1dBGGrv29;!~T7(^TD?W1~ zLG!6mE7TX(3bP2VQLGr<#O?SR=^ybOhM33wDh&?!r*;VcxGKAKxBM;ajon&D^{ODI zM2)m0-aSuwR;Lu6GG8+f*}onAK-mkHWa%P6QRL%}{gOjBT4k{fa$ftjro+V!*R%~Jv-Lsw!kom)%&nYv7{xa-oc1slfS zH!O$xrnUj9#6mjDZiU7&%`DpQx;o6RC}lm(o7iVF4Ic<};$MgFmO3gF1$BX1E>#Ut zaO?aSkyT;KJr9MI{}$G(iU>=Qwz2mPEqg-Tf~jJ01d+n#2VN|}QSEdxYb?=+d_9%} z?4#FX3*RKUC;+Ck*EYJ-6=GaK#>#f4zz!!FPtok?JZj^uVyOyw?ET=4`%;VAS1T@r z6^@Q9+RHu8Lvi5S8v&okqcX^L~ zvS!XCe2T+4$g`c<6`Qk8GcjVy}iXG?stAz^gl{60+e*Iq-G@5Rq#z#{7;bf z<(h|Q=|IS!f70*Y3N^R3IP*a3=C zY?sJ@+l2r-8XKhpM&fB#{cnZhNHRz|&HX8c*$ifzxfl=R{zb|q-szN0Y4Y0L#`~s$ z%Je`1^t$?0qniA5GvBc?<}z!yWv%Q?#6z!Df3d#1zdY}gyWgjr_y#u2{>UWBqu4R8 zn0gK=&=5sHGS9E@MR~|{Q&0GV*5sN})y>>zB^UU7^g=+{z)`pPuOQ2|C42vj!%Bd| z2X9a=N?Hw`_;nZ*FZ)MqcJb&NXGf{PA>YkEl->i1uIIlBEQ>#& zG20e?2V>(LXBA>?!GCxrMWEQepPe!}^Zp@`%@t`U^sA7xdhzEW0YI^H?|(ph3*zRi zZEAise0!Mw2tiTa0iJq>u+}f&k6>>hP%XgG-@hLcmZ-5F8w!a8?_DetH9YOP_)kc zk)Pmmu*2D5D+u%tuVld<`Tz6Ojb;M+jsF3y0E`mN7^lbTQ>k4zV>lMDzI3l-th)!DJ<-WY^v}~uo4K>ACO{4Loc1*epNB`X7 z%0X*{Yfm!Em2=I=p| z77xeLSrxz`8HqLkE_yIZGT@g3S)+35zTtKc;JC3x~cHKSQ+W9& zIrH;lCW)U1?OUnSG+CEa2OSrhf>X91SM|0yM+byKnJi9dnvfO~_W3E1Zv;wo%AK6! zmZsvXLJJ4=wEiM?qZWT9(34Ir5|hpCnd_6=PcbNDi>+F7x9?tx7-~~0Yh*Q#InuRG z+3Czk4#75RMBhP_q<$;S>|`|&lC44u$imu+^V%kbt}cC)uXk^i5u$JE{kZS38X zld?m^$Brz*pHL|xRtSR!7h6;x>%{7m#^<{VN|;jhuM~{j=x0W56s>56wgLoi(YZyj zHSEQ07RukruLQ^RiP+t2URYK#p?+VG@fWvlRwD;Ahc#P(w8#lEs*P?t%+OhUj@h1h zQ!+C!l2H}ENtbnvn#-WwaqZSF?-0FYFij?AM4?=Ju9;5ptjNmE(r2{@Rg@A-&mA;Ko%gpuA@j- zD^VMxW*vN*AZj?DIWjO=5$G}GQXo{Zg)EpHn!Qy^;X3x}m(e`XTba!m<@97M)VtDx z9U9C|K9#c=VlTlC2re_r2P-H~$t5#Zmz%5;OeqNaaOpbCH=k5#3X5;!Dz0ICtcV1S zN%F6jJ{d_Um=mNA!V(c#-j1GI7NELk}7XvzN z(J7r4uCWQd;|ZM7J*yqg492<|l9e1i&o9q63n3sz;flUw(LNj09Hu|HJ0Hs3;o_1s zik4*=;2u64?8NLF9~v@yW{0PO;(z|ODf+{gRC-1dxPh{xE%(Pf&rPVed<1iNU^h!L zB76_feXda*B~(4`qTh}W(D5U*d)048d!W0H@EO;4rh&b#l%e1I->MegUQ>Bo=-n7U zB5cZ0!sNE=C8Kv&pZ6!teYS}xTwzDQibuGH_sBNboUUwGH=JH)?S_$3M8d+n><9|k zAN(b!s=#;zHBqdRGB_e_es4hM2lw*NF2|7u9tS~tIz{0R6uw`sg&Rd5%eQXmkLMX3 zy!jmBc4SN}#l$dCBsn*4S0r+I^W*P)sk@b`>;UO-O^Bs5t9KW4=?Yh9y@O^~Z!C}!x-eigSt$Azf8^06{#NCepZQV=FV2UtJ6V)!4 zNVjX`iBuHF$x^z3dqoCUr-^^p6~f;*Y_KXlobCf_9vTT`m4EwO{+Kfx$1zQ%ckx|Unv-Np-|EOg!{Ou7TJ6C`;zmbyM@v@Tm`nbko=eru;XbmGZcTH?J zr$3=^m*;22Y{$G~5n}UK;)KCwaI<}a5nlBV`cS8Zw;`Q5#V+*8b(h)JGt7I!y(G4a z{mwFw{nypCO=`l}jJav)Y4(m_#S0wXi7nQC!YLazX9Fcx5mlh}70jJi9hbL0<=MwmnqTmjPo_K^}YF)!;4j(uyC&$!%`;rHPz9d?Uo+v@5jnHM7gu3$i$~1(h zDtV+#hH|*^sS?g)QaK z_G=?(5nR$5ZWo!aQF9u!=liDbiF~#6zWqpWkMT!;DktQB#P5n#nY&Z{G^pm0T(fT7 zJI9i>EX*q^y+fh5?jhb1F4!jRC=t-ke&ingh*OK>AZ8r9aDxK*j5gUX!f^meg(7p* z4mRhEQGDgp#V#e|NUI|HSHGICKC+3#5fl1hFMMXp=k z&3w+yAS>fi;BKg~9^W%?^v?$3c3*FMHbeY`Mc_11gxc-$#7OYbnAau@{;XP+y?QI~ zV?L|@9e4BU1O03ndXFQwFJtm(dARKN@(ibfZA*`zkJ@9+>rC%gsPf>p*4P`~u_d}b z_pT0Ph;taZY{)FHR?HN>#~tJJx;d?Ne^lD|Xwr^yAm3U^Ea>iQZR7Bp+@sYvpTjT8 zcB|CVvF#|!TTJO1PAlof+{5TK;@BsKjbAj}PAlkIi|ekkZfj@wpch8Qo|>8JWhjB< z|LoxY?sWkFpXXqU43(RWC(-yS|rG=dyIpMNRR-)i7;XymGfs&r? z2iB7ji!baa`Ey7+-%&SpHY);2-!okdHfEw~(sY@@2Ed@VdHUA0A(M6apKIkXprSn}LS5wRk&uA^dztKYq(&?VO%c_dJQ$g37t7d^aLC9e4Zg=;=gv$5#9MVz^H=NUL8!fCSaLkJ+$x-HG9K zoX)VtQoq7uaHcUYb z<4*k9rhew!x4lbF?ib7lW?CU<{;u$#ibM2H>=_ouS>97$T9-guu-6B*C-f#)3{!{@ zo4|Yn4*eh+ZhzT%-@Zm6JH;Btx-SXfb$hvP*bnw%-u(|FqfKhMOBqJn>(ZmM8NtO) zjF=MJxWjkVRo81GB=y{VByPY~WV%VmZa!zCk61LvH1tn-9r#?F=KOfq^xLm+Em3XS zq-MU?T$8ceRJoszIpUnP*tk*ZvLg(M>LR{L5}zLeR8gB=F9QoD&(fiahf^i98EmWH z)aGi|yH$&*ZNRGq+9txKiFJCmP_1hX1yW+K(-MNve5%3}5HKj1`A?3nHdCQixiWI? zKs{+e$E7RD$S~$YseBHHIdjdxGoes}Q=PhOFB_*G4asFFni|GJG=1|=b+OOpP7=Te zDZvu@?3(Azm5VFEP_Cfyr%JDc*5wV?l%`vtAi9^o>$2S|vrb%$j&Fhw*5JbzK&s#e z2Or?gJt?5^vfmZa+4~uwM~Ia3mm}?)ewX=YqtC%SzYfMg-yi?3OMyBA1ia}426zE3 zo!_HTw*_ci|=9#4)0%k zqmuTGQVM93Tz<2bcG_=p=$NHNMaqtQ2(k%z%dq=NPmg^|>`ra|d9&r>6UA=Uqp@91 z7>(WmlU1-V3JU5DsZJJZqY5Q)2gvJ=kjywMxh_5ltqF`Vkgh4}P=%f?dcVWd$n8PP ze+&>u``cQ;AnulfDUl58A?(<}BHw%J)5C=(Wu+MW^&<9aS7?ZEp6;l8-`e-KW#6%8 zVEIqwQ(C|o= zG!E-r)ZOVfBv8_2n1Ui*u%zeNza)klH* zA6Lj@YMC&xytdAtWv=s^d)(m!i_(+2Zlz6r)Op+XPR%4d5gOTR#^Y&Uo|7`H{-S@% zq~xyevP>N7d&y79#DbTo&Xy){%W!#yVdrxDk0;XV?9zvvXI7Ku}HaiH_o~ z*X$S0ysCgB8fqDR?~FF_@xORdrLv$0H38%BFiCxFTK5FlK&0i!V2A3lw@UY;0Rb0Lr|| zj*O_)(9V>3bN@IhF5f3VW%$XR`RI<|4&{8N4~k5-#xc>IF>(Bj_D{)F!ZrC0yLbW_ zb$X|`PbCb*QC#!w1#-}Lr zpWLlGM~SI1$zhicbraWuTa^v_)kF~&xC`#~!=5l|%ErAkm_E&Nc)4RxAUIMoJ#(^< zn?M*|J@a*Vept$PFWa$Rh9e{7IG;D?bz0E)aGVa`eu?mC9ZJxXuz3}XjWdFzMmra$ z*Xi$?QToXkbL#AU8xCV~)4UM-y8{oZ3^q9E^7uC1WanMt0#X+}8h#}wnn%ic)0=cc zh@W6Zd4jZ{&~ahpNd|*r$d3v`)67#)mkqo56LB6V`VM`^yuzY;@GbW03tA+U6NiZR z`Q95}2TJ-zD@Lh9rBM%#F>TZQQ48pyUtq;`2~)N28iF$<-M zrf7{J-%gV}YL!%-M_#LLzp7X;2s5jmpt^3FETVxL3>M*izkf&HH|C1)V7y7bS-GN` z3F-coK~LyY-S3NAQiN51-+3&%)ow`LZM55*#v5vc5;0=BV