Міністерство освіти і науки України

Національний університет “Львівська політехніка”

Кафедра інформаційних систем та мереж

ЗВІТ
про виконання лабораторної роботи № 5
“Міри близькості відношень”
з дисципліни “Теорія прийняття рішень”

Виконала студентка групи СА-41

Іванюк М.О.
Прийняла асистент кафедри ІСМ
Нич Л.Я.

Львів 2023
 Мета роботи: Вивчення та практичне ознайомлення з основними мірами
близькості на відношеннях.

Варіант – 7

Завдання на роботу
1. Робота виконується на базі реалізованих в лабораторних роботах №1 – 3
базового віртуального об’єкту “ВІДНОШЕННЯ” і його реалізацій
“ВІДНОШЕННЯ_МАТР” та “ВІДНОШЕННЯ_МАТР_МЕТР”.
2. Реалізувати механізми знаходження міри близькості – між
відношеннями лінійного порядку G та R, і між метризованими відношеннями S
і T.
3. Реалізувати механізм знаходження структурної міри близькості між
відношеннями еквівалентності Q1, Q2.
4. За допомогою отриманої програми знайти міру близькості між
відношеннями лінійного порядку G та R та між метризованими відношеннями
S і T, а також знайти структурну міру близькості між відношеннями
еквівалентності Q1, Q2.
5. Оформити звіт про виконану роботу.

Опис виконаної роботи

1. Розроблена на даній лабораторній програма визначає міри близькості
відношень. Множини Q, S, T, Q1 і Q2, а також верхній зріз R, всі дані взято
відповідно до варіанту №7. Код містить класи з попередніх лабораторних
робіт, а саме Relation, RelationMatrix, RelationCut і RelationMatrixMetrized, які
використовуються для реалізації функцій визначення міри близькості
метризованих відношень та відношень лінійного порядку.

2. Окрім функцій, реалізованих у перших трьох лабораторних роботах,

програма містить додані до головного класу Relation функції, які ранжирують
відношення, шукають міру близькості та структурну міру близькості
відношень:
 distance – приймає один аргумент, а саме посилання на відношення в
матричному вигляді. Шукає відстань між відношенням, яке викликає дану
функцію, та відношенням, яке передається як аргумент.
Текст програми:
float Relation::distance(Relation* mRelation)
{
float result{ 0 };
for (size_t i{ 0 }; i < size; i++)
for (size_t j{ 0 }; j < size; j++)
result += abs(matrix[i][j] - mRelation->matrix[i][j]);
return result;

 ranking – не приймає аргументів. Виконує ранжирування відношення, яке

викликає дану функцію;
Текст програми:
void Relation::ranking()
{
std::vector<std::vector<int>> newMatrix(5, std::vector<int>(5, 0));
for (size_t i{ 0 }; i < size; ++i)
for (size_t j{ 0 }; j < size; ++j)
newMatrix[i][j] = matrix[i][j] - matrix[j][i];

matrix.clear();
matrix = newMatrix;
}

 measureOfIntimacy – приймає один аргумент, а саме посилання на

відношення в матричному вигляді. Шукає міру близькості між бінарним
відношенням, яке викликало дану функцію, та бінарним відношенням, яке
передається як аргумент;
Функція measureOfIntimacy реалізує знаходження міри близькості через
ранжування бінарних відношень.
 Текст програми:
float Relation::measureOfIntimacy(Relation* mRelation)
{
float intimacy = this->distance(mRelation);
return intimacy / 2.0;
}

 measureOfIntimacyMetr – приймає один аргумент, а саме посилання на

відношення в матричному вигляді. Шукає міру близькості між
метризованим відношенням, яке викликало дану функцію, та
метризованим відношенням, яке передається як аргумент;
Функція measureOfIntimacyMetr реалізує формулу для знаходження міри
близькості між узгодженими метризованими відношеннями і формулу для
знаходження міри близькості між неузгодженими метризованими
відношеннями.
Текст програми:
float Relation::measureOfIntimacyMetr(Relation* mRelation)
{
float intimacy{ 0 };
if (this->concerted() && mRelation->concerted())
{
intimacy = this->distance(mRelation);
}
else
{
int distance1 = this->distance(mRelation);
int distance2{ 0 };
for (size_t i{ 0 }; i < size; i++)
for (size_t j{ 0 }; j < size; j++)
distance2 += abs(matrix[j][i] - mRelation->matrix[j][i]);
intimacy = (distance1 + distance2);
}
return intimacy / 2.0;
}

 structuredMeasureOfIntimacy – приймає один аргумент, а саме посилання

на відношення у матричному вигляді. Шукає структурну міру близькості
між відношенням, яке викликало дану функцію, та відношенням, яке
передається як аргумент.
Текст програми:
float Relation::structuredMeasureOfIntimacy(Relation* mRelation)
{
Relation* resultOfMeasure = new Relation(*mRelation);
std::vector<std::vector<int>> classes;
Relation* resultOfMeasure2 = new Relation(*this);
std::vector<std::vector<int>> classes2;
std::vector<int> r1;
std::vector<int> r2;
std::vector<int> cross;
Relation* crossRelation = new Relation(*this);
std::vector<std::vector<int>> classes22;
std::vector<int> coordinates;
std::vector<int> coordinates1;
for (size_t i{ 0 }; i < size; i++)
{
std::vector<int> elements;
bool check{ true };
int count{ 0 };
for (size_t j{ 0 }; j < size; j++)
{
if (matrix[i][j] == 1)
{
if (classes.size() == 0)
{
elements.push_back(j);
++count;
}
else
{
for (size_t k{ 0 }; k < classes.size(); k++)
{
for (size_t m = 0; m < classes[k].size(); m++)
{
if (j == classes[k][m])
{
check = false;
break;
}
}
}
if (check == true)
{
elements.push_back(j);
++count;
}
}
}
else
continue;
}
if (count > 0)
classes.push_back(elements);
}

for (size_t i{ 0 }; i < size; i++)

{
std::vector<int> elements;
bool check{ true };
int count{ 0 };
for (size_t j{ 0 }; j < size; j++)
{
if (mRelation->matrix[i][j] == 1)
{
if (classes2.size() == 0)
{
elements.push_back(j);
++count;
}
else
{
for (size_t k{ 0 }; k < classes2.size(); k++)
{
for (size_t m{ 0 }; m < classes2[k].size(); m++)
{
if (j == classes2[k][m])
{
check = false;
break;
}
}
}
if (check == true)
{
elements.push_back(j);
++count;
}
}
}
else
continue;
}
if (count > 0)
classes2.push_back(elements);
}

for (size_t i{ 0 }; i < classes.size(); i++)

{
resultOfMeasure->narrowing(&classes[i]);
std::vector<std::vector<int>> classes11;
for (size_t i{ 0 }; i < resultOfMeasure->size; i++)
{
std::vector<int> elements;
bool check{ true };
int count{ 0 };
for (size_t j{ 0 }; j < resultOfMeasure->size; j++)
{
if (resultOfMeasure->matrix[i][j] == 1)
 {
if (classes11.size() == 0)
{
elements.push_back(j);
++count;
}
else
{
for (size_t k{ 0 }; k < classes11.size(); k++)
{
for (size_t m{ 0 }; m < classes11[k].size(); m++)
{
if (j == classes11[k][m])
{
check = false;
break;
}
}
}
if (check == true)
{
elements.push_back(j);
++count;
}
}
}
else
continue;
}
if (count > 0)
classes11.push_back(elements);
}
r1.push_back(classes11.size());
}

for (size_t i{ 0 }; i < classes2.size(); i++)

{
resultOfMeasure2->narrowing(&classes2[i]);
std::vector<std::vector<int>> classes11;
for (size_t i{ 0 }; i < resultOfMeasure2->size; i++)
{
std::vector<int> elements;
bool check{ true };
int count{ 0 };
for (size_t j{ 0 }; j < resultOfMeasure2->size; j++)
{
if (resultOfMeasure2->matrix[i][j] == 1)
{
if (classes11.size() == 0)
{
elements.push_back(j);
++count;
 }
else
{
for (size_t k{ 0 }; k < classes11.size(); k++)
{
for (size_t m{ 0 }; m < classes11[k].size(); m++)
{
if (j == classes11[k][m])
{
check = false;
break;
}
}
}
if (check == true)
{
elements.push_back(j);
++count;
}
}
}
else
continue;
}
if (count > 0)
classes11.push_back(elements);
}
r2.push_back(classes11.size());
}

crossRelation->crossing(mRelation);
for (size_t i{ 0 }; i < crossRelation->size; i++)
{
std::vector<int> elements;
bool check{ true };
int count{ 0 };
for (size_t j{ 0 }; j < crossRelation->size; j++)
{
if (crossRelation->matrix[i][j] == 1)
{
if (classes22.size() == 0)
{
elements.push_back(j);
++count;
}
else
{
for (size_t k{ 0 }; k < classes22.size(); k++)
{
for (size_t m{ 0 }; m < classes22[k].size(); m++)
{
if (j == classes22[k][m])
 {
check = false;
break;
}
}
}
if (check == true)
{
elements.push_back(j);
count++;
}
}
}
else
continue;
}
if (count > 0) {
classes22.push_back(elements);
cross.push_back(elements.size());
}
}

int sum{ 0 };
for (size_t i{ 0 }; i < classes.size(); i++)
{
int max{ -10 };
if (coordinates.size() == 0)
{
int jmax{ 0 };
for (size_t j{ 0 }; j < cross.size(); j++)
{
if (cross[j] > max)
{
max = cross[j];
jmax = j;
}
}
coordinates.push_back(jmax);
}
else
{
int jmax{ 0 };
for (size_t j{ 0 }; j < cross.size(); j++)
{
int check{ false };
for (size_t k{ 0 }; k < coordinates.size(); k++)
{
if (j == coordinates[k])
check = true;
}
if (check)
continue;
 else
{
if (cross[j] > max)
{
max = cross[j];
jmax = j;
}
}
}
coordinates.push_back(jmax);
}
int res = 2 * (classes[i].size() - max) - r1[i] + 1;
sum += res;
}

for (size_t i{ 0 }; i < classes2.size(); i++)

{
int max{ -10 };
if (coordinates1.size() == 0)
{
int jmax{ 0 };
for (size_t j{ 0 }; j < cross.size(); j++)
{
if (cross[j] > max)
{
max = cross[j];
jmax = j;
}
}
coordinates1.push_back(jmax);
}
else
{
int jmax{ 0 };
for (size_t j{ 0 }; j < cross.size(); j++)
{
int check{ false };
for (size_t k{ 0 }; k < coordinates1.size(); k++)
{
if (j == coordinates1[k])
check = true;
}
if (check)
continue;
else
{
if (cross[j] > max)
{
max = cross[j];
jmax = j;
}
}
 }
coordinates1.push_back(jmax);
}
int res = 2 * (classes2[i].size() - max) - r2[i] + 1;
sum += res;
}
return sum;
}

3. У головній функції створюються змінні для збереження даних згідно

варіанту, ініціалізуються конструктори, а також викликаються функції
ранжування відношень, пошуку міри близькості та структурної міри близькості
відношень. Результати виводяться в консоль.
Текст основної програми:
#include <iostream>
#include <chrono>
#include "windows.h"
#include "psapi.h"
#include "pdh.h"
#include "relationmatrixmetrized.h"
#include "relationcut.h"

int main()
{
std::vector<std::vector<int>> relationQ = { {1,0,0,0,0},{1,1,1,1,0},{0,0,1,0,0},{0,0,1,1,0},
{0,0,0,0,1} };
std::vector<std::vector<int>> relationR = { {0},{1},{0,1,2},{0,3},{0,4} };
std::vector<std::vector<int>> relationS = { {0,-2,-1,-1,-2},{2,0,1,1,0},{1,-1,0,0,-1},{1,-1,0,0,-1},
{2,0,1,1,0} };
std::vector<std::vector<int>> relationT = { {0,-1,1,-1,1},{1,0,2,0,2},{-1,-2,0,-2,0},{1,0,2,0,2},{-1,-
2,0,-2,0} };
std::vector<std::vector<int>> relationQ1 = { {1,0,0,0,0},{0,1,0,0,1},{0,0,1,0,0},{0,0,0,1,0},
{0,1,0,0,1} };
std::vector<std::vector<int>> relationQ2 = { {1,0,0,0,0},{0,1,1,0,1},{0,1,1,0,1},{0,0,0,1,0},
{0,1,1,0,1} };

std::chrono::time_point<std::chrono::steady_clock> begin = std::chrono::steady_clock::now();

Relation* Q = new RelationMatrix(relationQ);
Relation* R = new RelationCut(relationR.size(), relationR);
Relation* RMatrix = new RelationMatrix(R->matrix);
Relation* S = new RelationMatrixMetrized(relationS);
Relation* T = new RelationMatrixMetrized(relationT);
Relation* Q1 = new RelationMatrix(relationQ1);
Relation* Q2 = new RelationMatrix(relationQ2);

std::cout << "Relation Q: " << std::endl;

Q->showResult();
std::cout << "Relation R:" << std::endl;
R->showResult();
 Q->ranking();
RMatrix->ranking();
std::cout << "Ranked relation Q: " << std::endl;
Q->showResult();
std::cout << "Ranked relation R:" << std::endl;
RMatrix->showResult();
std::cout << "Measure of intimacy of Q and R = " << Q->measureOfIntimacy(RMatrix) << std::endl
<< std::endl;

std::cout << "Relation S:" << std::endl;

S->showResult();
std::cout << "Relation T:" << std::endl;
T->showResult();
std::cout << "Measure of intimacy of S and T = " << S->measureOfIntimacyMetr(T) << std::endl
<< std::endl;

std::cout << "Relation Q1: " << std::endl;

Q1->showResult();
std::cout << "Relation Q2: " << std::endl;
Q2->showResult();
std::cout << "Structured measure of intimacy of Q1 and Q2 = " << Q1-
>structuredMeasureOfIntimacy(Q2) << std::endl;

std::chrono::time_point<std::chrono::steady_clock> end = std::chrono::steady_clock::now();

auto time = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
std::cout << std::endl << "Time wasted on calculations: " << time.count() << " ms." << std::endl;

PROCESS_MEMORY_COUNTERS_EX pmc;
GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc,
sizeof(pmc));
size_t memUsedByMe = pmc.WorkingSetSize;
std::cout << "Memory wasted on calculations: " << memUsedByMe / (1024) << " kb." << std::endl;
}

4. Програма виконується наступним чином:

 спочатку викликається функція main;
 далі ініціалізуються вхідні дані – двовимірні вектори, які містять
значення відношень Q, R, T, S, Q1 і Q2;
 ініціалізуються класи відношень – матричні відношення Q, Q1 і Q2,
відношення-зріз R та метризовані відношення T і S;
 відбуваються ранжування відношень Q та R у матричній формі, після
чого результати виводяться на екран;
 здійснюється розрахунок міри близькості відношень Q та R, після чого
на екран демонструється отриманий результат;
  на екран виводяться відношення T і S, розраховується і демонструється
їх міра близькості;
 на екран виводяться відношення Q1 та Q2, розраховується і
демонструється їх структурна міра близькості;
 здійснюється підрахунок витрачених часу та пам’яті.

Рис.1. Вміст відношень Q і R, результати їх ранжування та розрахованої міри

близькості.
 Рис. 2. Вміст метризованих відношень S і T, а також їх результат міри
близькості.

Рис. 3. Вміст еквівалентних відношень Q1 і Q2, результат їх структурної міри

близькості, а також витрачені на виконання програми час і пам'ять.

5. На обчислення основних операцій між відношеннями витрачено 4000

кілобайти оперативної пам’яті та 22 мілісекунди.
Висновок: У даній лабораторній роботі було проведено ознайомлення з
поняттями міри близькості відношень. Були вивчені аспекти та механізми
розрахунку міри близькості на ранжуваннях, метризованих відношеннях та
визначені способи структурної міри близькості відношень.
Здобуто тереотичні навички:
 Розуміння поняття міри близькості відношень.
 Розглянуто аспекти та механізми розрахунку міри близькості на
ранжуваннях і метризованих відношень. Способи визначення
структурної міри близькості відношень.
Після цього засвоєно практичні навички:
 Використання методів об'єктно-орієнтованого програмування для
реалізації функцій пошуку міри близькості.
 Робота з класами та об'єктами для обробки та аналізу відношень.
 Реалізовані функції було протестовано на відповідних даних, що
відповідають варіанту задачі.