commit e94e758736e0dc7720bbd98339417b50e2bd0625 Author: NKTKLN Date: Tue Sep 24 02:22:33 2024 +0300 first commit diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..16ffffd --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.DS_Store + +.vscode/ +Test/ diff --git a/First term/Algorithms/1-2/1.py b/First term/Algorithms/1-2/1.py new file mode 100755 index 0000000..6cd25a9 --- /dev/null +++ b/First term/Algorithms/1-2/1.py @@ -0,0 +1,42 @@ +def binary_search(arr: list, item: int) -> (int, bool): + is_found = False + low = 0 + high = len(arr) - 1 + + while low <= high: + mid = (low + high) // 2 + + if arr[mid] == item: + is_found = True + break + + if arr[mid] > item: + high = mid - 1 + continue + + low = mid + 1 + + if arr[mid] < item: + mid += 1 + + return mid, is_found + + +def main() -> None: + # Config + arr = [1, 2, 3, 4, 5, 7, 8] + item = 6 + + # Main code + ans = binary_search(arr, item) + + print("Index: ", ans[0]) + print("Before:", arr) + + if not ans[1]: + arr.insert(ans[0], item) + print("After: ", arr) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/1-2/2.py b/First term/Algorithms/1-2/2.py new file mode 100755 index 0000000..fef1dcd --- /dev/null +++ b/First term/Algorithms/1-2/2.py @@ -0,0 +1,62 @@ +def binary_search(arr: list) -> int: + low = 0 + high = len(arr) - 1 + + while low <= high: + mid = (low + high) // 2 + + if len(arr) - 1 == mid or mid == 0: + return mid + + if arr[mid-1] < arr[mid] > arr[mid+1]: + return mid + + if arr[mid] >= arr[mid+1]: + high = mid - 1 + continue + + low = mid + 1 + + return None + + +def checkIfPeakExist(arr: list) -> bool: + for index in range(len(arr)): + is_exist = True + + for first in range(index-1): + if not arr[first] < arr[first+1]: + is_exist = False + + for second in range(index, len(arr)-1): + if not arr[second] > arr[second+1]: + is_exist = False + + if is_exist: + if index == 0 or index == len(arr)-1: + return 0 + + return arr[index] + + return 0 + + +def main() -> None: + # Config + arr = [2, 3, 7, 4, 3, 2, -1, -2, -3, -4, -5, -6, -8] + # arr = [-8, -6, -5, -4, -3, -2, -1, 2, 3, 4, 3, 2] + # arr = [1, 2, 3, 4, 5, 4, 3, 2, 1] + + # Main code + if not checkIfPeakExist(arr): + print("Не является горным списком.") + return + + ans = binary_search(arr) + + print("Ответ:", arr[ans]) + print("Индекс:", ans) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/1-2/3.py b/First term/Algorithms/1-2/3.py new file mode 100755 index 0000000..ffdb2d7 --- /dev/null +++ b/First term/Algorithms/1-2/3.py @@ -0,0 +1,44 @@ +def binary_search(arr: list) -> int: + low = 0 + high = len(arr) - 1 + + while low <= high: + mid = (low + high) // 2 + + if arr[mid] == 0: + break + + if arr[mid] > 0: + high = mid - 1 + continue + + low = mid + 1 + + return mid + + +def main() -> None: + # Config + arr = [-5, -4, -3, -2, 2, 3, 4] + + # Main code + if len(arr) == 0: + print("Пустой список.") + return + + index = binary_search(arr) + + neg = index + pos = len(arr) - neg + + if arr[index] < 0: + neg += 1 + + if arr[index] <= 0: + pos -= 1 + + print(neg, pos) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/1-2/4.py b/First term/Algorithms/1-2/4.py new file mode 100755 index 0000000..94680fe --- /dev/null +++ b/First term/Algorithms/1-2/4.py @@ -0,0 +1,41 @@ +def binary_search(arr: list, item: int) -> int: + low = 0 + high = len(arr) - 1 + + while low <= high: + mid = (low + high) // 2 + + if arr[mid] == item: + break + + if arr[mid] > item: + high = mid - 1 + continue + + low = mid + 1 + + if arr[mid] < item: + mid += 1 + + return mid + + +def main() -> None: + # Config + arr = [5, 2, 6, 1, 9, 4, 3, 2, 4, 5] + + # Main code + sorted_arr = [arr[-1]] + ans = [0] + + for num_index in range(len(arr)-2, -1, -1): + index = binary_search(sorted_arr, arr[num_index]) + + sorted_arr.insert(index, arr[num_index]) + + ans.append(index) + print(ans[::-1]) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/2-2/1.py b/First term/Algorithms/2-2/1.py new file mode 100755 index 0000000..cea911e --- /dev/null +++ b/First term/Algorithms/2-2/1.py @@ -0,0 +1,12 @@ +def main() -> None: + n = int(input()) + + index = 0 + while 2 ** index < n: + index += 1 + + print(int(2 ** index == n)) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/2-2/2.py b/First term/Algorithms/2-2/2.py new file mode 100755 index 0000000..9df8f19 --- /dev/null +++ b/First term/Algorithms/2-2/2.py @@ -0,0 +1,20 @@ +def main() -> int: + a = int(input()) + + if a < 10: + return a + + numbers = [] + for divider in range(9, 1, -1): + while a % divider == 0: + a //= divider + numbers.append(divider) + + if a >= 10: + return 0 + + return int("".join(map(str, sorted(numbers)))) + + +if __name__ == "__main__": + print(main()) diff --git a/First term/Algorithms/2-2/3.py b/First term/Algorithms/2-2/3.py new file mode 100755 index 0000000..6bea74f --- /dev/null +++ b/First term/Algorithms/2-2/3.py @@ -0,0 +1,21 @@ +def main() -> None: + n = int(input()) + + number = 1 + numbers = [] + while len(numbers) < n: + num = number + for divider in 2, 3, 5: + while num % divider == 0: + num //= divider + + if num == 1: + numbers.append(number) + + number += 1 + + print(numbers[n-1]) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/2-2/4.py b/First term/Algorithms/2-2/4.py new file mode 100755 index 0000000..99a5b6a --- /dev/null +++ b/First term/Algorithms/2-2/4.py @@ -0,0 +1,24 @@ +import heapq + + +def main() -> None: + # Config + arr = [1, 2, 3, 5] + k = 3 + + # Main code + heap = [(arr[0]/arr[j], 0, j) for j in range(1, len(arr))] + heapq.heapify(heap) + + for _ in range(k): + val, i, j = heapq.heappop(heap) + if i < len(arr) - 1: + heapq.heappush(heap, (arr[i+1]/arr[j], i+1, j)) + + print([arr[i], arr[j]]) + + +if __name__ == "__main__": + main() + +# O(k * log(n)), где n - длина массива arr diff --git a/First term/Algorithms/4/1.py b/First term/Algorithms/4/1.py new file mode 100755 index 0000000..12d7b25 --- /dev/null +++ b/First term/Algorithms/4/1.py @@ -0,0 +1,21 @@ +def main() -> None: + arr = [86, 90, 27, 29, 38, 30, 40] + my_dict = [None] * 7 + + for num in arr: + key = num % 7 + d = 1 + while my_dict[key] is not None: + key += d + + if key >= len(arr)-1: + d = -1 + key -= 1 + + my_dict[key] = num + + print(my_dict) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/4/2.py b/First term/Algorithms/4/2.py new file mode 100755 index 0000000..9e651a2 --- /dev/null +++ b/First term/Algorithms/4/2.py @@ -0,0 +1,15 @@ +def main(string: str) -> None: + some_dict = {} + for char in string: + if some_dict.get(char) is None: + some_dict[char] = 1 + continue + + some_dict[char] += 1 + + for key in some_dict.keys(): + print(f"'{key}': {some_dict[key]}") + + +if __name__ == "__main__": + main("hello world") diff --git a/First term/Algorithms/4/3.py b/First term/Algorithms/4/3.py new file mode 100755 index 0000000..478ee00 --- /dev/null +++ b/First term/Algorithms/4/3.py @@ -0,0 +1,19 @@ +def main() -> None: + # Config + arr = [-1, 2, 3, 4, 7] + n = 5 + + # Main code + some_dict = {} + for index in range(len(arr)): + key = n - arr[index] + if some_dict.get(key) is not None: + print(some_dict[key], index) + break + + if some_dict.get(arr[index]) is None: + some_dict[arr[index]] = index + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/4/4.py b/First term/Algorithms/4/4.py new file mode 100755 index 0000000..4dd23ca --- /dev/null +++ b/First term/Algorithms/4/4.py @@ -0,0 +1,30 @@ +def main() -> None: + # Config + first_arr = [1, 2, 3, 4, 5] + second_arr = [0, 2, 4, 6, 8] + + # Main code + some_dict = {} + ans = set() + for index in range(max(len(first_arr), len(second_arr))): + if index < len(first_arr): + first_number = first_arr[index] + + if some_dict.get(first_number) is None: + some_dict[first_number] = 1 + elif some_dict[first_number] == 2: + ans.add(first_number) + + if index < len(second_arr): + second_number = second_arr[index] + + if some_dict.get(second_number) is None: + some_dict[second_number] = 2 + elif some_dict[second_number] == 1: + ans.add(second_number) + + print(list(ans)) + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/4/5.py b/First term/Algorithms/4/5.py new file mode 100755 index 0000000..97cdbb1 --- /dev/null +++ b/First term/Algorithms/4/5.py @@ -0,0 +1,16 @@ +def main() -> None: + # Config + arr = ["а", "b", "с", "d", "с", "е", "f"] + + # Main code + some_dict = {} + for index in range(len(arr)): + if some_dict.get(arr[index]) is not None: + print(arr[index]) + break + + some_dict[arr[index]] = index + + +if __name__ == "__main__": + main() diff --git a/First term/Algorithms/4/6.py b/First term/Algorithms/4/6.py new file mode 100755 index 0000000..5c18afb --- /dev/null +++ b/First term/Algorithms/4/6.py @@ -0,0 +1,23 @@ + +def main() -> None: + # Config + input_string = "minimum" + + # Main code + some_dict = {} + + for char in input_string: + if some_dict.get(char) is None: + some_dict[char] = 1 + continue + some_dict[char] += 1 + + for char in input_string: + if some_dict[char] == 1: + print(char) + break + + +if __name__ == "__main__": + main() + diff --git a/First term/Algorithms/4/Алгоритмы - Рабочая тетрадь 4.pdf b/First term/Algorithms/4/Алгоритмы - Рабочая тетрадь 4.pdf new file mode 100755 index 0000000..505a44d Binary files /dev/null and b/First term/Algorithms/4/Алгоритмы - Рабочая тетрадь 4.pdf differ diff --git a/First term/Algorithms/README.md b/First term/Algorithms/README.md new file mode 100755 index 0000000..a36e56e --- /dev/null +++ b/First term/Algorithms/README.md @@ -0,0 +1,17 @@ +# Algorithms + +[Таблица с баллами](https://docs.google.com/spreadsheets/d/135vbCsW6saNCQs6ftMX8vYrR1yVyBFGC8ENsjEpcQBc/edit#gid=0) + +number | name | grade +:----: | --------------------------------------------------------------------- | :---: +1 | Метод половинного деления. Метод хорд | ✅ +1.2 | Бинарный поиск | ✅ +2 | Числовые алгоритмы | ✅ +2.2 | Работа с делением -_- | ✅ +3 | Алгоритмы длинной арифметики: сложение, вычитание, умножение, деление | ✅ +4 | Рекурсия | ✅ +5 | Алгоритмы сортировки массивов | ✅ +6 | Структуры данных (часть 1) | ✅ +extra | Структуры данных (часть 2) | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/First term/Algorithms/extra/1.cpp b/First term/Algorithms/extra/1.cpp new file mode 100755 index 0000000..4bbf575 --- /dev/null +++ b/First term/Algorithms/extra/1.cpp @@ -0,0 +1,34 @@ +#include +#include +#include + +using namespace std; + +int main() { + // srand(time(0)); + int n = rand() % 50; + int *arr = new int[n]; + + cout << "[ "; + for (int index = 0; index < n; ++index) { + arr[index] = rand() % 100; + cout << arr[index] << " "; + } + cout << "] (" << n << ")" << endl; + + int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0; + + for (int index = 0; index < n; ++index) { + if (arr[index] % 2 != 0) ++a; + if (int(sqrt(arr[index])) == sqrt(arr[index]) && int(sqrt(arr[index])) % 2 == 0) ++b; + if (arr[index] % 3 == 0 && arr[index] % 5 != 0) ++c; + if ((2 ^ index) < arr[index] && arr[index] < tgamma(index + 1)) ++d; + if (index + 1 < n && index - 1 >= 0 && arr[index] < (arr[index - 1] + arr[index + 1]) / 2) ++e; + if (index % 2 == 1 && arr[index] % 2 != 0) ++f; + } + + cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << endl; + + delete[] arr; + return 0; +} diff --git a/First term/Algorithms/extra/10.cpp b/First term/Algorithms/extra/10.cpp new file mode 100755 index 0000000..776eb86 --- /dev/null +++ b/First term/Algorithms/extra/10.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include + +using namespace std; + +void printNumbersInOrder(const string &filename) { + ifstream inputFile(filename); + if (!inputFile.is_open()) { + cerr << "Unable to open the file: " << filename << endl; + return; + } + + queue singleDigitQueue; + queue doubleDigitQueue; + + int number; + while (inputFile >> number) { + if (number >= 10) { + doubleDigitQueue.push(number); + } + else { + singleDigitQueue.push(number); + } + } + + while (!singleDigitQueue.empty()) { + cout << singleDigitQueue.front() << " "; + singleDigitQueue.pop(); + } + + while (!doubleDigitQueue.empty()) { + cout << doubleDigitQueue.front() << " "; + doubleDigitQueue.pop(); + } + + inputFile.close(); +} + +int main() { + string filename = "input.txt"; + printNumbersInOrder(filename); + + return 0; +} diff --git a/First term/Algorithms/extra/2.cpp b/First term/Algorithms/extra/2.cpp new file mode 100755 index 0000000..3d6778e --- /dev/null +++ b/First term/Algorithms/extra/2.cpp @@ -0,0 +1,31 @@ +#include +#include +using namespace std; + +int main() { + // srand(time(0)); + int arraySize = rand() % 50; + int *numbers = new int[arraySize]; + + cout << "[ "; + for (int index = 0; index < arraySize; ++index) { + numbers[index] = rand() % 100; + cout << numbers[index] << " "; + } + cout << "] (" << arraySize << ")" << endl; + + int divisibleByFiveCount = 0; + int divisibleByFiveSum = 0; + + for (int index = 0; index < arraySize; ++index) { + if (numbers[index] % 5 == 0 && numbers[index] % 7 != 0) { + divisibleByFiveSum += numbers[index]; + ++divisibleByFiveCount; + } + } + + cout << divisibleByFiveCount << " " << divisibleByFiveSum << endl; + + delete[] numbers; + return 0; +} diff --git a/First term/Algorithms/extra/3.cpp b/First term/Algorithms/extra/3.cpp new file mode 100755 index 0000000..93cf81a --- /dev/null +++ b/First term/Algorithms/extra/3.cpp @@ -0,0 +1,43 @@ +#include +#include +using namespace std; + +int main() { + srand(time(0)); + int arraySize = rand() % 50; + int *numbers = new int[arraySize]; + + cout << "[ "; + for (int index = 0; index < arraySize; ++index) { + numbers[index] = rand() % 3; // 100 + cout << numbers[index] << " "; + } + cout << "] (" << arraySize << ")" << endl; + + bool hasTwoConsecutiveZeros = false; + bool hasThreeConsecutiveZeros = false; + int consecutiveZerosCount = 0; + + for (int index = 0; index < arraySize; ++index) { + if (numbers[index] != 0) { + consecutiveZerosCount = 0; + continue; + } + + if (consecutiveZerosCount == 1) { + hasTwoConsecutiveZeros = true; + } + + if (consecutiveZerosCount == 2) { + hasThreeConsecutiveZeros = true; + break; + } + + ++consecutiveZerosCount; + } + + cout << hasTwoConsecutiveZeros << " " << hasThreeConsecutiveZeros << endl; + + delete[] numbers; + return 0; +} diff --git a/First term/Algorithms/extra/4.cpp b/First term/Algorithms/extra/4.cpp new file mode 100755 index 0000000..ead0e50 --- /dev/null +++ b/First term/Algorithms/extra/4.cpp @@ -0,0 +1,55 @@ +#include +#include +using namespace std; + +struct Node { + int data; + Node *next; + Node(int value) : data(value), next(nullptr) {} +}; + +Node *createList(int size) { + if (size <= 0) + { + return nullptr; + } + Node *element = new Node(1); + Node *head = element; + for (int index = 0; index < size - 1; index++) + { + Node *new_node = new Node(index); + element->next = new_node; + element = new_node; + } + return head; +} + +void printList(Node *head) { + Node *ptr = head; + while (ptr) + { + cout << ptr->data << " -> "; + ptr = ptr->next; + } + cout << "nullptr" << endl; +} + +int sumOfListElements(Node *head) { + int sum = 0; + while (head != nullptr) + { + sum += head->data; + head = head->next; + } + return sum; +} + +int main() { + srand(time(0)); + + Node *head = createList(10); + + printList(head); + cout << sumOfListElements(head) << endl; + return 0; +} diff --git a/First term/Algorithms/extra/5.cpp b/First term/Algorithms/extra/5.cpp new file mode 100755 index 0000000..2ae1b5e --- /dev/null +++ b/First term/Algorithms/extra/5.cpp @@ -0,0 +1,33 @@ +#include +#include +using namespace std; + +int main() { + srand(time(0)); + int arraySize = rand() % 50; + int *numbers = new int[arraySize]; + + cout << "[ "; + for (int index = 0; index < arraySize; ++index) { + numbers[index] = rand() % 10; + cout << numbers[index] << " "; + } + cout << "] (" << arraySize << ")" << endl; + + bool isDescending = true; + int previousNumber = numbers[0]; + + for (int index = 0; index < arraySize; ++index) { + if (numbers[index] >= previousNumber) { + isDescending = false; + break; + } + previousNumber = numbers[index]; + } + + cout << isDescending << endl; + + delete[] numbers; + return 0; +} + diff --git a/First term/Algorithms/extra/6.cpp b/First term/Algorithms/extra/6.cpp new file mode 100755 index 0000000..72696a6 --- /dev/null +++ b/First term/Algorithms/extra/6.cpp @@ -0,0 +1,134 @@ +#include +#include +using namespace std; + +struct Node { + int data; + Node* next; + + Node(int value) : data(value), next(nullptr) {} +}; + +Node* constructList(int size) { + if (size <= 0) { + return nullptr; + } + + Node* element = new Node(rand() % 100 + 1); + Node* head = element; + + for (int i = 0; i < size - 1; i++) { + Node* new_node = new Node(rand() % 100 + 1); + element->next = new_node; + element = new_node; + } + + return head; +} + +bool isListEmpty(Node* head) { + return (head == nullptr); +} + +int countOfListElements(Node* head) { + int count = 0; + while (head != nullptr) { + ++count; + head = head->next; + } + return count; +} + +void addElementToHead(Node*& head, int value) { + Node* element = new Node(value); + element->next = head; + head = element; +} + +void addElementToLast(Node*& head, int value) { + Node* element = new Node(value); + Node* ptr = head; + + while (ptr) { + if (ptr->next == nullptr) { + ptr->next = element; + break; + } + ptr = ptr->next; + } +} + +void addElementToN(Node*& head, int value, int index) { + Node* element = new Node(value); + Node* ptr = head; + + while (ptr) { + --index; + + if (index < 0) { + element->next = head; + break; + } + + if (index == 0) { + element->next = ptr->next; + ptr->next = element; + break; + } + + ptr = ptr->next; + } +} + +void printList(Node* head) { + Node* ptr = head; + while (ptr) { + cout << ptr->data << " -> "; + ptr = ptr->next; + } + cout << "nullptr" << endl; +} + +Node* copyListExceptFirst(Node* head) { + if (head == nullptr || head->next == nullptr) { + return nullptr; + } + + Node* newHead = new Node(head->next->data); + Node* current = newHead; + Node* original = head->next->next; + + while (original) { + current->next = new Node(original->data); + current = current->next; + original = original->next; + } + + return newHead; +} + +int main() { + srand(time(0)); + Node* numbers = nullptr; + + cout << isListEmpty(numbers) << endl; + + numbers = constructList(10); + printList(numbers); + + addElementToHead(numbers, 1); + printList(numbers); + + addElementToLast(numbers, 10); + printList(numbers); + + addElementToN(numbers, 5, 5); + printList(numbers); + + Node* newList = copyListExceptFirst(numbers); + printList(newList); + + cout << countOfListElements(numbers) << endl; + + return 0; +} diff --git a/First term/Algorithms/extra/7.cpp b/First term/Algorithms/extra/7.cpp new file mode 100755 index 0000000..9ccc3d0 --- /dev/null +++ b/First term/Algorithms/extra/7.cpp @@ -0,0 +1,203 @@ +#include +#include +using namespace std; + +struct Node { + int data; + Node* next; + + Node(int value) : data(value), next(nullptr) {} +}; + +Node* createList(int size) { + if (size <= 0) { + return nullptr; + } + + Node* element = new Node(1); + Node* head = element; + + for (int index = 0; index < size - 1; index++) { + Node* new_node = new Node(index); + element->next = new_node; + element = new_node; + } + + return head; +} + +void printList(Node* head) { + Node* ptr = head; + while (ptr) { + cout << ptr->data << " -> "; + ptr = ptr->next; + } + cout << "nullptr" << endl; +} + +bool areListsEqual(Node* head1, Node* head2) { + Node* ptr1 = head1; + Node* ptr2 = head2; + + while (ptr1 && ptr2) { + if (ptr1->data != ptr2->data) { + return false; + } + ptr1 = ptr1->next; + ptr2 = ptr2->next; + } + + return ptr1 == ptr2; +} + +bool doAllElementsExist(Node* head1, Node* head2) { + map m; + Node* ptr = head2; + + while (ptr) { + m[ptr->data] = true; + ptr = ptr->next; + } + + ptr = head1; + + while (ptr) { + if (!m[ptr->data]) { + return false; + } + ptr = ptr->next; + } + + return true; +} + +bool hasDuplicateElements(Node* head) { + map m; + Node* ptr = head; + + while (ptr) { + if (m[ptr->data]) { + return true; + } + + m[ptr->data] = true; + ptr = ptr->next; + } + + return false; +} + +void moveToLast(Node*& head) { + Node* newHead = head->next; + Node* ptr = head; + + while (ptr->next != nullptr) { + ptr = ptr->next; + } + + head->next = nullptr; + ptr->next = head; + + head = newHead; +} + +void moveToFirst(Node*& head) { + Node* ptr = head; + + while (ptr->next->next != nullptr) { + ptr = ptr->next; + } + + Node* newHead = ptr->next; + ptr->next = nullptr; + newHead->next = head; + + head = newHead; +} + +void appendList(Node*& head1, Node* head2) { + Node* ptr = head1; + + while (ptr->next != nullptr) { + ptr = ptr->next; + } + + ptr->next = head2; +} + +void reverseList(Node*& head) { + Node* newHead = nullptr; + Node* ptr = head; + + while (ptr) { + Node* nextPtr = ptr->next; + ptr->next = newHead; + newHead = ptr; + ptr = nextPtr; + } + + head = newHead; +} + +void keepDistinctElements(Node*& head) { + map m; + Node* newHead = nullptr; + Node* ptr = head; + Node* prev = nullptr; + + while (ptr) { + if (!m[ptr->data]) { + m[ptr->data] = true; + + if (!newHead) { + newHead = ptr; + } + + if (prev) { + prev->next = ptr; + } + + prev = ptr; + } + + ptr = ptr->next; + } + + if (prev) { + prev->next = nullptr; + } + + head = newHead; +} + +int main() { + srand(time(0)); + + Node* list1 = createList(10); + Node* list2 = createList(10); + appendList(list2, new Node(10)); + + printList(list1); + printList(list2); + + cout << areListsEqual(list1, list2) << endl; + cout << doAllElementsExist(list1, list2) << endl; + cout << hasDuplicateElements(list1) << endl; + + moveToLast(list1); + printList(list1); + + moveToFirst(list1); + printList(list1); + + appendList(list1, list2); + printList(list1); + + reverseList(list1); + printList(list1); + + keepDistinctElements(list1); + printList(list1); + + return 0; +} diff --git a/First term/Algorithms/extra/8.cpp b/First term/Algorithms/extra/8.cpp new file mode 100755 index 0000000..3801467 --- /dev/null +++ b/First term/Algorithms/extra/8.cpp @@ -0,0 +1,31 @@ +#include + +using namespace std; + +int main() { + int* arr; + int temp; + int size = 10; + int shift = 23; + + arr = new int[size]; + for (int index = 0; index < size; ++ index) { + arr[index] = index; + cout << arr[index] << " "; + } + cout << endl; + + shift %= size; + for (int count = 0; count < shift; ++count) { + temp = arr[9]; + for (int index = size-1; index > 0; --index) + arr[index] = arr[index-1]; + arr[0] = temp; + } + + for (int index = 0; index < size; ++index) + cout << arr[index] << " "; + cout << endl; + + return 0; +} diff --git a/First term/Algorithms/extra/9.cpp b/First term/Algorithms/extra/9.cpp new file mode 100755 index 0000000..2513565 --- /dev/null +++ b/First term/Algorithms/extra/9.cpp @@ -0,0 +1,24 @@ +#include +#include +#include + +using namespace std; + +int main() { + stack stack; + ifstream inputFile("input.txt"); + + if (inputFile.is_open()) { + while (inputFile) { + stack.push(inputFile.get()); + } + } + stack.pop(); + + while (!stack.empty()) { + cout << char(stack.top()); + stack.pop(); + } + + return 0; +} diff --git a/First term/Informatics/IT-1.md b/First term/Informatics/IT-1.md new file mode 100755 index 0000000..eb8d56f --- /dev/null +++ b/First term/Informatics/IT-1.md @@ -0,0 +1,325 @@ +# Рабочая тетрадь № 1 + +## Задачи № 1 + +### № 1 + +```math +4 mb = 4 * 1024 * 1024 * 8 bit = 33554432 bit +``` + +### № 2 + +```math +2 gb = 2 * 1024 * 1024 * 1024 byte = 2147483648 byte +``` + +### № 3 + +```math +6291456 byte = 6291456 / 1024 / 1024 mb = 6 mb +``` + +## Задачи № 2 + +### № 1 + +```math +log2(26) = 5 bit +``` + +### № 2 + +```math +log2(5) = 3 bit +``` + +### № 3 + +```math +log2(21) = 5 bit +``` + +## Задачи № 3 + +### № 1 + +```math +-0.5 * log2(0.5) = 0.5 +-0.5 * log2(0.5) = 0.5 + +H = 0.5 + 0.5 = 1 +``` + +### № 2 + +```math +-1/6 * log2(1/6) = 0.431 +-1/6 * log2(1/6) = 0.431 +-1/6 * log2(1/6) = 0.431 +-1/6 * log2(1/6) = 0.431 +-1/6 * log2(1/6) = 0.431 +-1/6 * log2(1/6) = 0.431 + +H = 0.431 + 0.431 + 0.431 + 0.431 + 0.431 + 0.431 = 2586 +``` + +### № 3 + +```math +-0.6 * log2(0.6) = 0.442 +-0.4 * log2(0.4) = 0.529 + +H = 0.442 + 0.529 = 0.971 +``` + +## Задачи № 4 + +### № 1 + +```math +77 +``` + +### № 2 + +```math +u +``` + +### № 3 + +```math +73 74 75 64 65 6E 74 +``` + +## Задачи № 5 + +### № 1 + +```math +110010010 +``` + +### № 2 + +```math +101000011 +``` + +### № 3 + +```math +Да +``` + +## Задачи № 6 + +### № 1 + +```math +00111011 + +000 000 111 111 111 000 111 111 +``` + +### № 2 + +```math +001 011 010 110 011 010 001 111 + +01011001 +``` + +### № 3 + +```math +CCz oYo mdm ppS uRu tpt wee Qrr __* Rss acc iBi eee nn% Fcc jee + +Computer_science +``` + +## Задачи № 7 + +### № 1 + +```math +B 1010100 +C 0011110 + 0110101 + +3 +``` + +### № 2 + +```math +A 0101010 +B 1010100 +C 0011110 + +ρ(A,B) + +A 0101010 +B 1010100 + 0000001 + +6 + +ρ(A,C) + +A 0101010 +C 0011110 + 1001011 + +3 + +ρ(B,C) + +B 1010100 +C 0011110 + 0110101 + +3 + +ρ(A,B) ≤ ρ(A,C) + ρ(C,B) - Да +ρ(A,C) ≤ ρ(A,B) + ρ(B,C) - Да +ρ(B,C) ≤ ρ(B,A) + ρ(A,C) - Да + +Да +``` + +### № 3 + +```math +d = min(6, 3, 3) = 3 + +3 >= 2n + 1 + +n = 1 +``` + +## Тест + +1. 1 +2. 3 +3. 2 +4. 4 +5. 4 +6. 2 +7. 3 +8. 1 +9. 3 +10. 4 + +## Задачи № 8 + +### № 1 + +```python +print("Калинин Никита Викторович ЭФБО-09-23") +``` + +### № 2 + +```python +a = int(input()) +b = int(input()) + +print(a + b) +``` + +### № 3 + +```python +a = float(input()) + +print(x ** 5 - 2 * x ** 3 + 1) +``` + +## Задачи № 9 + +### № 1 + +```python +strange = [[], 1] + +print(type(strange)) +``` + +### № 2 + +```python +for x in 0, 1: + for y in 0, 1: + if (x or y) and (not(x) or y) and not(x and y): + print(x, y) +``` + +### № 3 + +```python +some_list = [] + +for i in range(4): + some_list.append(i) + +for i in some_list[::-1]: + print(i) +``` + +## Задачи № 10 + +### № 1 + +```python +from math import log, ceil + +def hartly(n: int) -> float: + return ceil(log(n, 2)) + +print(hartly(int(input()))) +``` + +### № 2 + +```python +from math import log + +def entropy(p1, p2: float) -> float: + h1 = -1 * p1 * log(p1, 2) + h2 = -1 * p2 * log(p2, 2) + + return h1 + h2 + +a = float(input()) +b = float(input()) + +print(entropy(a, b)) +``` + +### № 3 + +```python +from math import tan, cos, sin, e, log + +def some_func(x: float) -> float: + return tan(cos(x) * sin(2 * x) / x * e**x) ** log(x, 7) + +x = float(input()) +print(some_func(x)) +``` + +### № 4 + +```python +def parity_bit(string: str) -> str: + if string.count("1") % 2 == 0: + return string + "0" + + return string + "1" + +s = input() + +print(parity_bit(s)) +``` diff --git a/First term/Informatics/IT-2.md b/First term/Informatics/IT-2.md new file mode 100755 index 0000000..b345ee0 --- /dev/null +++ b/First term/Informatics/IT-2.md @@ -0,0 +1,286 @@ +# Рабочая тетрадь № 2 + +## Задачи № 1 + +### № 1 + +```math +101010 bin = 1 * 2 ^ 1 + 1 * 2 ^ 3 + 1 * 2 ^ 5 = 42 dec +``` + +### № 2 + +```math +563 oct = 3 * 8 ^ 0 + 6 * 8 ^ 1 + 5 * 8 ^ 2 = 371 dec +``` + +### № 3 + +```math +A1286 двенадцатиричной = 6 * 12 ^ 0 + 8 * 12 ^ 1 + 2 * 12 ^ 2 + 1 * 12 ^ 3 + 10 * 12 ^ 4 = 209478 dec +``` + +### № 4 + +```math +127 dec = 1111111 bin + +7 +``` + +## Задачи № 2 + +### № 1 + +```math +367 / 7 = 52 3 +52 / 7 = 7 3 +7 / 7 = 1 0 +1 / 7 = 0 1 + +1033 +``` + +### № 2 + +```math +1143 / 12 = 95 3 +95 / 12 = 7 11 +7 / 12 = 0 7 + +7B3 +``` + +### № 3 + +```ma# Рабочая тетрадь № 2 + +## Задачи № 1 + +### № 1 + +```math +101010 bin = 1 * 2 ^ 1 + 1 * 2 ^ 3 + 1 * 2 ^ 5 = 42 dec +``` + +### № 2 + +```math +563 oct = 3 * 8 ^ 0 + 6 * 8 ^ 1 + 5 * 8 ^ 2 = 371 dec +``` + +### № 3 + +```math +A1286 двенадцатиричной = 6 * 12 ^ 0 + 8 * 12 ^ 1 + 2 * 12 ^ 2 + 1 * 12 ^ 3 + 10 * 12 ^ 4 = 209478 dec +``` + +### № 4 + +```math +127 dec = 1111111 bin + +7 +```th +127 oct = 7 * 8 ^ 0 + 2 * 8 ^ 1 + 1 * 8 ^ 2 = 87 dec + +87 / 9 = 9 6 +9 / 9 = 1 0 +1 / 9 = 0 1 + +106 +``` + +### № 4 + +```math +AB4 = 4 * 13 ^ 0 + 11 * 13 ^ 1 + 10 * 13 ^ 2 = 1837 + +1837 / 6 = 306 1 +306 / 6 = 51 0 +51 / 6 = 8 3 +8 / 6 = 1 2 +1 / 6 = 0 1 + + +12301 +``` + +## Задачи № 3 + +### № 1 + +```math +0010 1001 1101 + +29D +``` + +### № 2 + +```math +1 1 4 7 4 5 3 + +1001100111100101011 +``` + +### № 3 + +```math +1 2 7 + +0000 0101 0111 + +57 +``` + +### № 4 + +```math +C 3 E 1 + +110000111100001 + +8 +``` + +### № 5 + +```math +A F 3 8 + +0101 0011 1100 0110 1001 + +53C69 + +001 010 011 110 001 101 001 + +1236151 + +1010011110001101001 +``` + +## Тест № 2 + +1. A - 100101 +2. C - 26 +3. D - 11011000 +4. B - X a // 10: + print("Первая цифра больше") +elif a % 10 < a // 10: + print("Вторая цифра больше") +else: + print("Они одинаковые") +``` + +### № 3 + +```python +a = float(input()) +b = float(input()) +c = float(input()) + +d = b ** 2 - 4 * a * c + +if d >= 0: + a1 = (-b + d ** 0.5) / (2 * a) + a2 = (-b - d ** 0.5) / (2 * a) + print(a1, a2) +else: + print("Корней нет") +``` + +## Задачи № 6 + +### № 1 + +```python +a = int(input()) +i = 0 +while a % i != 0: + i += 1 + +print(i) +``` + +### № 2 + +```python +a = int(input()) +i = 0 +while a != 0: + i += a + a -= 1 +print(i) +``` + +### № 3 + +```python +a = int(input()) + +k = 0 +for i in range(2, a // 2 + 1): + if a % i == 0: + k += 1 + +if k <= 0: + print("Простое") +else: + print("Не простое") +``` + +### № 4 + +```python +a = int(input()) +n = int(input()) + +new = "" +while a > 0: + r = a % n + new += str(r) + a //= n + +print(new[::-1]) +``` diff --git a/First term/Informatics/IT-3.md b/First term/Informatics/IT-3.md new file mode 100755 index 0000000..c0ee60c --- /dev/null +++ b/First term/Informatics/IT-3.md @@ -0,0 +1,150 @@ +# Рабочая тетрадь № 3 + +## Задачи № 1 + +### № 1 + +```math +132 dec / 2 = 66 0 +66 / 2 = 33 0 +33 / 2 = 17 1 +17 / 2 = 8 1 +8 / 2 = 4 0 +4 / 2 = 2 0 +2 / 2 = 1 0 +1 / 2 = 0 1 + +136 dec = 10001100 bin + +0000000010001100 +``` + +### № 2 + +```math +0000000000000000 bin = 0 dec + +1111111111111111 bin = 65535 dec +``` + +## Задачи № 2 + +### № 1 + +```math +12 dec = 1100 bin + +0.0001100 +0.0001100 +0.0001100 +``` + +### № 2 + +```math +35 dec = 100011 bin + +1.00100011 +1.11011100 +1.11011101 +``` + +### № 3 + +```math +1.1011100 +1.1111011 + +1111011 bin = 123 dec + +-123 +``` + +## Задачи № 3 + +### № 1 + +```math +A dec = 78 B dec = 56 + +A bin = +1001110 +B bin = +0111000 + +[A]п = [A]ок = [A]дк = 0.1001110 +[B]п = [B]ок = [B]дк = 0.0111000 + + +0.1001110 +0.0111000 +--------- +0.10000110 + +10000110 bin = 134 dec +``` + +## Тест № 3 + +1. B (прямой, обратный или дополнительный код) +2. C (выглядит одинаково в прямом, обратном и дополнительном кодах) +3. A (обратный код) +4. A (из обратного кода прибавлением единицы к младшему разряду без переноса в знаковый разряд) +5. B (прямой код) +6. A (00001110) +7. D (–118) +8. B (+39) +9. A (10111111) +10. 10011001 + +## Задачи № 4 + +### № 1 + +```python +from math import * + +def f(x, y: float) -> float: + return log(abs(sin(x+y))) + +x = float(input()) +y = float(input()) + +print(f(x, y)) +``` + +### № 2 + +```python +from math import * + +def (x, y: float) -> float: + if sin(x + y) <= -0.5: + return arctg(abs(x * y) ** (1/3) * (x * e ** y)) + + if -0.5 < sin(x + y) < 0.5: + return 3 * log(abs(x * y), 3) + + if sin(x + y) >= 0.5: + return x ** 3 + y ** 1.5 + +x = float(input()) +y = float(input()) + +print(f(x, y)) +``` + +### № 3 + +```python +from math import * + +def f(x: float) -> float: + return cos(e * x) ** 3 + sin(abs(x)) + +a = float(input()) +b = float(input()) + +hx = float(input()) + +for x in range(a, b+1, hx): + print(f(x)) +``` diff --git a/First term/Informatics/IT-4.md b/First term/Informatics/IT-4.md new file mode 100755 index 0000000..7eb53f2 --- /dev/null +++ b/First term/Informatics/IT-4.md @@ -0,0 +1,127 @@ +# Рабочая тетрадь № 4 + +## Задачи № 1 + +### № 1 + +```math +AvB⇒A~B + +a b f +0 0 0 +1 1 1 +0 1 0 +1 0 0 + +A̅v¬(B~A)⊕B + +a b f +0 0 1 +1 1 1 +1 0 0 +0 1 1 + +AvB⇒C + +a b c f +0 0 0 1 +0 0 1 1 +0 1 1 1 +1 0 1 1 +1 1 1 1 +0 1 0 0 +1 0 0 0 +1 1 0 0 +``` + +### № 2 + +```math +(4) +``` + +### № 3 + +```math +(2) +``` + +### № 4 + +```math +(4) +``` + +### № 5 + +```math +4 +``` + +### № 6 + +```math +1 0 0 0 +``` + +### № 7 + +```math +C, 2 +``` + +## Тест № 3 + +1. 2 (Таблица истинности) +2. 1 (¬А&¬В) +3. 2 (Сергей) +4. 1 (¬A ∨ ¬B ∨ ¬C) +5. 4 (X ∨ Y ∨ Z) +6. 4 (2) +7. 3 (3) +8. 30 +9. 10 +10. M, B + +## Задачи № 4 + +### № 1 + +```python +k = int(input()) +n = int(input()) + +print(2 << k-1 + 2 << n-1) +``` + +### № 2 + +```python +n = int(input()) + +if (n > 0 and (n & (n - 1))) == 0: + print("Yes") +else: + print("No") +``` + +### № 3 + +```python +a = int(input()) +k = int(input()) + +print(a | (1 << k)) +``` + +### № 4 + +```python +n = int(input()) +k = int(input()) + +ans = n & ~((1 << k) - 1) + +print(ans) +print(bin(n & ~((1 << k) - 1))) +``` diff --git a/First term/Informatics/IT-5.md b/First term/Informatics/IT-5.md new file mode 100755 index 0000000..ed21bd0 --- /dev/null +++ b/First term/Informatics/IT-5.md @@ -0,0 +1,212 @@ +# Рабочая тетрадь № 5 + +## Задачи № 1 + +### № 1 + +```math +¬( ( x ∧ y ) ∨ ̅z ) ≡ ¬( z → x ) ∨ ¬( z → y ) +¬( x ∧ y ) ∧ z ≡ ¬( ̅z ∨ x ) ∨ ¬( ̅z ∨ y ) +( ̅x ∨ ̅y ) ∧ z ≡ ( z ∧ ̅x ) ∨ ( z ∧ ̅y ) +( ̅x ∨ ̅y ) ∧ z ≡ z ∧ ( ̅x ∨ ̅y ) +( ̅x ∨ ̅y ) ∧ z ≡ ( ̅x ∨ ̅y ) ∧ z +``` + +### № 2 + +```math +¬( ( x ∧ y ) ∨ ̅z) ≡ ¬( z → x ) ∨ ¬( z → y ) + +x y z f1 f2 +0 0 0 0 0 +0 0 1 1 1 +0 1 1 1 1 +0 1 0 0 0 +1 0 0 0 0 +1 0 1 1 1 +1 1 0 0 0 +1 1 1 0 0 +``` + +### № 3 + +```math +F(x,y,z) = ( ̅z → x ) ↔ ( ̅x │ y ) + +x y z f +0 0 0 0 +0 0 1 1 +0 1 1 0 +0 1 0 1 +1 0 0 1 +1 0 1 1 +1 1 0 1 +1 1 1 1 + +ДНФ: ( y ∧ ̅z ) ∨ ( ̅y ∧ z ) ∨ x +КНФ: ( x ∨ ̅y ∨ z ) ∧ ( x ∨ y ∨ z ) +``` + +### № 4 + +```math +A = ( x → y ) ∧ ( x → ̅y ) ∧ x +A = ( ̅x ∨ y ) ∧ ( ̅x ∨ ̅y ) ∧ x +A = ( ̅x ∨ ( y ∧ ̅y ) ) ∧ x +A = ( ̅x ∨ 0 ) ∧ x +A = ̅x ∧ x +A = 0 +``` + +## Задачи № 2 + +### № 1 + +```math +1) x ∧ y ∨ x ∧ y ∨ ̅x ∧ ̅y + ( x ∧ y ) ∨ ( ̅x ∧ ̅y ) + ( x ∧ y ) ∨ ( ̅x ∧ ̅y ) + x ↔ y +2) ( x ∨ ̅y ) ∧ ( ̅x ∨ y ) ∧ ( ̅x ∨ ̅y ) + ( x ∨ ̅y ) ∧ ̅x + ( x ∧ ̅x ) ∨ ( ̅y ∧ ̅x ) + 0 ∨ ¬( y ∧ x ) + y | x +``` + +### № 2 + +```math +( x1 ∨ x2 ∨ x3 ) ∧ ( ̅x1 ∨ ̅x2 ∨ x3 ) ∧ ( x1 ∨ x2 ∨ ̅x3 ) ∧ ( ̅x1 ∨ ̅x2 ∨ ̅x3 ) +``` + +### № 3 + +```math +1) ( x ∨ ̅x ) +2) ( ̅x ∧ ̅y ) ∨ ( x ∧ y ) ∨ ( ̅x ∧ y ) ∨ ( x ∧ ̅y ) +``` + +### № 4 + +```math +1) ( x ∧ ̅x ) +2) ( ̅x ∨ ̅y ) ∧ ( x ∨ y ) ∧ ( ̅x ∨ y ) ∧ ( x ∨ ̅y ) +``` + +### № 5 + +```math +CДНФ: ( x ∧ y ∧ z ) ∨ ( ̅x ∧ y ∧ z ) ∨ ( ̅x ∧ ̅y ∧ z ) +CКНФ: ( x ∨ y ∨ z ) ∧ ( x ∨ ̅y ∨ z ) ∧ ( ̅x ∨ y ∨ z ) ∧ ( ̅x ∨ y ∨ ̅z ) ∧ ( ̅x ∨ ̅y ∨ z ) +``` + +## Тест № 5 + +1. 4 +2. 1 +3. 1 +4. 2 +5. 1 +6. 3 +7. 4 +8. 2 +9. 2 +10. 4 + +## Задачи № 3 + +### № 1 + +```python +a = int(input()) +if 100 <= a < 1000 and a % 5 == 0: + print("Является") +else: + print("Не является") +``` + +### № 2 + +```python +a = int(input()) +b = int(input()) +c = int(input()) + +if (a % 2) + (b % 2) + (c % 2) <= 1: + print("2 и более") +else: + print("Меньше 2") + +``` + +### № 3 + +```python +x, y = float(input()), float(input()) + +if (x >= 0 and x**2 + y**2 <= 1) or (y <= 1 and x >= 0 and y >= x - 1): + print("Yes") +else: + print("No") + +``` + +### № 4 + +```python +import math as m + + +x, y = float(input()), float(input()) + +if (y <= m.sin(x) and 0 <= y <= 0.5 and 0 <= x <= m.pi): + print("Yes") +else: + print("No") +``` + +### № 5 + +```python +x, y = float(input()), float(input()) +if (x <= 0 and x**2 + y**2 <= 1) or (x**2 + y**2 <= 1 and y >= x): + print("Yes") +else: + print("No") + +``` + +## Задачи № 4 + +### № 1 + +```python +# 3 +x, y = float(input()), float(input()) + +if (x >= 0 and x**2 + y**2 <= 1) or (y <= 1 and x >= 0 and y >=// x - 1): + print("Yes") +else: + print("No") + +# 4 +import math as m + + +x, y = float(input()), float(input()) + +if (y <= m.sin(x) and 0 <= y <= 0.5 and 0 <= x <= m.pi): + print("Yes") +else: + print("No") + +# 5 +x, y = float(input()), float(input()) + +if (x <= 0 and x**2 + y**2 <= 1) or (x**2 + y**2 <= 1 and y >= x): + print("Yes") +else: + print("No") + +``` diff --git a/First term/Informatics/IT-6.md b/First term/Informatics/IT-6.md new file mode 100755 index 0000000..83aeb64 --- /dev/null +++ b/First term/Informatics/IT-6.md @@ -0,0 +1,92 @@ +# Рабочая тетрадь № 6 + +## Задачи № 3 + +### № 1 + +```python +word = intput() + +if word[::-1] == word: + print("Палиндром") +else: + print("Не палиндром") +``` + +### № 2 + +```python +word = intput() + +print(word.lower()) +``` + +### № 3 + +```python +word = intput() + +print(word.upper()) +``` + +### № 4 + +```python +word = intput() + +for num in 0,1,2,3,4,5,6,7,8,9: + if str(num) in word: + print("Есть") + break +else: + print("Нет") +``` + +### № 5 + +```python +word = intput() + +print(" ".join(list(word))) +``` + +### № 6 + +```python +c = "C" + +print(ord(c)) +``` + +## Задачи № 4 + +### № 1 + +```python +print(list(range(0, 101, 17))) +``` + +### № 2 + +```python +w = [] +c = [] +for _ in range(5): + w.appen(input()) + c.append(w[-1]) + +print(w, c) +``` + +## Задачи № 5 + +### № 1 + +```python +a = set([1,2,3,4]) +b = set([4,34,2,6]) + +print(a | b) +print(a & b) +print(a - b) +``` diff --git a/First term/Informatics/IT-7.md b/First term/Informatics/IT-7.md new file mode 100755 index 0000000..0b46524 --- /dev/null +++ b/First term/Informatics/IT-7.md @@ -0,0 +1,107 @@ +# Рабочая тетрадь № 7 + +## Задачи № 1 + +### № 1 + +```math +А) 0, 0, 0, 5 +Б) 0, 0, 5, 0 +В) 10, 10, 20, 6 +``` + +### № 2 + +```math +1) s1 = 1, n = 1, n = 2, s = 1,5 +2) s1 = 1, n = 2, n = 3, s1 = 1,8 +3) 1,8 3 4 2,08 +4) 2,08 4 5 2,8 +``` + +### № 3 + +```math +5 +``` + +### № 4 + +```math +А) z = 1 +Б) z = 1,9375 +``` + +## Задачи № 2 + +### № 1 + +![image](./src/Screenshot%202023-12-02%20094710.png) + +### № 2 + +![image](./src/Screenshot%202023-12-02%20094736.png) + +### № 3 + +![image](./src/Screenshot%202023-12-02%20094750.png) + +## Задачи № 3 + +### № 1 + +```python +n = 10 +b = 2 +k = a // b +l = n % b +print("Остаток:", k) +print("Целая часть:", l) +``` + +### № 2 + +```python +def Sign(x): + if x < 0: + return -1 + elif x > 0: + return 1 + return 0 +``` + +### № 3 + +```python +word = str(input()) + +if word == word[::-1]: + print("yes") +else: + print("no") +``` + +### № 4 + +```python +sec = int(input()) + +day = 86400 +hour = 3600 +minute = 60 +second = 1 + +print(sec // day, (sec % day) // hour, ((sec % day) % hour) // minute, ((sec % day) % hour) % minute, sep=':') +``` + +### № 5 + +```python +def fibonacci_of(n): + if n in {0, 1}: + return n + return fibonacci_of(n - 1) + fibonacci_of(n - 2) + + +print(fibonacci_of(int(input()))) +``` diff --git a/First term/Informatics/IT-8.md b/First term/Informatics/IT-8.md new file mode 100755 index 0000000..a679d56 --- /dev/null +++ b/First term/Informatics/IT-8.md @@ -0,0 +1,73 @@ +# Рабочая тетрадь № 6 + +## Задачи № 1 + +### № 1 + +```python +def function(string: str) -> str: + half_length = len(string) // 2 + return string[:half_length][::-1] + string[half_length:][::-1] + +some_string = "привет" +print(function(some_string)) +``` + +### № 2 + +```python +def is_valid_bracket_structure(expression: str) -> bool: + stack = [] + bracket_pairs = {')': '(', '}': '{', ']': '['} + + for char in expression: + if char in bracket_pairs.values(): + stack.append(char) + elif char in bracket_pairs.keys(): + if not stack or bracket_pairs[char] != stack.pop(): + return False + + return not stack + + +expression = ")(, ())((), (, )))), ((())" # "(), (())(), ()(), ((()))" +if is_valid_bracket_structure(expression): + print("Скобочная структура правильная.") +else: + print("Скобочная структура неправильная.") +``` + +## Задачи № 2 + +### № 1 + +```python +import random + +class Warrior: + def __init__(self, name: str, health: int = 100): + self.name = name + self.health = health + + def attack(self, enemy: Warrior): + print(f"{self.name} атакует {enemy.name}") + enemy.health -= 20 + print(f"У {enemy.name} осталось {enemy.health} единиц здоровья") + + +warrior1 = Warrior("Воин 1") +warrior2 = Warrior("Воин 2") + +while warrior1.health > 0 and warrior2.health > 0: + attacker = random.choice([warrior1, warrior2]) + defender = warrior2 if attacker == warrior1 else warrior1 + + attacker.attack(defender) + +if warrior1.health <= 0: + print(f"{warrior2.name} одержал победу!") +elif warrior2.health <= 0: + print(f"{warrior1.name} одержал победу!") +else: + print("Бой окончен в ничью.") +``` diff --git a/First term/Informatics/README.md b/First term/Informatics/README.md new file mode 100755 index 0000000..eada365 --- /dev/null +++ b/First term/Informatics/README.md @@ -0,0 +1,14 @@ +# Algorithms + +number | name | grade +:----: | --------------------------------------------------------------------- | :---: +1 | Работа с размером информации | ✅ +2 | Системы счисления | ✅ +3 | Прямой, обратный, дополненный коды | ✅ +4 | Алгебра логики (часть 1) | ✅ +5 | Алгебра логики (часть 2) | ✅ +6 | Алгебра логики (python) | ✅ +7 | Машина Тьюринга | ✅ +8 | ООП | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/First term/Informatics/src/Screenshot 2023-12-02 094710.png b/First term/Informatics/src/Screenshot 2023-12-02 094710.png new file mode 100755 index 0000000..652c2c5 Binary files /dev/null and b/First term/Informatics/src/Screenshot 2023-12-02 094710.png differ diff --git a/First term/Informatics/src/Screenshot 2023-12-02 094736.png b/First term/Informatics/src/Screenshot 2023-12-02 094736.png new file mode 100755 index 0000000..96c3fff Binary files /dev/null and b/First term/Informatics/src/Screenshot 2023-12-02 094736.png differ diff --git a/First term/Informatics/src/Screenshot 2023-12-02 094750.png b/First term/Informatics/src/Screenshot 2023-12-02 094750.png new file mode 100755 index 0000000..5a19bec Binary files /dev/null and b/First term/Informatics/src/Screenshot 2023-12-02 094750.png differ diff --git a/README.md b/README.md new file mode 100755 index 0000000..7c4e450 --- /dev/null +++ b/README.md @@ -0,0 +1,26 @@ +# Mirea projects + +***project codename:*** Lucy + +This repository was created for saving and transferring MIREA Institute assignment solutions. + +## First term + +* [Algorithms](/NKTKLN/mirea-projects/src/branch/main/First%20term/Algorithms) +* [Informatics](/NKTKLN/mirea-projects/src/branch/main/First%20term/Informatics) + +## Second term + +* [Algorithms](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Algorithms) +* [Discrete math](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Discrete%20math) +* [Familiarization practice](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Familiarization%20practice) +* [Industrial programming technologies](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Industrial%20programming%20technologies) +* [Term papper](/NKTKLN/mirea-projects/src/branch/main/Term%20papers/%D0%AD%D0%A4%D0%91%D0%9E-09-23%20%D0%9A%D0%B0%D0%BB%D0%B8%D0%BD%D0%B8%D0%BD%20%D0%9D%D0%B8%D0%BA%D0%B8%D1%82%D0%B0%20%D0%92%D0%B8%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2%D0%B8%D1%87%20%D0%9A%D1%83%D1%80%D1%81%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D1%83%D1%81%D1%82%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%BC%D1%83%20%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8E%20%D0%BF%D1%80%D0%BE%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8B%D0%B9%20%D1%83%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%202%20%D1%81%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D1%80) + +## Third term + +* [Discrete math](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Discrete%20math) +* [Industrial programming technologies](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Industrial%20programming%20technologies) +* [Frontend and backend development](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Frontend%20and%20backend%20development) +* [Programming of corporate systems](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Programming%20of%20corporate%20systems) +* [Artificial intelligence systems and big data](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Artificial%20intelligence%20systems%20and%20big%20data) diff --git a/Second term/Algorithms/1.1/1.cpp b/Second term/Algorithms/1.1/1.cpp new file mode 100755 index 0000000..bbba235 --- /dev/null +++ b/Second term/Algorithms/1.1/1.cpp @@ -0,0 +1,66 @@ +#include + +using namespace std; + +struct Node { + int minNum; + int maxNum; + Node *left; + Node *right; + Node(int minValue, int maxValue) : minNum(minValue), maxNum(maxValue), left(nullptr), right(nullptr) {} +}; + +Node *buildTree(int minValue, int maxValue) { + if (minValue >= maxValue) return nullptr; + Node *root = new Node(minValue, maxValue); + if (maxValue - minValue > 1) { + int middleValue = (minValue + maxValue) / 2; + root->left = buildTree(minValue, middleValue); + root->right = buildTree(middleValue, maxValue); + } + return root; +} + +int searchX(Node *&node, int value) { + if(node == nullptr) return 0; + int count = 0; + if(node->minNum <= value && node->maxNum >= value) count++; + return count + searchX(node->left, value) + searchX(node->right, value); +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << "(" << node->minNum << ", " << node->maxNum << ") "; + printTree(node->right); +} + +int searchSum(Node *&node, int minValue, int maxValue) { + if (node == nullptr || minValue >= maxValue) return 0; + if(node->left != nullptr || node->right != nullptr) return searchSum(node->left, minValue, maxValue) + searchSum(node->right, minValue, maxValue); + int sum = 0; + if (node->maxNum <= maxValue && node->maxNum > minValue) sum += node->maxNum; + if (node->minNum == minValue) sum += node->minNum; + return sum; +} + +int main() { + int a, b; + cout << "> "; + cin >> a; + cout << "> "; + cin >> b; + Node *root = buildTree(a, b); + printTree(root); + cout << endl; + cout << "> "; + cin >> a; + cout << "Number of elements containing the number : " << searchX(root, a) << endl; + cout << "> "; + cin >> a; + cout << "> "; + cin >> b; + cout << "Counting the sum of elements on the segment : " << searchSum(root, a, b) << endl; + + return 0; +} diff --git a/Second term/Algorithms/1.1/Практическое занятие Рабочая_тетрадь_1_1_Дерево_отрезков_1.pdf b/Second term/Algorithms/1.1/Практическое занятие Рабочая_тетрадь_1_1_Дерево_отрезков_1.pdf new file mode 100755 index 0000000..4932245 Binary files /dev/null and b/Second term/Algorithms/1.1/Практическое занятие Рабочая_тетрадь_1_1_Дерево_отрезков_1.pdf differ diff --git a/Second term/Algorithms/1.1/Рабочая_тетрадь_1_1_Дерево_отрезков (2).docx b/Second term/Algorithms/1.1/Рабочая_тетрадь_1_1_Дерево_отрезков (2).docx new file mode 100755 index 0000000..abf39a9 Binary files /dev/null and b/Second term/Algorithms/1.1/Рабочая_тетрадь_1_1_Дерево_отрезков (2).docx differ diff --git a/Second term/Algorithms/1/1.cpp b/Second term/Algorithms/1/1.cpp new file mode 100755 index 0000000..a631480 --- /dev/null +++ b/Second term/Algorithms/1/1.cpp @@ -0,0 +1,106 @@ +#include +#include + +using namespace std; + +struct Node { + int key; + int count; + Node *left; + Node *right; + int height; + Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {} +}; + +int getHeight(Node *node) { + return (node == nullptr) ? -1 : node->height; +} + +void updateHeight(Node *&node) { + node->height = max(getHeight(node->left), getHeight(node->right)) + 1; +} + +void insert(Node *&node, int key) { + if (node->key > key) { + if (node->left == nullptr) node->left = new Node(key); + else insert(node->left, key); + } + else if (node->key < key) { + if (node->right == nullptr) node->right = new Node(key); + else insert(node->right, key); + } + else node->count++; + + updateHeight(node); +} + +Node *search(Node *&node, int key) { + if (node == nullptr) return nullptr; + if (node->key == key) return node; + return search((node->key > key) ? node->left : node->right, key); +} + +Node *getMin(Node *&node) { + if (node == nullptr) return nullptr; + if (node->left == nullptr) return node; + return getMin(node->left); +} + +Node *getMax(Node *&node) { + if (node == nullptr) return nullptr; + if (node->right == nullptr) return node; + return getMax(node->right); +} + +Node *deleteNode(Node *&node, int key) { + if (node == nullptr) return nullptr; + else if (node->key > key) node->left = deleteNode(node->left, key); + else if (node->key < key) node->right = deleteNode(node->right, key); + else if (node->key == key && node->count != 1) node->count--; + else { + if (node->left == nullptr || node->right == nullptr) + node = (node->left == nullptr) ? node->right : node->left; + else { + Node *maxLeft = getMax(node->left); + node->key = maxLeft->key; + node->left = deleteNode(node->left, maxLeft->key); + } + } + if (node != nullptr) updateHeight(node); + return node; +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << node->count << ") "; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes) { + Node *root = new Node(rand() % 100); + for (; countOfNodes > 0; countOfNodes--) insert(root, rand() % 100); + return root; +} + +int main() { + srand(time(0)); + + Node *root = generateRandomTree(10); + cout << "root: " << root->key << endl; + printTree(root); + cout << endl; + insert(root, 9); + cout << "root: " << root->key << endl; + printTree(root); + cout << endl; + cout << "height: " << root->height + 1 << endl; + Node *buffer = search(root, 9); + cout << buffer << endl; + cout << "root: " << root->key << endl; + root = deleteNode(root, 9); + printTree(root); + cout << endl; + + return 0; +} diff --git a/Second term/Algorithms/1/2.cpp b/Second term/Algorithms/1/2.cpp new file mode 100755 index 0000000..5558742 --- /dev/null +++ b/Second term/Algorithms/1/2.cpp @@ -0,0 +1,155 @@ +#include +#include +#include +#include + +using namespace std; + +struct Node { + string name; + vector numbers; + Node *left; + Node *right; + Node(string nameValue, string numberValue) { + name = nameValue; + numbers.push_back(numberValue); + right = nullptr; + left = nullptr; + } +}; + +Node *insert(Node *&node, string name, string number) { + if (node == nullptr) return new Node(name, number); + if (node->name > name) { + if (node->left == nullptr) node->left = new Node(name, number); + else insert(node->left, name, number); + } + else if (node->name < name) { + if (node->right == nullptr) node->right = new Node(name, number); + else insert(node->right, name, number); + } + else node->numbers.push_back(number); + + return node; +} + +Node *search(Node *&node, string name) { + if (node == nullptr) return nullptr; + if (node->name == name) return node; + return search((node->name > name) ? node->left : node->right, name); +} + +Node *getMax(Node *&node) { + if (node == nullptr) return nullptr; + if (node->right == nullptr) return node; + return getMax(node->right); +} + +Node *deleteNode(Node *&node, string name) { + if (node == nullptr) return nullptr; + else if (node->name > name) node->left = deleteNode(node->left, name); + else if (node->name < name) node->right = deleteNode(node->right, name); + else { + if (node->left == nullptr || node->right == nullptr) + node = (node->left == nullptr) ? node->right : node->left; + else { + Node *maxLeft = getMax(node->left); + node->name = maxLeft->name; + node->left = deleteNode(node->left, maxLeft->name); + } + } + + return node; +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->name << ":" << endl; + for (vector::const_iterator number = node->numbers.begin(); number != node->numbers.end(); number++) + cout << " * " << *number << endl; + printTree(node->right); +} + +int main() { + srand(time(0)); + + Node *root = nullptr; + + cout << "Phone book" << endl + << "Use 'help' to output all available commands." << endl; + while (true) { + string inputCommand; + cout << "> "; + cin >> inputCommand; + if (inputCommand == "help") + cout << "Commands:" << endl + << " * help - output all available commands" << endl + << " * add - add a new record" << endl + << " * del-person - delete person" << endl + << " * del-number - delete phone number from a person" << endl + << " * search - output phone numbers for a particular person" << endl + << " * list - output all names and phone numbers for each person" << endl + << " * exit - exit the program" << endl; + else if (inputCommand == "add") { + string name, phoneNumber; + cout << "Enter the person's name: "; + cin >> name; + cout << "Enter the person's phone number: "; + cin >> phoneNumber; + root = insert(root, name, phoneNumber); + cout << "The phone number '" << phoneNumber << "' was successfully added to the person named '" << name << "'." << endl; + } + else if (inputCommand == "del-person") { + string name; + cout << "Enter the person's name: "; + cin >> name; + root = deleteNode(root, name); + cout << "Person named '" << name << "' has been deleted." << endl; + } + else if (inputCommand == "del-number") { + string name; + cout << "Enter the person's name: "; + cin >> name; + Node *personNode = search(root, name); + if (personNode == nullptr) { + cout << "Person named '" << name << "' not found." << endl; + continue; + } + string phoneNumber; + cout << "Enter the person's phone number: "; + cin >> phoneNumber; + vector::iterator position = find(personNode->numbers.begin(), personNode->numbers.end(), phoneNumber); + if (position == personNode->numbers.end()) { + cout << "The phone number '" << phoneNumber << "' of a person named '" << name << "' was not found." << endl; + continue; + } + personNode->numbers.erase(position); + cout << "The phone number '" << phoneNumber << "' of a person named '" << name << "' has been deleted." << endl; + } + else if (inputCommand == "search") { + string name; + cout << "Enter the person's name: "; + cin >> name; + Node *personNode = search(root, name); + if (personNode == nullptr) { + cout << "Person named '" << name << "' not found." << endl; + continue; + } + cout << "The phone numbers of a person named '" << name << "':" << endl; + for (vector::const_iterator number = personNode->numbers.begin(); number != personNode->numbers.end(); number++) + cout << " * " << *number << endl; + } + else if (inputCommand == "list") { + cout << "List of all users and their phone numbers:" << endl; + printTree(root); + } + else if (inputCommand == "exit") { + cout << "Goodbye!" << endl; + break; + } + else cout << "Unknown command." << endl; + } + + return 0; +} diff --git a/Second term/Algorithms/1/Makefile b/Second term/Algorithms/1/Makefile new file mode 100755 index 0000000..a33ab74 --- /dev/null +++ b/Second term/Algorithms/1/Makefile @@ -0,0 +1,5 @@ +.SILENT: +run: + g++ -o main "$(name).cpp" + ./main + rm main diff --git a/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.docx b/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.docx new file mode 100755 index 0000000..d58a858 Binary files /dev/null and b/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.docx differ diff --git a/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.pdf b/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.pdf new file mode 100755 index 0000000..6a8f521 Binary files /dev/null and b/Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.pdf differ diff --git a/Second term/Algorithms/2/1.cpp b/Second term/Algorithms/2/1.cpp new file mode 100755 index 0000000..830b32b --- /dev/null +++ b/Second term/Algorithms/2/1.cpp @@ -0,0 +1,65 @@ +#include +#include + +using namespace std; + +struct Node { + int key; + int count; + Node *left; + Node *right; + int height; + Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {} +}; + +int getHeight(Node *node) { + return (node == nullptr) ? -1 : node->height; +} + +void updateHeight(Node *&node) { + node->height = max(getHeight(node->left), getHeight(node->right)) + 1; +} + +int getBalance(Node *node) { + return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left); +} + +void insert(Node *&node, int key) { + if (node->key > key) { + if (node->left == nullptr) node->left = new Node(key); + else insert(node->left, key); + } + else if (node->key < key) { + if (node->right == nullptr) node->right = new Node(key); + else insert(node->right, key); + } + else node->count++; + + updateHeight(node); +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | "; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes) { + Node *root = new Node(rand() % 100); + for (; countOfNodes > 0; countOfNodes--) + insert(root, rand() % 100); + return root; +} + +int main() { + srand(time(0)); + + cout << "[] - balance | () - count" << endl << endl; + + Node *root = generateRandomTree(10); + printTree(root); + cout << endl; + + return 0; +} diff --git a/Second term/Algorithms/2/2.cpp b/Second term/Algorithms/2/2.cpp new file mode 100755 index 0000000..b983a66 --- /dev/null +++ b/Second term/Algorithms/2/2.cpp @@ -0,0 +1,108 @@ +#include +#include + +using namespace std; + +struct Node { + int key; + int count; + Node *left; + Node *right; + int height; + Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {} +}; + +int getHeight(Node *node) { + return (node == nullptr) ? -1 : node->height; +} + +void updateHeight(Node *&node) { + node->height = max(getHeight(node->left), getHeight(node->right)) + 1; +} + +int getBalance(Node *node) { + return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left); +} + +void swap(Node *&first, Node *&second) { + int firstKey = first->key; + first->key = second->key; + second->key = firstKey; +} + +void rightRotate(Node *&node) { + swap(node, node->left); + Node *buffer = node->right; + node->right = node->left; + node->left = node->right->left; + node->right->left = node->right->right; + node->right->right = buffer; + updateHeight(node->right); + updateHeight(node); +} + +void leftRotate(Node *&node) { + swap(node, node->right); + Node *buffer = node->left; + node->left = node->right; + node->right = node->left->right; + node->left->right = node->left->left; + node->left->left = buffer; + updateHeight(node->left); + updateHeight(node); +} + +void balanceTree(Node *&node) { + int balance = getBalance(node); + if (balance == -2) { + if (getBalance(node->left) == 1) leftRotate(node->left); + rightRotate(node); + } + else if (balance == 2) { + if (getBalance(node->right) == -1) rightRotate(node->right); + leftRotate(node); + } +} + +void insert(Node *&node, int key) { + if (node->key > key) { + if (node->left == nullptr) node->left = new Node(key); + else insert(node->left, key); + } + else if (node->key < key) { + if (node->right == nullptr) node->right = new Node(key); + else insert(node->right, key); + } + else node->count++; + + updateHeight(node); + balanceTree(node); +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | "; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes) { + Node *root = new Node(rand() % 100); + for (; countOfNodes > 0; countOfNodes--) + insert(root, rand() % 100); + return root; +} + +int main() { + srand(time(0)); + + cout << "[] - balance | () - count" << endl << endl; + + Node *root = generateRandomTree(10); + printTree(root); + cout << endl; + cout << "root height: " << root->height << endl; + cout << "root key: " << root->key << endl; + + return 0; +} diff --git a/Second term/Algorithms/2/3.cpp b/Second term/Algorithms/2/3.cpp new file mode 100755 index 0000000..7c5ba3e --- /dev/null +++ b/Second term/Algorithms/2/3.cpp @@ -0,0 +1,151 @@ +#include +#include + +using namespace std; + +struct Node { + int key; + int count; + Node *left; + Node *right; + int height; + Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {} +}; + +int getHeight(Node *node) { + return (node == nullptr) ? -1 : node->height; +} + +void updateHeight(Node *&node) { + node->height = max(getHeight(node->left), getHeight(node->right)) + 1; +} + +int getBalance(Node *node) { + return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left); +} + +void swap(Node *&first, Node *&second) { + int firstKey = first->key; + first->key = second->key; + second->key = firstKey; +} + +void rightRotate(Node *&node) { + swap(node, node->left); + Node *buffer = node->right; + node->right = node->left; + node->left = node->right->left; + node->right->left = node->right->right; + node->right->right = buffer; + updateHeight(node->right); + updateHeight(node); +} + +void leftRotate(Node *&node) { + swap(node, node->right); + Node *buffer = node->left; + node->left = node->right; + node->right = node->left->right; + node->left->right = node->left->left; + node->left->left = buffer; + updateHeight(node->left); + updateHeight(node); +} + +void balanceTree(Node *&node) { + int balance = getBalance(node); + if (balance == -2) { + if (getBalance(node->left) == 1) leftRotate(node->left); + rightRotate(node); + } + else if (balance == 2) { + if (getBalance(node->right) == -1) rightRotate(node->right); + leftRotate(node); + } +} + +void insert(Node *&node, int key) { + if (node->key > key) { + if (node->left == nullptr) node->left = new Node(key); + else insert(node->left, key); + } + else if (node->key < key) { + if (node->right == nullptr) node->right = new Node(key); + else insert(node->right, key); + } + else node->count++; + + updateHeight(node); + balanceTree(node); +} + +Node *search(Node *&node, int key) { + if (node == nullptr) return nullptr; + if (node->key == key) return node; + return search((node->key > key) ? node->left : node->right, key); +} + +Node *getMin(Node *&node) { + if (node == nullptr) return nullptr; + if (node->left == nullptr) return node; + return getMin(node->left); +} + +Node *getMax(Node *&node) { + if (node == nullptr) return nullptr; + if (node->right == nullptr) return node; + return getMax(node->right); +} + +Node *deleteNode(Node *&node, int key) { + if (node == nullptr) return nullptr; + else if (node->key > key) node->left = deleteNode(node->left, key); + else if (node->key < key) node->right = deleteNode(node->right, key); + else { + if (node->left == nullptr || node->right == nullptr) + node = (node->left == nullptr) ? node->right : node->left; + else { + Node *maxLeft = getMax(node->left); + node->key = maxLeft->key; + node->left = deleteNode(node->left, maxLeft->key); + } + } + if (node != nullptr) { + updateHeight(node); + balanceTree(node); + } + return node; +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | "; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes, int head) { + Node *root = new Node(head); + for (; countOfNodes > 0; countOfNodes--) + insert(root, rand() % 100); + return root; +} + +int main() { + srand(time(0)); + + cout << "[] - balance | () - count" << endl << endl; + + Node *root = generateRandomTree(10, 8); + printTree(root); + cout << endl; + cout << "root height: " << root->height << endl; + cout << "root key: " << root->key << endl; + root = deleteNode(root, root->key); + cout << "root height: " << root->height << endl; + cout << "root key: " << root->key << endl; + printTree(root); + cout << endl; + + return 0; +} diff --git a/Second term/Algorithms/2/4.cpp b/Second term/Algorithms/2/4.cpp new file mode 100755 index 0000000..8015b74 --- /dev/null +++ b/Second term/Algorithms/2/4.cpp @@ -0,0 +1,102 @@ +#include +#define RED true +#define BLACK false + +using namespace std; + +struct Node { + int key; + Node *left; + Node *right; + Node *parent; + bool color; + Node(int value) : key(value), left(nullptr), right(nullptr), color(RED) {} +}; + +bool getColor(Node *node) { + if (node == nullptr) return BLACK; + return node->color; +} + +void setColor(Node *node, bool color) { + if (node == nullptr) return; + node->color = color; +} + +void insert(Node *&root, Node *&node, int key) { + if (root == nullptr) { + root = new Node(key); + setColor(root, BLACK); + return; + } + + if (node->key > key) { + if (node->left == nullptr) { + node->left = new Node(key); + setColor(node->left, !getColor(node)); + } + else insert(root, node->left, key); + } + else if (node->key <= key) { + if (node->right == nullptr) { + node->right = new Node(key); + setColor(node->right, !getColor(node)); + } + else insert(root, node->right, key); + } + + setColor(root, BLACK); +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << ((node->color == RED) ? "RED" : "BLACK") << ") " << endl; + printTree(node->right); +} + +int blackHeight(Node* node) { + if (node == nullptr) return 1; + int leftHeight = blackHeight(node->left); + int rightHeight = blackHeight(node->right); + + if (leftHeight != rightHeight) return 0; + if (leftHeight == 0 || rightHeight == 0) return 0; + if (getColor(node) == BLACK) leftHeight++; + + return leftHeight; +} + +void checkRedBlackTreeProperties(Node* root) { + if (blackHeight(root) != 0) + cout << "Correct" << endl; + else + cout << "Incorrect" << endl; +} + +int main() { + Node *root = nullptr; + insert(root, root, 13); + insert(root, root, 8); + insert(root, root, 17); + insert(root, root, 15); + insert(root, root, 25); + insert(root, root, 22); + insert(root, root, 27); + insert(root, root, 1); + insert(root, root, 11); + insert(root, root, 6); + + printTree(root); + cout << endl; + cout << "Checking for rules: "; + checkRedBlackTreeProperties(root); + + cout << "Add 7" << endl; + + insert(root, root, 7); + cout << "Checking for rules: "; + checkRedBlackTreeProperties(root); + + return 0; +} diff --git a/Second term/Algorithms/2/5.cpp b/Second term/Algorithms/2/5.cpp new file mode 100755 index 0000000..3c6c333 --- /dev/null +++ b/Second term/Algorithms/2/5.cpp @@ -0,0 +1,319 @@ +#include +#include +#define RED true +#define BLACK false + +using namespace std; + +struct Node { + int key; + Node *left; + Node *right; + Node *parent; + bool color; + Node(int value) : key(value), left(nullptr), right(nullptr), color(RED) {} +}; + +bool getColor(Node *node) { + if (node == nullptr) return BLACK; + return node->color; +} + +void setColor(Node *node, bool color) { + if (node == nullptr) return; + node->color = color; +} + +void rightRotate(Node *&root, Node *&node) { + Node *leftChild = node->left; + node->left = leftChild->right; + + if(node->left != nullptr) node->left->parent = node; + + leftChild->parent = node->parent; + + if(node->parent == nullptr) root = leftChild; + else if(node == node->parent->left) node->parent->left = leftChild; + else node->parent->right = leftChild; + + leftChild->right = node; + node->parent = leftChild; +} + +void leftRotate(Node *&root, Node *&node) { + Node *rightChild = node->right; + node->right = rightChild->left; + + if(node->right != nullptr) node->right->parent = node; + + rightChild->parent = node->parent; + + if(node->parent == nullptr) root = rightChild; + else if(node == node->parent->left) node->parent->left = rightChild; + else node->parent->right = rightChild; + + rightChild->left = node; + node->parent = rightChild; +} + +void fixRulesAfterInsertion(Node *&root, Node*& node) { + Node* parent = nullptr; + Node* grandParent = nullptr; + while (node != root && getColor(node) == RED && getColor(node->parent) == RED) { + parent = node->parent; + grandParent = parent->parent; + if(parent == grandParent->left) { + Node* uncle = grandParent->right; + if(getColor(uncle) == RED) { + setColor(uncle, BLACK); + setColor(parent, BLACK); + setColor(grandParent, RED); + node = grandParent; + } + else { + if(node == parent->right) { + leftRotate(root, parent); + node = parent; + parent = node->parent; + } + rightRotate(root, grandParent); + const bool color = grandParent->color; + grandParent->color = parent->color; + parent->color = color; + node = parent; + } + } + else { + Node* uncle = grandParent->left; + if(getColor(uncle) == RED) { + setColor(uncle, BLACK); + setColor(parent, BLACK); + setColor(grandParent, RED); + node = grandParent; + } + else { + if(node == parent->left) { + rightRotate(root, parent); + node = parent; + parent = node->parent; + } + leftRotate(root, grandParent); + const bool color = grandParent->color; + grandParent->color = parent->color; + parent->color = color; + node = parent; + } + } + } + setColor(root, BLACK); +} + +void insertNode(Node *&root, Node *&node) { + if (root == nullptr) { + root = node; + return; + } + + if (node->key < root->key) { + insertNode(root->left, node); + root->left->parent = root; + } + else if (node->key >= root->key) { + insertNode(root->right, node); + root->right->parent = root; + } +} + +void insertNodeValue(Node *&root, const int key) { + Node *node = new Node(key); + insertNode(root, node); + fixRulesAfterInsertion(root, node); +} + +Node *search(Node *&node, int key) { + if (node == nullptr) return nullptr; + if (node->key == key) return node; + return search((node->key > key) ? node->left : node->right, key); +} + +Node *getMin(Node *&node) { + if (node == nullptr) return nullptr; + if (node->left == nullptr) return node; + return getMin(node->left); +} + +Node *getMax(Node *&node) { + if (node == nullptr) return nullptr; + if (node->right == nullptr) return node; + return getMax(node->right); +} + +int getChildrenCount(Node *&node) { + int count = 0; + if (node->left != nullptr) count++; + if (node->right != nullptr) count++; + return count; +} + +Node *getChildOrMock(Node*& node) { + return node->left != nullptr ? node->left : node->right; +} + +void transplantNode(Node *&root, Node *&toNode, Node *&fromNode) { + if (toNode == root) root = toNode; + else if (toNode == toNode->parent->left) toNode->parent->left = fromNode; + else toNode->parent->right = fromNode; + fromNode->parent = toNode->parent; +} + +void fixRulesAfterRemoval(Node *&root, Node *&node) { + if (node == nullptr) return; + + if (node == root) { + root = nullptr; + return; + } + + if (getColor(node) == RED || getColor(node->left) == RED || getColor(node->right) == RED) { + Node *child = node->left != nullptr ? node->left : node->right; + if (node == node->parent->left) { + node->parent->left = child; + if (child != nullptr) child->parent = node->parent; + setColor(child, BLACK); + delete (node); + } else { + node->parent->right = child; + if (child != nullptr) child->parent = node->parent; + setColor(child, BLACK); + delete (node); + } + } else { + Node *sibling = nullptr; + Node *parent = nullptr; + Node *ptr = node; + setColor(ptr, BLACK); + while (ptr != root && getColor(ptr) == BLACK) { + parent = ptr->parent; + if (ptr == parent->left) { + sibling = parent->right; + if (getColor(sibling) == RED) { + setColor(sibling, BLACK); + setColor(parent, RED); + leftRotate(root, parent); + } else { + if (getColor(sibling->left) == BLACK && getColor(sibling->right) == BLACK) { + setColor(sibling, RED); + if(getColor(parent) == RED) setColor(parent, BLACK); + else setColor(parent, BLACK); + ptr = parent; + } else { + if (getColor(sibling->right) == BLACK) { + setColor(sibling->left, BLACK); + setColor(sibling, RED); + rightRotate(root, sibling); + sibling = parent->right; + } + setColor(sibling, parent->color); + setColor(parent, BLACK); + setColor(sibling->right, BLACK); + leftRotate(root, parent); + break; + } + } + } else { + sibling = parent->left; + if (getColor(sibling) == RED) { + setColor(sibling, BLACK); + setColor(parent, RED); + rightRotate(root, parent); + } else { + if (getColor(sibling->left) == BLACK && getColor(sibling->right) == BLACK) { + setColor(sibling, RED); + if (getColor(parent) == RED) setColor(parent, BLACK); + else setColor(parent, BLACK); + ptr = parent; + } else { + if (getColor(sibling->left) == BLACK) { + setColor(sibling->right, BLACK); + setColor(sibling, RED); + leftRotate(root, sibling); + sibling = parent->left; + } + setColor(sibling, parent->color); + setColor(parent, BLACK); + setColor(sibling->left, BLACK); + rightRotate(root, parent); + break; + } + } + } + } + if (node == node->parent->left) node->parent->left = nullptr; + else node->parent->right = nullptr; + delete(node); + setColor(root, BLACK); + } +} + +Node *deleteNode(Node *&node, int key) { + if (node == nullptr) return nullptr; + if (node->key > key) return deleteNode(node->left, key); + if (node->key < key) return deleteNode(node->right, key); + if (node->left == nullptr || node->right == nullptr) return node; + + Node *minRight = getMin(node->right); + node->key = minRight->key; + return deleteNode(node->right, minRight->key); +} + +void deleteNodeValue(Node *&root, const int key) { + Node* node = deleteNode(root, key); + fixRulesAfterRemoval(root, node); +} + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << ((node->color == RED) ? "RED" : "BLACK") << ")"<< endl; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes) { + Node *root = nullptr; + for (; countOfNodes > 0; countOfNodes--) insertNodeValue(root, rand() % 100); + return root; +} + +int blackHeight(Node* node) { + if (node == nullptr) return 1; + int leftHeight = blackHeight(node->left); + int rightHeight = blackHeight(node->right); + + if (leftHeight != rightHeight) return 0; + if (leftHeight == 0 || rightHeight == 0) return 0; + if (getColor(node) == BLACK) leftHeight++; + + return leftHeight; +} + +void checkRedBlackTreeProperties(Node* root) { + cout << "Checking for rules: "; + if (blackHeight(root) != 0) + cout << "Correct" << endl; + else + cout << "Incorrect" << endl; +} + +int main() { + srand(time(0)); + + Node *root = generateRandomTree(10); + printTree(root); + checkRedBlackTreeProperties(root); + cout << "rm " << root->key << endl; + deleteNodeValue(root, root->key); + printTree(root); + checkRedBlackTreeProperties(root); + + return 0; +} diff --git a/Second term/Algorithms/2/6.cpp b/Second term/Algorithms/2/6.cpp new file mode 100755 index 0000000..c3db7ad --- /dev/null +++ b/Second term/Algorithms/2/6.cpp @@ -0,0 +1,151 @@ +#include + +using namespace std; + +struct Node { + int key; + int count; + Node *left; + Node *right; + Node(int value) : key(value), left(nullptr), right(nullptr), count(1) {} +}; + +Node *getMax(Node *&node) { + if (node == nullptr) return nullptr; + if (node->right == nullptr) return node; + return getMax(node->right); +} + +Node *rightRotate(Node *node) { + Node *buffer = node->left; + node->left = buffer->right; + buffer->right = node; + return buffer; +} + +Node *leftRotate(Node *node) { + Node *buffer = node->right; + node->right = buffer->left; + buffer->left = node; + return buffer; +} + +void insertNode(Node *node, int key) { + if (node->key > key) { + if (node->left == nullptr) node->left = new Node(key); + else insertNode(node->left, key); + } + else if (node->key < key) { + if (node->right == nullptr) node->right = new Node(key); + else insertNode(node->right, key); + } + else node->count++; +} + +Node *deleteNode(Node *&node, int key) { + if (node == nullptr) return nullptr; + else if (node->key > key) node->left = deleteNode(node->left, key); + else if (node->key < key) node->right = deleteNode(node->right, key); + else if (node->key == key && node->count != 1) node->count--; + else { + if (node->left == nullptr || node->right == nullptr) + node = (node->left == nullptr) ? node->right : node->left; + else { + Node *maxLeft = getMax(node->left); + node->key = maxLeft->key; + node->left = deleteNode(node->left, maxLeft->key); + } + } + return node; +} + +Node *splay(Node *root, int key) { + if (root == nullptr || root->key == key) return root; + + if (root->key > key) { + if (root->left == nullptr) return root; + if (root->left->key > key) { + root->left->left = splay(root->left->left, key); + root = rightRotate(root); + } + else if (root->left->key < key) { + root->left->right = splay(root->left->right, key); + if (root->left->right != nullptr) root->left = leftRotate(root->left); + } + + return (root->left == nullptr) ? root : rightRotate(root); + } + + if (root->right == nullptr) return root; + if (root->right->key > key) { + root->right->left = splay(root->right->left, key); + if (root->right->left != nullptr) root->right = rightRotate(root->right); + } + else if (root->right->key < key) { + root->right->right = splay(root->right->right, key); + root = leftRotate(root); + } + + return (root->right == nullptr) ? root : leftRotate(root); +} + +void searchNodeValue(Node *&root, const int key) { + root = splay(root, key); +} + +void insertNodeValue(Node *&root, const int key) { + insertNode(root, key); + root = splay(root, key); +} + +void deleteNodeValue(Node *&root, const int key) { + root = splay(deleteNode(root, key), key); +} + +// ============================================= // + +int getKey(Node *&node) { + if (node == nullptr) return -1; + return node->key; +} + +void printTree(Node *&node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " (" << node->count << ") [" << getKey(node->left) + << ", " << getKey(node->right) << "]" << endl; + printTree(node->right); +} + +Node *generateRandomTree(int countOfNodes) { + Node *root = new Node(rand() % 100); + for (; countOfNodes > 0; countOfNodes--) insertNodeValue(root, rand() % 100); + return root; +} + +// ============================================= // + +int main() { + srand(13); + + Node *root = generateRandomTree(10); + printTree(root); + cout << "root: " << root->key << endl; + + cout << endl << "Search (8)" << endl; + searchNodeValue(root, 8); + printTree(root); + cout << "root: " << root->key << endl; + + cout << endl << "Insert (73)" << endl; + insertNodeValue(root, 73); + printTree(root); + cout << "root: " << root->key << endl; + + cout << endl << "Delete (38)"<< endl; + deleteNodeValue(root, 38); + printTree(root); + cout << "root: " << root->key << endl; + + return 0; +} diff --git a/Second term/Algorithms/2/Практические занятия Алгоритмы - Рабочая тетрадь 2.pdf b/Second term/Algorithms/2/Практические занятия Алгоритмы - Рабочая тетрадь 2.pdf new file mode 100755 index 0000000..0df1fa2 Binary files /dev/null and b/Second term/Algorithms/2/Практические занятия Алгоритмы - Рабочая тетрадь 2.pdf differ diff --git a/Second term/Algorithms/2/Текущий контроль - Рабочая тетрадь 2.docx b/Second term/Algorithms/2/Текущий контроль - Рабочая тетрадь 2.docx new file mode 100755 index 0000000..d7b2ea0 Binary files /dev/null and b/Second term/Algorithms/2/Текущий контроль - Рабочая тетрадь 2.docx differ diff --git a/Second term/Algorithms/3/1.cpp b/Second term/Algorithms/3/1.cpp new file mode 100755 index 0000000..fb3713e --- /dev/null +++ b/Second term/Algorithms/3/1.cpp @@ -0,0 +1,82 @@ +#include + +using namespace std; + +class Heap { +private: + int *data; + int length; + int lastIndex; + + void swap(int firstIndex, int secondIndex); + void heapify(int index); +public: + Heap(int maxHeapLength); + Heap(int* array, int arrayLength, int maxHeapLength); + ~Heap(); + void print(); +}; + +Heap::Heap(int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = 0; +} + +Heap::Heap(int* array, int arrayLength, int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = arrayLength - 1; + copy(array, array+arrayLength, this->data); + + for (int index = this->lastIndex / 2; index >= 0; index--) + heapify(index); +} + +Heap::~Heap() { delete[] this->data; } + +void Heap::swap(int firstIndex, int secondIndex) { + int tempElement = this->data[firstIndex]; + this->data[firstIndex] = this->data[secondIndex]; + this->data[secondIndex] = tempElement; +} + +void Heap::heapify(int index) { + int largestIndex = index; + int leftIndex = 2 * index + 1; + int rightIndex = 2 * index + 2; + + if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex]) + largestIndex = leftIndex; + if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex]) + largestIndex = rightIndex; + if (largestIndex == index) + return; + + swap(index, largestIndex); + heapify(largestIndex); +} + +void Heap::print() { + for (int index = 0; index <= this->lastIndex; index++) + cout << this->data[index] << " "; + cout << endl; +} + +int main() { + int length; + cout << "Enter array length: "; + cin >> length; + + int* arr = new int[length]; + cout << "Enter elements: "; + for (int index = 0; index < length; index++) + cin >> arr[index]; + + Heap* heap = new Heap(arr, length, 100); + heap->print(); + + delete heap; + + return 0; +} diff --git a/Second term/Algorithms/3/2.cpp b/Second term/Algorithms/3/2.cpp new file mode 100755 index 0000000..a213a1c --- /dev/null +++ b/Second term/Algorithms/3/2.cpp @@ -0,0 +1,136 @@ +#include + +using namespace std; + +class Heap { +private: + int *data; + int length; + int lastIndex; + + void heapify(int index); + void insertFix(int index); + void swap(int firstIndex, int secondIndex); +public: + Heap(int maxHeapLength); + Heap(int* array, int arrayLength, int maxHeapLength); + ~Heap(); + void print(); + int getMax(); + void deleteMax(); + void insert(int element); + void merge(Heap *heap); +}; + +Heap::Heap(int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = -1; +} + +Heap::Heap(int* array, int arrayLength, int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = arrayLength - 1; + copy(array, array+arrayLength, this->data); + + for (int index = arrayLength / 2 - 1; index >= 0; index--) + heapify(index); +} + +Heap::~Heap() { delete[] this->data; } + +void Heap::heapify(int index) { + int largestIndex = index; + int leftIndex = 2 * index + 1; + int rightIndex = 2 * index + 2; + + if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex]) + largestIndex = leftIndex; + if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex]) + largestIndex = rightIndex; + if (largestIndex == index) + return; + + swap(index, largestIndex); + heapify(largestIndex); +} + +void Heap::insertFix(int index) { + int parentIndex = (index - 1) / 2; + if (index <= parentIndex || this->data[parentIndex] >= this->data[index]) + return; + + swap(index, parentIndex); + insertFix(parentIndex); +} + +void Heap::swap(int firstIndex, int secondIndex) { + int tempElement = this->data[firstIndex]; + this->data[firstIndex] = this->data[secondIndex]; + this->data[secondIndex] = tempElement; +} + +void Heap::print() { + for (int index = 0; index <= this->lastIndex; index++) + cout << this->data[index] << " "; + cout << endl; +} + +int Heap::getMax() { + if (this->lastIndex == -1) + return -1; + return this->data[0]; +} + +void Heap::deleteMax() { + if (this->lastIndex == -1) + return; + + this->lastIndex--; + this->data[0] = this->data[this->lastIndex+1]; + heapify(0); +} + +void Heap::insert(int element) { + this->lastIndex++; + this->data[this->lastIndex] = element; + insertFix(this->lastIndex); +} + +void Heap::merge(Heap *heap) { + copy(heap->data, heap->data+heap->lastIndex+1, this->data + this->lastIndex + 1); + this->lastIndex += heap->lastIndex + 1; + + for (int index = (this->lastIndex + 1) / 2 - 1; index >= 0; index--) + heapify(index); +} + +int main() { + int length = 10; + int arr[] = {1, 3, 2, 4, 8, 7, 10, 14, 9, 16}; + int length2 = 9; + int arr2[] = {6, 5, 11, 16, 17, 18, 20, 24, 29}; + + Heap* heap = new Heap(arr, length, 100); + Heap* heap2 = new Heap(arr2, length2, 100); + + heap->print(); + cout << "Max element: " << heap->getMax() << endl; + cout << "Remove the max element." << endl; + heap->deleteMax(); + heap->print(); + cout << "Insert element (19)." << endl; + heap->insert(19); + heap->print(); + cout << "Print heap №2." << endl; + heap2->print(); + cout << "Merge heap and heap2." << endl; + heap->merge(heap2); + heap->print(); + + delete heap; + delete heap2; + + return 0; +} diff --git a/Second term/Algorithms/3/3.cpp b/Second term/Algorithms/3/3.cpp new file mode 100755 index 0000000..9600d84 --- /dev/null +++ b/Second term/Algorithms/3/3.cpp @@ -0,0 +1,113 @@ +#include + +using namespace std; + +class Heap { +private: + int *data; + int length; + int lastIndex; + + void heapify(int index); + void insertFix(int index); + void swap(int firstIndex, int secondIndex); +public: + Heap(int maxHeapLength); + Heap(int* array, int arrayLength, int maxHeapLength); + ~Heap(); + int getLength(); + int deleteMin(); + void insert(int element); +}; + +Heap::Heap(int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = -1; +} + +Heap::Heap(int* array, int arrayLength, int maxHeapLength) { + this->data = new int[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = arrayLength - 1; + copy(array, array+arrayLength, this->data); + + for (int index = arrayLength / 2 - 1; index >= 0; index--) + heapify(index); +} + +Heap::~Heap() { delete[] this->data; } + +void Heap::heapify(int index) { + int largestIndex = index; + int leftIndex = 2 * index + 1; + int rightIndex = 2 * index + 2; + + if (leftIndex <= this->lastIndex && this->data[leftIndex] < this->data[largestIndex]) + largestIndex = leftIndex; + if (rightIndex <= this->lastIndex && this->data[rightIndex] < this->data[largestIndex]) + largestIndex = rightIndex; + if (largestIndex == index) + return; + + swap(index, largestIndex); + heapify(largestIndex); +} + +void Heap::insertFix(int index) { + int parentIndex = (index - 1) / 2; + if (index <= parentIndex || this->data[parentIndex] <= this->data[index]) + return; + + swap(index, parentIndex); + insertFix(parentIndex); +} + +void Heap::swap(int firstIndex, int secondIndex) { + int tempElement = this->data[firstIndex]; + this->data[firstIndex] = this->data[secondIndex]; + this->data[secondIndex] = tempElement; +} + +int Heap::getLength() { return this->lastIndex + 1; } + +int Heap::deleteMin() { + if (this->lastIndex == -1) + return -1; + + int minElement = this->data[0]; + this->lastIndex--; + this->data[0] = this->data[this->lastIndex+1]; + heapify(0); + return minElement; +} + +void Heap::insert(int element) { + this->lastIndex++; + this->data[this->lastIndex] = element; + insertFix(this->lastIndex); +} + +int main() { + cout << "Array: [5, 4, 2, 8]" << endl; + + int length = 4; + int arr[] = {5, 4, 2, 8}; + Heap* heap = new Heap(arr, length, 10); + + int spending = 0; + int sumOfMinElements, firstMin, secondMin; + while (heap->getLength() > 1) { + firstMin = heap->deleteMin(); + secondMin = heap->deleteMin(); + sumOfMinElements = firstMin + secondMin; + cout << firstMin << " + " << secondMin << " = " << sumOfMinElements << endl; + spending += sumOfMinElements; + heap->insert(sumOfMinElements); + } + cout << spending << endl; + + delete heap; + + return 0; +} diff --git a/Second term/Algorithms/3/4.cpp b/Second term/Algorithms/3/4.cpp new file mode 100755 index 0000000..ec0be5a --- /dev/null +++ b/Second term/Algorithms/3/4.cpp @@ -0,0 +1,89 @@ +#include + +using namespace std; + +struct Node { + int key; + Node *left; + Node *right; + Node(int value) : key(value), left(nullptr), right(nullptr) {} +}; + +bool leftOrRight(Node *&node, int* depth = 0) { + if (node == nullptr) return -1; + + int leftDepth = 0; + int rightDepth = 0; + leftOrRight(node->left, &leftDepth); + leftOrRight(node->right, &rightDepth); + + *depth += 1 + min(leftDepth, rightDepth); + return leftDepth > rightDepth; +} + +void insert(Node *&node, int key) { + if (node->left == nullptr) { + node->left = new Node(key); + return; + } + else if (node->right == nullptr) { + node->right = new Node(key); + return; + } + + int temp = 0; + insert((leftOrRight(node, &temp)) ? node->right : node->left, key); +} + +int getKey(Node *&node) { return (node == nullptr) ? -1 : node->key; } + +void printTree(Node *node) { + if (node == nullptr) return; + printTree(node->left); + cout << node->key << " [" << getKey(node->left) << ", " << getKey(node->right) << "]" << endl; + printTree(node->right); +} + +bool isMinBinaryHeap(Node *&node) { + if (node == nullptr) return true; + + if (node->left != nullptr && node->left->key < node->key) return false; + if (node->right != nullptr && node->right->key < node->key) return false; + + return isMinBinaryHeap(node->left) && isMinBinaryHeap(node->right); +} + +bool isMaxBinaryHeap(Node *&node) { + if (node == nullptr) return true; + + if (node->left != nullptr && node->left->key > node->key) return false; + if (node->right != nullptr && node->right->key > node->key) return false; + + return isMaxBinaryHeap(node->left) && isMaxBinaryHeap(node->right); +} + +void checkForBinaryHeap(Node*& root) { + if (isMaxBinaryHeap(root)) cout << "Max binary heap" << endl; + else if (isMinBinaryHeap(root)) cout << "Min binary heap" << endl; + else cout << "Not a binary heap" << endl; +} + +int main() { + int value; + int length; + cout << "Enter array length: "; + cin >> length; + int* arr = new int[length]; + cout << "Enter elements: "; + cin >> value; + Node *root = new Node(value); + for (int index = 1; index < length; index++) { + cin >> value; + insert(root, value); + } + + printTree(root); + checkForBinaryHeap(root); + + return 0; +} diff --git a/Second term/Algorithms/3/5.cpp b/Second term/Algorithms/3/5.cpp new file mode 100755 index 0000000..f384442 --- /dev/null +++ b/Second term/Algorithms/3/5.cpp @@ -0,0 +1,88 @@ +#include + +using namespace std; + +class Heap { +private: + int *data; + int length; + int lastIndex; + + void heapify(int index); + void swap(int firstIndex, int secondIndex); +public: + Heap(int* array, int arrayLength); + int* getArray(); + void heapSort(); +}; + +Heap::Heap(int* array, int arrayLength) { + this->data = array; + this->length = arrayLength - 1; + this->lastIndex = arrayLength - 1; + + for (int index = arrayLength / 2 - 1; index >= 0; index--) + heapify(index); +} + +void Heap::heapify(int index) { + int largestIndex = index; + int leftIndex = 2 * index + 1; + int rightIndex = 2 * index + 2; + + if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex]) + largestIndex = leftIndex; + if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex]) + largestIndex = rightIndex; + if (largestIndex == index) + return; + + swap(index, largestIndex); + heapify(largestIndex); +} + +void Heap::swap(int firstIndex, int secondIndex) { + int tempElement = this->data[firstIndex]; + this->data[firstIndex] = this->data[secondIndex]; + this->data[secondIndex] = tempElement; +} + +int* Heap::getArray() { return this->data; } + +void Heap::heapSort() { + if (this->lastIndex == 0) return; + swap(0, this->lastIndex--); + heapify(0); + heapSort(); +} + +void pyramidalSorting(int *array, int length) { + Heap* heap = new Heap(array, length); + heap->heapSort(); + array = heap->getArray(); +} + +void printArray(int *array, int length) { + for (int index = 0; index < length; index++) + cout << array[index] << " "; + cout << endl; +} + +int main() { + int length; + cout << "Enter array length: "; + cin >> length; + + int* array = new int[length]; + cout << "Enter elements: "; + for (int index = 0; index < length; index++) + cin >> array[index]; + + printArray(array, length); + pyramidalSorting(array, length); + printArray(array, length); + + delete[] array; + + return 0; +} diff --git a/Second term/Algorithms/3/6.cpp b/Second term/Algorithms/3/6.cpp new file mode 100755 index 0000000..294c46a --- /dev/null +++ b/Second term/Algorithms/3/6.cpp @@ -0,0 +1,164 @@ +#include +#include + +using namespace std; + +struct heapnode { + int key; + string data; +}; + +class Heap { +private: + struct heapnode *data; + int length; + int lastIndex; + + void heapify(int index); + void insertFix(int index); + void swap(int firstIndex, int secondIndex); +public: + Heap(int maxHeapLength); + ~Heap(); + void print(); + struct heapnode *deleteMax(); + void insert(int priority, string name); + struct heapnode *search(int priority, string name); + void edit(struct heapnode *node, int newPriority, string newName); +}; + +Heap::Heap(int maxHeapLength) { + this->data = new struct heapnode[maxHeapLength]; + this->length = maxHeapLength; + this->lastIndex = -1; +} + +Heap::~Heap() { delete[] this->data; } + +void Heap::heapify(int index) { + int largestIndex = index; + int leftIndex = 2 * index + 1; + int rightIndex = 2 * index + 2; + + if (leftIndex <= this->lastIndex && this->data[leftIndex].key > this->data[largestIndex].key) + largestIndex = leftIndex; + if (rightIndex <= this->lastIndex && this->data[rightIndex].key > this->data[largestIndex].key) + largestIndex = rightIndex; + if (largestIndex == index) + return; + + swap(index, largestIndex); + heapify(largestIndex); +} + +void Heap::insertFix(int index) { + int parentIndex = (index - 1) / 2; + if (index <= parentIndex || this->data[parentIndex].key >= this->data[index].key) + return; + + swap(index, parentIndex); + insertFix(parentIndex); +} + +void Heap::swap(int firstIndex, int secondIndex) { + struct heapnode tempElement = this->data[firstIndex]; + this->data[firstIndex] = this->data[secondIndex]; + this->data[secondIndex] = tempElement; +} + +struct heapnode *Heap::search(int priority, string name) { + for (int index = 0; index <= this->lastIndex; index++) + if (this->data[index].data == name && this->data[index].key == priority) + return &this->data[index]; + return nullptr; +} + +struct heapnode *Heap::deleteMax() { + if (this->lastIndex == -1) return nullptr; + + this->lastIndex--; + swap(0, this->lastIndex+1); + heapify(0); + return &this->data[this->lastIndex+1]; +} + +void Heap::insert(int priority, string name) { + this->lastIndex++; + this->data[this->lastIndex].key = priority; + this->data[this->lastIndex].data = name; + insertFix(this->lastIndex); +} + +void Heap::edit(struct heapnode *node, int newPriority, string newName) { + node->data = newName; + node->key = newPriority; + heapify(0); +} + +void Heap::print() { + for (int index = 0; index <= this->lastIndex; index++) + cout << "[" << this->data[index].key << "] " << this->data[index].data << endl; +} + +int main() { + Heap* heap = new Heap(100); + struct heapnode* trash = new heapnode[100]; + struct heapnode *node; + int lastTrashIndex = -1; + string command; + string name; + int priority; + + while (true) { + cout << "> "; + cin >> command; + + if (command == "add") { + cout << "Enter task name: "; + getline(cin >> ws, name); + cout << "Enter task priority: "; + cin >> priority; + heap->insert(priority, name); + } + else if (command == "execute") { + node = heap->deleteMax(); + if (node == nullptr) { + cout << "No tasks." << endl; + continue; + } + trash[++lastTrashIndex] = *node; + cout << trash[lastTrashIndex].data << endl; + } + else if (command == "list") { + cout << "Tasks:" << endl; + heap->print(); + for (int index = 0; index <= lastTrashIndex; index++) + cout << "[" << trash[index].key << "] " << trash[index].data << " (completed)" << endl; + } + else if (command == "edit") { + cout << "Enter task name: "; + getline(cin >> ws, name); + cout << "Enter task priority: "; + cin >> priority; + + node = heap->search(priority, name); + if (node == nullptr) { + cout << "Task not found." << endl; + continue; + } + + cout << "Enter new task name: "; + getline(cin >> ws, name); + cout << "Enter new task priority: "; + cin >> priority; + heap->edit(node, priority, name); + } + else if (command == "exit") break; + } + + delete heap; + delete[] trash; + delete node; + + return 0; +} diff --git a/Second term/Algorithms/3/Makefile b/Second term/Algorithms/3/Makefile new file mode 100755 index 0000000..a33ab74 --- /dev/null +++ b/Second term/Algorithms/3/Makefile @@ -0,0 +1,5 @@ +.SILENT: +run: + g++ -o main "$(name).cpp" + ./main + rm main diff --git a/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.docx b/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.docx new file mode 100755 index 0000000..fc24ac2 Binary files /dev/null and b/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.docx differ diff --git a/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.pdf b/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.pdf new file mode 100755 index 0000000..a787ad0 Binary files /dev/null and b/Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.pdf differ diff --git a/Second term/Algorithms/5.1/1.py b/Second term/Algorithms/5.1/1.py new file mode 100755 index 0000000..d33e6e6 --- /dev/null +++ b/Second term/Algorithms/5.1/1.py @@ -0,0 +1,106 @@ +class Node(): + def __init__(self, count, data, left=None, right=None) -> None: + self.count = count + self.data = data + self.left = left + self.right = right + + +def create_coding_formats(node: Node, encoding_format: dict[str, str], decoding_format: dict[str, str], bits="") -> None: + if node is None: + return + + if node.data is not None: + encoding_format[node.data] = bits + decoding_format[bits] = node.data + + create_coding_formats(node.left, encoding_format, decoding_format, bits + "0") + create_coding_formats(node.right, encoding_format, decoding_format, bits + "1") + + +def get_unique_letters(message: str) -> list[Node]: + nodes = [] + for letter in set(message): + node = Node(message.count(letter), letter) + nodes.append(node) + + nodes.sort(key=lambda node: node.count, reverse=True) + + return nodes + + +def huffman_algorithm(nodes: list[Node]) -> tuple[dict[str, str], dict[str, str], Node]: + while len(nodes) > 1: + first_node = nodes.pop() + second_node = nodes.pop() + new_node = Node(first_node.count + second_node.count, + None, first_node, second_node) + nodes.append(new_node) + nodes.sort(key=lambda node: node.count, reverse=True) + + encoding_format = {} + decoding_format = {} + create_coding_formats(nodes[0], encoding_format, decoding_format) + + return encoding_format, decoding_format, nodes[0] + + +def encode(message: str, encoding_format: dict[str, str]) -> str: + encoded_message = "" + for letter in message: + encoded_message += encoding_format[letter] + + return encoded_message + + +def decode(encoded_message: int, decoding_format: dict[str, str]) -> str: + decoded_message = "" + bits = "" + for bit in encoded_message: + bits += bit + if decoding_format.get(bits) is not None: + decoded_message += decoding_format[bits] + bits = "" + + return decoded_message + + +def print_tree(node: Node, message: str, depth: int = 0) -> None: + if node is None: + return + + print_tree(node.right, message, depth + 1) + print(" " * depth * 5, f"{node.data or '*'} ({node.count / len(message) :.7f})", sep="") + print_tree(node.left, message, depth + 1) + + +def main() -> None: + print("Введите текст, содержащий не менее двух символов...") + + message = input() + unique_letters = get_unique_letters(message) + + print("Полученный список:") + for node in unique_letters: + print(f"{node.data} ({node.count / len(message) :.7f})", end=" ---> ") + print("\nПостроим дерево...") + + new_encoding_fromat, new_decoding_format, huffman_tree = huffman_algorithm(unique_letters) + + print_tree(huffman_tree, message) + print("---------------------------------------------") + print("Приступим к кодировке введенного текста...") + + encoded_message = encode(message, new_encoding_fromat) + + print("Код перед Вами...", encoded_message) + print(f"Коэффициент сжатия: {len(encoded_message) / (len(message) * 8) * 100 :.4f}%") + + decoded_message = decode(encoded_message, new_decoding_format) + + print("Ранее было зашифровано...", message) + print("Расшифровано...", decoded_message) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.docx b/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.docx new file mode 100755 index 0000000..2075c4b Binary files /dev/null and b/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.docx differ diff --git a/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.pdf b/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.pdf new file mode 100755 index 0000000..7644064 Binary files /dev/null and b/Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.pdf differ diff --git a/Second term/Algorithms/5/1.py b/Second term/Algorithms/5/1.py new file mode 100755 index 0000000..4ebd4ff --- /dev/null +++ b/Second term/Algorithms/5/1.py @@ -0,0 +1,34 @@ +from string import ascii_lowercase + + +def caesar_cipher(alphabet: str, key: int, message: str) -> str: + new_message = "" + for char in message: + is_upper = char.isupper() + char = char.lower() + + if char not in alphabet: + new_message += char + continue + + index_of_new_char = (alphabet.find(char) + key) % len(alphabet) + new_char = alphabet[index_of_new_char] + new_message += new_char.upper() if is_upper else new_char + + return new_message + + +def main() -> None: + input_message = input("Please enter text: ") + key = int(input("Please enter key: ")) + alphabet = ascii_lowercase + + encrypted_message = caesar_cipher(alphabet, key, input_message) + print("Encrypted message:", encrypted_message) + + decrypted_message = caesar_cipher(alphabet, -key, encrypted_message) + print("Decrypted message:", decrypted_message) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/5/2.py b/Second term/Algorithms/5/2.py new file mode 100755 index 0000000..33eec20 --- /dev/null +++ b/Second term/Algorithms/5/2.py @@ -0,0 +1,48 @@ +from operator import itemgetter + + +def caesar_cipher(alphabet: str, key: int, message: str) -> str: + new_message = "" + for char in message: + is_upper = char.isupper() + char = char.lower() + + if char not in alphabet: + new_message += char + continue + + index_of_new_char = (alphabet.find(char) + key) % len(alphabet) + new_char = alphabet[index_of_new_char] + new_message += new_char.upper() if is_upper else new_char + + return new_message + + +def hack(alphabet: str, delta: dict[str, float], message: str) -> int: + delta_arr = [] + for key in delta.keys(): + for char in alphabet: + shift = abs(alphabet.find(key) - alphabet.find(char)) + delta_arr.append((abs(delta[key] - message.count(char) / len(message)), shift)) + + return min(delta_arr, key=itemgetter(0))[1] + + +def main() -> None: + encrypted_message = "Елжзо фср, дцжхс Лсфлч Гознфзлъ е псзп жспз флжлх, л в угж съзря л йзогб зёс цёсфхлхя. Дцжхс в ф тсфхсусррлпл рзцпсоърс дсохгб л ежуцё ефтспрло, ъхс ахс зпц рз псйзх ругелхяфв, л йзогб н рзпц тулдолклхяфв л зёс сдрвхя. Рс хсоянс ъхс тулдолклофв, елйц, ъхс олщс зёс тузсдугклосфя, фхгос псосжсз, л ср прз хлшс, хлшс ъхс-хс ёсесулх лк цъзряв сужзрг, хгн хлшс, ъхс в рз псёц угффоюыгхя. Тсхсп дцжхс еюыол пю ефз лк нспргхю, л ъхс-хс хцх фоцълосфя пцжузрсз. Пю флжзол лол озйгол рг тсоц. Ср прз ъхс-хс ёсесуло. Г прз дцжхс кгшсхзосфя тснгкгхя зпц фесб ъцефхелхзоярсфхя, л в, рз ефоцылегвфя е зёс узъл, фхго фздз ессдугйгхя фсфхсврлз фесзёс ерцхузррзёс ъзосезнг л сфзрлеыцб пзрв плосфхя Дсйлб. Л тсвелолфя ц пзрв фозкю рг ёогкгш, л в дюо жсесозр, ъхс ср ахс тулпзхло. Рс ср екёоврцо рг пзрв ф жсфгжсм л ефнсъло, тузфзныл фесм угкёсесу. В сусдзо л фтусфло, рз нс прз ол фнгкгррсз схрсфлосфя; рс ср рлъзёс рз схезъго, тснгкго прз огфнсеюм елж, л тсфоз ежуцё съцхлолфя пю е фтгоярз псзм, ёжз фхслх жесмргв нусегхя. Ср озё рг рзз рг нугм, л в, дцжхс тюогв н рзпц йзогрлзп огфнгхяфв, тулозё хцх йз. Л ср дцжхс ц пзрв фтугылегзх: „Фнгйлхз тс тугежз, нгнсз ею лпззхз ёогерсз тулфхугфхлз? Цкргол ол ею зёс? В жцпгб, ъхс ею цйз зёс цкргол“. В, фпцхлеылфя флп естусфсп, схезъго, ъхс озря псз ёогерсз тулфхугфхлз. Ср рзжсезуълес тснгъго ёсосесм. Л в, зьз дсозз фпцхлеылфя, схезъго, ъхс в шсхв л йлец ф йзрсб, тс зёс фсезхц, рс рз нгн пцй йзрю фесзм. Рг ахс ср ескугкло, ъхс рз жсойрс йзрц олыгхя фесзм огфнл, жго ъцефхесегхя, ъхс е ахсп дюог псв сдвкгррсфхя. Рс в схезъго, ъхс в фхюйцфя ахсёс; л ежуцё ефз фснуюосфя. Л в тусфрцофв л ргызо е пюфовш феслш хзнфх фе. Тлфгрлв: Йлесх дз фезх ъзосезнсп, г фезх ес хяпз фезхлх л хяпг зёс рз сдэвх. Олщс ц Лсфлчг Гознфззелъг дюос псосйгесз л фезхосз. Е ахсх жзря тсоцъло тлфяпс сх догёсжзхзов, е нсхсусп ср тлызх сд сдвкгррсфхл фцтуцйзфхег»." + alphabet = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя" + delta = { + "о": 0.10983, + "е": 0.08483, + "а": 0.07998, + } + + key = hack(alphabet, delta, encrypted_message) + print("Key:", key) + + decrypted_message = caesar_cipher(alphabet, -key, encrypted_message) + print("Decrypted message:", decrypted_message) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/5/3.py b/Second term/Algorithms/5/3.py new file mode 100755 index 0000000..48cca8a --- /dev/null +++ b/Second term/Algorithms/5/3.py @@ -0,0 +1,33 @@ +from string import ascii_lowercase + + +def substitution_cipher(alphabet: str, replacement_alphabet: str, message: str) -> str: + new_message = "" + for char in message: + is_upper = char.isupper() + char = char.lower() + + if char not in alphabet: + new_message += char + continue + + new_char = replacement_alphabet[alphabet.find(char)] + new_message += new_char.upper() if is_upper else new_char + + return new_message + + +def main() -> None: + input_message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit." + alphabet = ascii_lowercase + replacement_alphabet = "goydsipeluavcrjwxznhbqftmk" + + encrypted_message = substitution_cipher(alphabet, replacement_alphabet, input_message) + print("Encrypted message:", encrypted_message) + + decrypted_message = substitution_cipher(replacement_alphabet, alphabet, encrypted_message) + print("Decrypted message:", decrypted_message) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/5/4.py b/Second term/Algorithms/5/4.py new file mode 100755 index 0000000..eff0420 --- /dev/null +++ b/Second term/Algorithms/5/4.py @@ -0,0 +1,103 @@ +class Gost(object): + def __init__(self, key, sbox): + self._key = 0 + self._subkeys = None + self.key = key + self.sbox = sbox + + @property + def key(self) -> int: + return self._key + + @key.setter + def key(self, key: str) -> None: + assert len(key) <= 32 + + encoded_key = key.encode("ascii") + for index in range(31, -1, -1): + self._key |= encoded_key[index] << (index * 8) + + self._subkeys = [(self._key >> (32 * index)) & 0xFFFFFFFF for index in range(8)] + + def _function(self, part: int, key: int) -> int: + part = (part + key) % (1 << 32) + temp = 0 + for index in range(8): + temp |= ((self.sbox[index][(part >> (4 * index)) & 0b1111]) << (4 * index)) + + return ((temp >> 11) | (temp << 21)) & 0xFFFFFFFF + + def encrypt_part(self, message_part: int) -> int: + left = message_part >> 32 + right = message_part & 0xFFFFFFFF + + for index in range(24): + left, right = right, left ^ self._function(right, self._subkeys[index % 8]) + + for index in range(8): + left, right = right, left ^ self._function(right, self._subkeys[7 - index]) + + return (left << 32) | right + + def decrypt_part(self, crypted_message_part: int) -> int: + left = crypted_message_part >> 32 + right = crypted_message_part & 0xFFFFFFFF + + for index in range(8): + left, right = right ^ self._function(left, self._subkeys[index]), left + + for index in range(24): + left, right = right ^ self._function(left, self._subkeys[(7 - index) % 8]), left + + return (left << 32) | right + + def encrypt(self, message: str) -> int: + encoded_message = message.encode("ascii") + + encrypted_message = 0 + for part_index in range(len(message) // 8 + 1 * (len(message) % 8 != 0)): + binary_part = 0 + for letter_index in range(8): + letter = 0x0000 + if (letter_index + part_index * 8 < len(message)): + letter = encoded_message[letter_index + part_index * 8] + binary_part = (binary_part << 8) | letter + encrypted_message = (encrypted_message << 64) | self.encrypt_part(binary_part) + + return encrypted_message + + def decrypt(self, encrypted_message: int) -> str: + decrypted_message = "" + for index in range(len(bin(encrypted_message)[2:]) // 64, -1, -1): + binary_part = (encrypted_message >> (64 * index)) & 0xFFFFFFFFFFFFFFFF + decrypted_binary_part = self.decrypt_part(binary_part) + for letter_index in range(8): + decrypted_message += chr((decrypted_binary_part >> ((7 - letter_index) * 8)) & 0xFF) + + return decrypted_message + + +def main(): + sbox = [ + [0x4, 0xA, 0x9, 0x2, 0xD, 0x8, 0x0, 0xE, 0x6, 0xB, 0x1, 0xC, 0x7, 0xF, 0x5, 0x3], + [0xE, 0xB, 0x4, 0xC, 0x6, 0xD, 0xF, 0xA, 0x2, 0x3, 0x8, 0x1, 0x0, 0x7, 0x5, 0x9], + [0x5, 0x8, 0x1, 0xD, 0xA, 0x3, 0x4, 0x2, 0xE, 0xF, 0xC, 0x7, 0x6, 0x0, 0x9, 0xB], + [0x7, 0xD, 0xA, 0x1, 0x0, 0x8, 0x9, 0xF, 0xE, 0x4, 0x6, 0xC, 0xB, 0x2, 0x5, 0x3], + [0x6, 0xC, 0x7, 0x1, 0x5, 0xF, 0xD, 0x8, 0x4, 0xA, 0x9, 0xE, 0x0, 0x3, 0xB, 0x2], + [0x4, 0xB, 0xA, 0x0, 0x7, 0x2, 0x1, 0xD, 0x3, 0x6, 0x8, 0x5, 0x9, 0xC, 0xF, 0xE], + [0xD, 0xB, 0x4, 0x1, 0x3, 0xF, 0x5, 0x9, 0x0, 0xA, 0xE, 0x7, 0x6, 0x8, 0x2, 0xC], + [0x1, 0xF, 0xD, 0x0, 0x5, 0x7, 0xA, 0x4, 0x9, 0x2, 0x3, 0xE, 0x6, 0xB, 0x8, 0xC] + ] + message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit." + key = "zqHqtbGwB41OOsm5EeGmG0VKeJWrnhML" + + gost = Gost(key, sbox) + crypted_message = gost.encrypt(message) + encrypted_message = gost.decrypt(crypted_message) + + print("Original message: ", message) + print("Crypted: ", crypted_message) + print("Encrypted message: ", encrypted_message) + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.docx b/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.docx new file mode 100755 index 0000000..dc8cd0f Binary files /dev/null and b/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.docx differ diff --git a/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.pdf b/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.pdf new file mode 100755 index 0000000..fe47d1d Binary files /dev/null and b/Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.pdf differ diff --git a/Second term/Algorithms/6/1.py b/Second term/Algorithms/6/1.py new file mode 100755 index 0000000..6b5ea54 --- /dev/null +++ b/Second term/Algorithms/6/1.py @@ -0,0 +1,47 @@ +from random import randint + + +def main() -> None: + inf = float("inf") + names = [ + "Пр-т Вернадского, 78", + "Пр-т Вернадского, 86", + "Стромынка, 20", + "Малая Пироговская, 1", + "5-я улица Соколиной горы, 22", + "Усачева, 7" + ] + graph = [ + [inf, 1.97, 21.6, 10.7, 22.3, 10.4], + [1.97, inf, 22.3, 11.4, 23, 11.1], + [21.6, 22.3, inf, 11.5, 5.2, 12], + [10.7, 1.4, 11.5, inf, 13.4, 0.68], + [22.3, 23, 5.2, 13.4, inf, 13.8], + [10.4, 11.1, 12, 0.68, 13.8, inf] + ] + + node = randint(0, 5) + indexes = [node] + edges = [] + + while len(indexes) < len(graph): + new_edge = (indexes[0], indexes[0]) + for node in indexes: + for new_node in range(len(graph)): + if new_node in indexes: + continue + + if graph[node][new_node] < graph[new_edge[0]][new_edge[1]]: + new_edge = (node, new_node) + + edges.append(new_edge) + indexes.append(new_edge[1]) + + for edge in edges: + print(f"{names[edge[0]] :>28} --> {names[edge[1]]}") + + print("Length:", sum([graph[edge[1]][edge[0]] for edge in edges])) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/6/2-1.py b/Second term/Algorithms/6/2-1.py new file mode 100755 index 0000000..0f97190 --- /dev/null +++ b/Second term/Algorithms/6/2-1.py @@ -0,0 +1,32 @@ +def remover(nodes: list[int], graph: list[list[int]], pnode: int) -> None: + for node in nodes: + if graph[pnode][node]: + nodes.remove(node) + remover(nodes, graph, node) + + +def main() -> None: + graph = [ + [0, 0, 0, 0, 0, 1, 0, 1], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 0, 1], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 0, 0], + [1, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 1, 0, 0, 0, 0, 0] + ] + + nodes = [0, 1, 2, 3, 4, 5, 6, 7] + count = 0 + while len(nodes) != 0: + count += 1 + index = nodes[0] + nodes.remove(index) + remover(nodes, graph, index) + + print("Connectivity score:", count) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/6/2-2.py b/Second term/Algorithms/6/2-2.py new file mode 100755 index 0000000..57b78ff --- /dev/null +++ b/Second term/Algorithms/6/2-2.py @@ -0,0 +1,32 @@ +def remover(nodes: list[int], graph: list[list[int]], pnode: int) -> None: + for node in range(len(graph[pnode])): + if node in nodes and graph[pnode][node]: + nodes.remove(node) + remover(nodes, graph, node) + + +def main() -> None: + graph = [ + [1, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 1], + [0, 0, 0, 0, 1, 1], + [1, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0], + ] + + nodes = [0, 1, 2, 3, 4, 5, 6, 7] + count = 0 + while len(nodes) != 0: + count += 1 + index = nodes[0] + nodes.remove(index) + remover(nodes, graph, index) + + print("Connectivity score:", count) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/6/3.py b/Second term/Algorithms/6/3.py new file mode 100755 index 0000000..142965d --- /dev/null +++ b/Second term/Algorithms/6/3.py @@ -0,0 +1,39 @@ +from random import randint + + +def main() -> None: + inf = float("inf") + graph = [ + [inf, 44, 46, 32, inf, 37], + [44, inf, 45, inf, 30, inf], + [46, 45, inf, inf, inf, 15], + [32, inf, inf, inf, 17, 22], + [inf, 30, inf, 17, inf, inf], + [37, inf, 15, 22, inf, inf], + ] + + index = randint(0, len(graph)-1) + indexes = [index] + while len(indexes) < len(graph): + min_val_index = indexes[-1] + for index in range(len(graph)): + if index in indexes: + continue + + if graph[indexes[-1]][index] <= graph[indexes[-1]][min_val_index]: + min_val_index = index + + indexes.append(min_val_index) + indexes.append(indexes[0]) + length = 0 + for index in range(1, len(indexes)): + length += graph[indexes[index-1]][indexes[index]] + print(f" {graph[indexes[index-1]][indexes[index]] :^5}", end="") + + print() + print(" --> ".join(map(str, indexes))) + print("Length:", length) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/6/4.py b/Second term/Algorithms/6/4.py new file mode 100755 index 0000000..50a255b --- /dev/null +++ b/Second term/Algorithms/6/4.py @@ -0,0 +1,113 @@ +class Graph: + def __init__(self) -> None: + self.graph = [] + + def add_edge(self, first_index: int, second_index: int, length: int) -> None: + if len(self.graph) <= first_index and len(self.graph) <= second_index: + return + + self.graph[first_index][second_index] = length + self.graph[second_index][first_index] = length + + def remove_edge(self, first_index: int, second_index: int) -> None: + self.add_edge(first_index, second_index, 0) + + def print_matrix(self) -> None: + node_count = len(self.graph) + if node_count == 0: + return + + print(" |", *range(node_count)) + print("--+" + "--" * node_count) + for index in range(node_count): + print(index, "|", *self.graph[index]) + + def print_list(self) -> None: + for first_index in range(len(self.graph)): + edges = self.graph[first_index] + print(f"{first_index :>2}: ", end="") + for second_index in range(len(edges)): + if edges[second_index]: + print(f"{second_index} ({edges[second_index]}) ", end="") + print() + + def create_empty_graph(self, node_count: int) -> None: + self.graph = [[0 for _ in range(node_count)] for _ in range(node_count)] + + def save(self) -> None: + if len(self.graph) == 0: + return + + with open("graph.txt", "w") as file: + file.write(f"{len(self.graph)}\n") + for index in range(len(self.graph)): + file.write(" ".join(map(str, self.graph[index])) + "\n") + file.close() + + def first_import_type(self, file_name: str) -> None: + with open(file_name, "r") as file: + node_count = int(file.readline()) + self.create_empty_graph(node_count) + while True: + line = file.readline().split() + if len(line) < 2: + break + + for second_index in line[1:]: + self.add_edge(int(line[0]), int(second_index), 1) + file.close() + + def second_import_type(self, file_name: str) -> None: + with open(file_name, "r") as file: + node_count = int(file.readline()) + self.create_empty_graph(node_count) + while True: + line = file.readline().split() + if len(line) != 3: + break + + self.add_edge(int(line[0]), int(line[1]), int(line[2])) + file.close() + + def third_import_type(self, file_name: str) -> None: + with open(file_name, "r") as file: + node_count = int(file.readline()) + self.create_empty_graph(node_count) + for first_index in range(node_count): + line = file.readline().split() + for second_index in range(node_count): + self.add_edge(first_index, second_index, int(line[second_index])) + file.close() + + +def main() -> None: + g = Graph() + print("Import of the first graph type (А)") + g.first_import_type("first_type_graph.txt") + g.print_matrix() + + print("Import of the second graph type (Б)") + g.second_import_type("second_type_graph.txt") + g.print_matrix() + + print("Import of the third graph type (В)") + g.third_import_type("third_type_graph.txt") + g.print_matrix() + + print("Print the graph as a list") + g.print_list() + + print("Adding a new edge 1-2 with length 6") + g.add_edge(1, 2, 6) + g.print_matrix() + + print("Removing the edge 3-4") + g.remove_edge(3, 4) + g.print_matrix() + + print("Saving a new graph") + g.save() + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/6/Алгоритмы - Рабочая тетрадь 6.docx b/Second term/Algorithms/6/Алгоритмы - Рабочая тетрадь 6.docx new file mode 100755 index 0000000..e8dc13e Binary files /dev/null and b/Second term/Algorithms/6/Алгоритмы - Рабочая тетрадь 6.docx differ diff --git a/Second term/Algorithms/6/Практические занятия Алгоритмы - Рабочая тетрадь 6.pdf b/Second term/Algorithms/6/Практические занятия Алгоритмы - Рабочая тетрадь 6.pdf new file mode 100755 index 0000000..05b5b8d Binary files /dev/null and b/Second term/Algorithms/6/Практические занятия Алгоритмы - Рабочая тетрадь 6.pdf differ diff --git a/Second term/Algorithms/7/1.py b/Second term/Algorithms/7/1.py new file mode 100755 index 0000000..03b2bd8 --- /dev/null +++ b/Second term/Algorithms/7/1.py @@ -0,0 +1,39 @@ +def main() -> None: + inf = float("inf") + graph = [ + [ 0, 7, inf, inf, 4, inf], + [ 7, 0, 5, inf, inf, 2], + [inf, 5, 0, 11, inf, 6], + [inf, inf, 11, 0, 8, 9], + [ 4, inf, inf, 8, 0, 3], + [inf, 2, 6, 9, 3, 0], + ] + + start_node = 0 + + dist = graph[start_node].copy() + queue = list(range(len(dist))) + routes = [[] if dist[index] == inf else [start_node] for index in range(len(dist))] + while len(queue) > 0: + min_index = queue[0] + for node in queue: + if dist[node] < dist[min_index]: + min_index = node + queue.remove(min_index) + + for node in queue: + new_dist = dist[min_index] + graph[min_index][node] + if dist[node] > new_dist: + dist[node] = new_dist + routes[node] = routes[min_index] + [min_index] + + for index in range(len(routes)): + if index == start_node: + continue + + print(f"{start_node} --> {index} ({dist[index] :>2}):", end=" ") + print(" --> ".join(map(str, routes[index] + [index]))) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/7/2.py b/Second term/Algorithms/7/2.py new file mode 100755 index 0000000..0cf9e0e --- /dev/null +++ b/Second term/Algorithms/7/2.py @@ -0,0 +1,58 @@ +def dijkstra(graph: list[list[int]], start_node: int, end_node: int) -> list[int]: + dist = graph[start_node].copy() + queue = list(range(len(dist))) + routes = [[] if dist[index] == float("inf") else [start_node] for index in range(len(dist))] + while len(queue) > 0: + min_index = queue[0] + for node in queue: + if dist[node] < dist[min_index]: + min_index = node + queue.remove(min_index) + + for node in queue: + new_dist = dist[min_index] + graph[min_index][node] + if dist[node] > new_dist: + dist[node] = new_dist + routes[node] = routes[min_index] + [min_index] + + return routes[end_node] + [end_node] + + +def main() -> None: + inf = float("inf") + graph = [ + [ 0, 7, 4, inf, inf, inf], + [inf, 0, 4, inf, 2, inf], + [inf, inf, 0, 4, 8, inf], + [inf, inf, inf, 0, inf, 12], + [inf, inf, inf, 4, 0, 5], + [inf, inf, inf, inf, inf, 0] + ] + + start_node = 0 + end_node = 5 + + flow_sum = 0 + while True: + min_flow = inf + route = dijkstra(graph, start_node, end_node) + if len(route) == 1: + break + + for index in range(len(route)-1): + min_flow = min(min_flow, graph[route[index]][route[index+1]]) + + flow_sum += min_flow + + for index in range(len(route)-1): + graph[route[index]][route[index+1]] -= min_flow + graph[route[index+1]][route[index]] = min_flow + + if graph[route[index]][route[index+1]] == 0: + graph[route[index]][route[index+1]] = inf + + print("Sum:",flow_sum) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/7/Алгоритмы - Рабочая тетрадь 7.pdf b/Second term/Algorithms/7/Алгоритмы - Рабочая тетрадь 7.pdf new file mode 100755 index 0000000..7164411 Binary files /dev/null and b/Second term/Algorithms/7/Алгоритмы - Рабочая тетрадь 7.pdf differ diff --git a/Second term/Algorithms/8/1.py b/Second term/Algorithms/8/1.py new file mode 100755 index 0000000..11c5f0a --- /dev/null +++ b/Second term/Algorithms/8/1.py @@ -0,0 +1,14 @@ +def gcd_extended(a: int, b: int) -> tuple[int, int, int]: + if b == 0: + return a, 1, 0 + + gcd, x, y = gcd_extended(b, a % b) + return gcd, y, x - (a // b) * y + + +def main() -> None: + print(gcd_extended(240, 46)) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/8/2.py b/Second term/Algorithms/8/2.py new file mode 100755 index 0000000..11f3cf1 --- /dev/null +++ b/Second term/Algorithms/8/2.py @@ -0,0 +1,96 @@ +from random import choice + + +def gcd(a: int, b: int) -> int: + if b == 0: + return a + + return gcd(b, a % b) + + +def gcd_extended(a: int, b: int) -> tuple[int, int, int]: + if b == 0: + return a, 1, 0 + + gcd, x, y = gcd_extended(b, a % b) + return gcd, y, x - (a // b) * y + + +def mod_inverse(n: int, x: int) -> int: + inv_x = gcd_extended(n, x)[2] + if inv_x <= 0: + inv_x += n + return inv_x + + +def mod_extended(x: int, y: int, n: int) -> int: + if y == 0: + return 1 + + z = mod_extended(x, y // 2, n) + + if y % 2 == 0: + return (z * z) % n + + return (x * z * z) % n + + +def generate_keys(p: int, q: int) -> tuple[tuple[int, int], tuple[int, int]]: + n = p * q + phi = (p - 1) * (q - 1) + + e = 3 + for ferm_number in [5, 17, 257, 65537]: + if ferm_number < phi: + e = ferm_number + + d = mod_inverse(phi, e) + + return (e, n), (d, n) + + +def encrypt(message: str, key: tuple[int, int]): + e, n = key + encrypted_message = [mod_extended(ord(char), e, n) for char in message] + return encrypted_message + + +def decrypt(encrypted_message: str, key: tuple[int, int]): + d, n = key + decrypted_message = [chr(mod_extended(char, d, n)) + for char in encrypted_message] + return "".join(decrypted_message) + + +def get_primes(n: int): + sieve = [True] * n + primes = [] + for p in range(2, n): + if sieve[p]: + primes.append(p) + for i in range(p * p, n, p): + sieve[i] = False + return primes + + +def main() -> None: + primes = get_primes(100000) + p = choice(primes) + q = choice(primes) + while p == q: + q = choice(primes) + + message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit." + public, private = generate_keys(p, q) + encrypted_message = encrypt(message, public) + decrypted_message = decrypt(encrypted_message, private) + + print("Public key: ", public) + print("Private key:", private) + print("Original message: ", message) + print("Encrypted message:", "".join(map(str, encrypted_message))) + print("Decrypted message:", decrypted_message) + + +if __name__ == "__main__": + main() diff --git a/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь 8.pdf b/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь 8.pdf new file mode 100755 index 0000000..ce3b161 Binary files /dev/null and b/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь 8.pdf differ diff --git a/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь7.docx b/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь7.docx new file mode 100755 index 0000000..730a1bd Binary files /dev/null and b/Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь7.docx differ diff --git a/Second term/Algorithms/README.md b/Second term/Algorithms/README.md new file mode 100755 index 0000000..9aeef09 --- /dev/null +++ b/Second term/Algorithms/README.md @@ -0,0 +1,15 @@ +# Algorithms + +number | name | grade +:----: | ----------------------------------------------------------------------------------- | :---: +1 | Двоичное дерево поиска | ✅ +1.1 | Дерево отрезков | ✅ +2 | Сбалансированные двоичные деревья поиска | ✅ +3 | Двоичная куча. Очередь с приоритетом. Пирамидальная сортировка. | ✅ +5 | Основы криптографических алгоритмов | ✅ +5.1 | Дерево Хаффмана | ✅ +6 | Основы теории графов | ✅ +7 | Алгоритмы на графах (Удален из программы) | ❓ +8 | Шифрование с открытым ключом. Расширенный алгоритм Евклида. Алгоритм шифрования RSA | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Second term/Algorithms/exam/img/Расход_памяти_КЧ.png b/Second term/Algorithms/exam/img/Расход_памяти_КЧ.png new file mode 100755 index 0000000..1fd7e3a Binary files /dev/null and b/Second term/Algorithms/exam/img/Расход_памяти_КЧ.png differ diff --git a/Second term/Algorithms/exam/img/Решение_уравнения_методом_хорд.png b/Second term/Algorithms/exam/img/Решение_уравнения_методом_хорд.png new file mode 100755 index 0000000..c6d6edc Binary files /dev/null and b/Second term/Algorithms/exam/img/Решение_уравнения_методом_хорд.png differ diff --git a/Second term/Algorithms/exam/img/Числа_Мерсенна._Тест_Люка-Лемера.png b/Second term/Algorithms/exam/img/Числа_Мерсенна._Тест_Люка-Лемера.png new file mode 100755 index 0000000..9f8a9d6 Binary files /dev/null and b/Second term/Algorithms/exam/img/Числа_Мерсенна._Тест_Люка-Лемера.png differ diff --git a/Second term/Algorithms/exam/img/алгоритм_RSA_1.png b/Second term/Algorithms/exam/img/алгоритм_RSA_1.png new file mode 100755 index 0000000..dba7d19 Binary files /dev/null and b/Second term/Algorithms/exam/img/алгоритм_RSA_1.png differ diff --git a/Second term/Algorithms/exam/img/алгоритм_RSA_2.png b/Second term/Algorithms/exam/img/алгоритм_RSA_2.png new file mode 100755 index 0000000..e518c1b Binary files /dev/null and b/Second term/Algorithms/exam/img/алгоритм_RSA_2.png differ diff --git a/Second term/Algorithms/exam/img/алгоритм_Прима.png b/Second term/Algorithms/exam/img/алгоритм_Прима.png new file mode 100755 index 0000000..2b480c7 Binary files /dev/null and b/Second term/Algorithms/exam/img/алгоритм_Прима.png differ diff --git a/Second term/Algorithms/exam/img/алгоритм_быстрого_возведения_в_степень.png b/Second term/Algorithms/exam/img/алгоритм_быстрого_возведения_в_степень.png new file mode 100755 index 0000000..6baabb8 Binary files /dev/null and b/Second term/Algorithms/exam/img/алгоритм_быстрого_возведения_в_степень.png differ diff --git a/Second term/Algorithms/exam/img/алгоритм_ферма.png b/Second term/Algorithms/exam/img/алгоритм_ферма.png new file mode 100755 index 0000000..c7f6987 Binary files /dev/null and b/Second term/Algorithms/exam/img/алгоритм_ферма.png differ diff --git a/Second term/Algorithms/exam/img/быстрая_сортировка.png b/Second term/Algorithms/exam/img/быстрая_сортировка.png new file mode 100755 index 0000000..52d863b Binary files /dev/null and b/Second term/Algorithms/exam/img/быстрая_сортировка.png differ diff --git a/Second term/Algorithms/exam/img/евклид.png b/Second term/Algorithms/exam/img/евклид.png new file mode 100755 index 0000000..0d46ac4 Binary files /dev/null and b/Second term/Algorithms/exam/img/евклид.png differ diff --git a/Second term/Algorithms/exam/img/карта.png b/Second term/Algorithms/exam/img/карта.png new file mode 100755 index 0000000..1937148 Binary files /dev/null and b/Second term/Algorithms/exam/img/карта.png differ diff --git a/Second term/Algorithms/exam/img/матрица_инцедентности.png b/Second term/Algorithms/exam/img/матрица_инцедентности.png new file mode 100755 index 0000000..080fc39 Binary files /dev/null and b/Second term/Algorithms/exam/img/матрица_инцедентности.png differ diff --git a/Second term/Algorithms/exam/img/матрица_смежности.png b/Second term/Algorithms/exam/img/матрица_смежности.png new file mode 100755 index 0000000..ca14f22 Binary files /dev/null and b/Second term/Algorithms/exam/img/матрица_смежности.png differ diff --git a/Second term/Algorithms/exam/img/метод_Карацубы.png b/Second term/Algorithms/exam/img/метод_Карацубы.png new file mode 100755 index 0000000..f487d2f Binary files /dev/null and b/Second term/Algorithms/exam/img/метод_Карацубы.png differ diff --git a/Second term/Algorithms/exam/img/метод_касательных.png b/Second term/Algorithms/exam/img/метод_касательных.png new file mode 100755 index 0000000..d52543f Binary files /dev/null and b/Second term/Algorithms/exam/img/метод_касательных.png differ diff --git a/Second term/Algorithms/exam/img/метод_половинного_деления.png b/Second term/Algorithms/exam/img/метод_половинного_деления.png new file mode 100755 index 0000000..f31eab4 Binary files /dev/null and b/Second term/Algorithms/exam/img/метод_половинного_деления.png differ diff --git a/Second term/Algorithms/exam/img/очередь.png b/Second term/Algorithms/exam/img/очередь.png new file mode 100755 index 0000000..b5c5026 Binary files /dev/null and b/Second term/Algorithms/exam/img/очередь.png differ diff --git a/Second term/Algorithms/exam/img/префиксное_дерево.png b/Second term/Algorithms/exam/img/префиксное_дерево.png new file mode 100755 index 0000000..1d81f85 Binary files /dev/null and b/Second term/Algorithms/exam/img/префиксное_дерево.png differ diff --git a/Second term/Algorithms/exam/img/пример_двоичной_кучи.png b/Second term/Algorithms/exam/img/пример_двоичной_кучи.png new file mode 100755 index 0000000..4f19ec8 Binary files /dev/null and b/Second term/Algorithms/exam/img/пример_двоичной_кучи.png differ diff --git a/Second term/Algorithms/exam/img/пример_евклида.png b/Second term/Algorithms/exam/img/пример_евклида.png new file mode 100755 index 0000000..1283bd3 Binary files /dev/null and b/Second term/Algorithms/exam/img/пример_евклида.png differ diff --git a/Second term/Algorithms/exam/img/пример_кч_дерева.png b/Second term/Algorithms/exam/img/пример_кч_дерева.png new file mode 100755 index 0000000..eed3c74 Binary files /dev/null and b/Second term/Algorithms/exam/img/пример_кч_дерева.png differ diff --git a/Second term/Algorithms/exam/img/расход_памяти_АВЛ.png b/Second term/Algorithms/exam/img/расход_памяти_АВЛ.png new file mode 100755 index 0000000..111c44c Binary files /dev/null and b/Second term/Algorithms/exam/img/расход_памяти_АВЛ.png differ diff --git a/Second term/Algorithms/exam/img/расход_памяти_Сплай.png b/Second term/Algorithms/exam/img/расход_памяти_Сплай.png new file mode 100755 index 0000000..068b269 Binary files /dev/null and b/Second term/Algorithms/exam/img/расход_памяти_Сплай.png differ diff --git a/Second term/Algorithms/exam/img/расширенный_алгоритм_Евклида.png b/Second term/Algorithms/exam/img/расширенный_алгоритм_Евклида.png new file mode 100755 index 0000000..f4bf9b7 Binary files /dev/null and b/Second term/Algorithms/exam/img/расширенный_алгоритм_Евклида.png differ diff --git a/Second term/Algorithms/exam/img/решето_Эратосфена.png b/Second term/Algorithms/exam/img/решето_Эратосфена.png new file mode 100755 index 0000000..b9aa22b Binary files /dev/null and b/Second term/Algorithms/exam/img/решето_Эратосфена.png differ diff --git a/Second term/Algorithms/exam/img/связанные_списки.png b/Second term/Algorithms/exam/img/связанные_списки.png new file mode 100755 index 0000000..445fe60 Binary files /dev/null and b/Second term/Algorithms/exam/img/связанные_списки.png differ diff --git a/Second term/Algorithms/exam/img/сортировка_вставками_пример.png b/Second term/Algorithms/exam/img/сортировка_вставками_пример.png new file mode 100755 index 0000000..abb0ce5 Binary files /dev/null and b/Second term/Algorithms/exam/img/сортировка_вставками_пример.png differ diff --git a/Second term/Algorithms/exam/img/стек.png b/Second term/Algorithms/exam/img/стек.png new file mode 100755 index 0000000..a3969d6 Binary files /dev/null and b/Second term/Algorithms/exam/img/стек.png differ diff --git a/Second term/Algorithms/exam/img/тест_мерсена.png b/Second term/Algorithms/exam/img/тест_мерсена.png new file mode 100755 index 0000000..fe49f72 Binary files /dev/null and b/Second term/Algorithms/exam/img/тест_мерсена.png differ diff --git a/Second term/Algorithms/exam/img/формула_метод_хорд.png b/Second term/Algorithms/exam/img/формула_метод_хорд.png new file mode 100755 index 0000000..96df9d8 Binary files /dev/null and b/Second term/Algorithms/exam/img/формула_метод_хорд.png differ diff --git a/Second term/Algorithms/exam/img/число_связанности.png b/Second term/Algorithms/exam/img/число_связанности.png new file mode 100755 index 0000000..82db2b7 Binary files /dev/null and b/Second term/Algorithms/exam/img/число_связанности.png differ diff --git a/Second term/Algorithms/exam/questions-gpt-version.md b/Second term/Algorithms/exam/questions-gpt-version.md new file mode 100755 index 0000000..c64f18e --- /dev/null +++ b/Second term/Algorithms/exam/questions-gpt-version.md @@ -0,0 +1,1280 @@ +# Вопросы из СДО + +## 1 Понятие алгоритма + +### Краткий ответ + +Алгоритм – это последовательность шагов, предназначенная для решения конкретной задачи или достижения цели. + +### Развернутый ответ + +Алгоритм – это чётко определённый и конечный набор инструкций, которые описывают порядок действий для выполнения определённой задачи. Алгоритмы широко применяются в математике, компьютерных науках и различных областях инженерии. Они могут быть выражены на естественном языке, через блок-схемы, псевдокод или в виде программного кода. Основные характеристики алгоритмов включают конечность, детерминированность, понятность и эффективность. + +## 2 Основные свойства алгоритма + +* Дискретность: Алгоритм состоит из отдельных шагов. +* Понятность: Каждый шаг должен быть понятен исполнителю (компьютеру). +* Определённость: Результат каждого шага однозначно определяется. +* Результативность: Алгоритм должен приводить к результату за конечное число шагов. +* Массовость: Алгоритм должен быть применим для решения целого класса задач. + +## 3 Способы описания алгоритма + +* Словесный: Обычный текст, как рецепт. +* Графический: Блок-схемы, где каждый блок - это действие. +* Программный: На языке программирования, понятном компьютеру. + +## 4 Линейные алгоритмы + +### Краткий ответ + +Линейные алгоритмы выполняются последовательно, шаг за шагом, без ветвлений и циклов. + +### Развернутый ответ + +Линейные алгоритмы представляют собой последовательность шагов, которые выполняются один за другим в строго определённом порядке. В таких алгоритмах отсутствуют условия (ветвления) и циклы (повторения шагов), что делает их выполнение прямолинейным и предсказуемым. Каждый шаг выполняется точно один раз, и после его завершения алгоритм переходит к следующему шагу. + +Примеры линейных алгоритмов включают: + +* Вычисление суммы двух чисел. +* Последовательное выполнение нескольких арифметических операций. + +Линейные алгоритмы просты в реализации и анализе, но их область применения ограничена задачами, которые можно решить без необходимости повторения шагов или проверки условий. + +### Пример + +```python +a = (2 + 5) * 3 +print(a) +``` + +## 5 Ветвящиеся алгоритмы + +### Краткий ответ + +Ветвящиеся алгоритмы включают условия, по которым выполнение алгоритма может пойти по разным путям. + +### Развернутый ответ + +Ветвящиеся алгоритмы содержат условия (логические выражения), в зависимости от выполнения которых выбирается один из нескольких возможных путей дальнейшего выполнения. Такие алгоритмы позволяют принимать решения в процессе выполнения, что делает их более гибкими и способными обрабатывать более сложные задачи по сравнению с линейными алгоритмами. + +Основные элементы ветвящихся алгоритмов: + +* **Условные операторы**: позволяют проверять условия и выбирать путь выполнения. Примеры: `if-else` в большинстве языков программирования. +* **Множественный выбор**: использование конструкции `switch-case` или аналогов для выбора одного из нескольких возможных вариантов на основе значения переменной. + +Такие алгоритмы часто применяются в задачах, где необходимо проверять различные условия и принимать решения в зависимости от их выполнения. Например, проверка ввода пользователя и выполнение соответствующих действий в зависимости от введённых данных. + +### Пример + +```python +age = 18 +if age < 18: + print("Вам меньше 18 лет") +else: + print("Вам 18 лет или больше") +``` + +## 6 Циклические алгоритмы + +### Краткий ответ + +Циклические алгоритмы выполняют определённые действия многократно, пока выполняется заданное условие. + +### Развернутый ответ + +Циклические алгоритмы включают повторяющиеся действия, которые выполняются до тех пор, пока соблюдается определённое условие. Эти алгоритмы используют циклы для многократного выполнения набора инструкций, что позволяет эффективно обрабатывать большие объемы данных или выполнять повторяющиеся задачи. + +Основные виды циклов: + +* **Цикл с предусловием (`while`)**: выполняется, пока условие истинно. +* **Цикл с постусловием (`do-while`)**: сначала выполняется тело цикла, затем проверяется условие. +* **Цикл с счётчиком (`for`)**: выполняется определённое количество раз. + +Циклические алгоритмы позволяют: + +1. Обрабатывать массивы и списки. +2. Выполнять действия, зависящие от многократного выполнения одинаковых операций. +3. Реализовывать сложные вычислительные задачи, требующие повторения шагов. + +Эти алгоритмы широко используются в программировании и алгоритмике благодаря своей способности обрабатывать данные и выполнять повторяющиеся действия эффективно и структурированно. + +### Пример + +Сумма элементов + +```python +summa = 0 +while summa != 23: + summa += 1 +print(summa) +``` + +Поиск индекса элемента в массиве + +```python +array = [1, 3, 5, 2, 6] +for index in range(len(array)): + if array[index] == 2: + print(index) + break +``` + +## 7 Решение уравнения методом деления отрезка пополам + +### Краткий ответ + +Метод деления отрезка пополам (метод бисекции) заключается в итеративном делении отрезка пополам и выборе подотрезка, на котором функция меняет знак, до достижения нужной точности. + +### Развернутый ответ + +Метод деления отрезка пополам, или метод бисекции, используется для нахождения корней уравнения *f(x) = 0* на заданном отрезке *[a, b]*, где функция *f* непрерывна и знаки значений функции на концах отрезка различны (т.е. *f(a) * f(b) < 0*). Метод заключается в следующем: + +1. **Проверка условия начального отрезка**: Убедиться, что *f(a) * f(b) < 0*. Если это условие не выполняется, метод не применим на данном отрезке. +2. **Итеративное деление отрезка**: + * Найти середину отрезка: *c = (a + b)/2*. + * Вычислить значение функции в середине: *f(c)*. + * Если *f(c) = 0*, то *c* и есть корень уравнения. + * Если *f(a) * f(c) < 0*, то корень находится в отрезке *[a, c]*, иначе в отрезке *[c, b]*. +3. **Сужение отрезка**: Заменить отрезок *[a, b]* на подотрезок, в котором функция меняет знак. +4. **Повторение шагов**: Повторять шаги 2 и 3, пока длина отрезка не станет меньше заданной точности. +5. **Результат**: Середина отрезка в последней итерации будет приближением к корню уравнения с заданной точностью. + +Этот метод гарантирует нахождение корня при условии, что функция непрерывна и значения на концах отрезка имеют противоположные знаки. Метод эффективен и прост в реализации, но может быть медленным по сравнению с другими методами, такими как метод Ньютона, если требуется высокая точность. + +### Пример + +```python +def bisection_method(f, a, b, epsilon): + if f(a) * f(b) >= 0: + print("f(a) и f(b) должны иметь разные знаки") + return + + while (b - a) / 2 > epsilon: + c = (a + b) / 2 + if f(c) == 0: + return c + elif f(a) * f(c) < 0: + b = c + else: + a = c + + return (a + b) / 2 + +# Пример функции +def f(x): + return x**3 - x - 2 + +# Найти корень на отрезке [1, 2] с точностью 0.01 +root = bisection_method(f, 1, 2, 0.01) +print("Корень:", root) +``` + +## 8 Решение уравнения методом касательных + +### Краткий ответ + +Метод касательных (метод Ньютона) использует итерации с помощью касательных к функции для приближения к корню уравнения. + +### Развернутый ответ + +Метод касательных, или метод Ньютона, решает уравнение *f(x) = 0* путём итеративного приближения к корню с использованием касательных к графику функции. Этот метод требует начального приближения *x_0* и производной функции *f'(x)*. Алгоритм заключается в следующем: + +1. **Начальное приближение**: Выбирается начальное приближение *x_0*. +2. **Итерации**: + * Вычисляется значение функции *f(x_n)* и её производной *f'(x_n)* в текущей точке *x_n*. + * Вычисляется новое приближение по формуле: *x_{n+1} = x_n - f(x_n)/f'(x_n)*. + * Проверяется условие остановки: если разница между *x_{n+1}* и *x_n* меньше заданной точности, итерации прекращаются. +3. **Результат**: Последнее вычисленное значение *x_{n+1}* считается приближением к корню уравнения. + +Этот метод требует, чтобы начальное приближение было достаточно близко к истинному корню, а функция *f(x)* и её производная *f'(x)* были непрерывны и не равны нулю в области итераций. Метод Ньютона часто сходится очень быстро, особенно если начальное приближение близко к реальному корню. Однако, если производная равна нулю или начальное приближение далеко от корня, метод может не сработать. + +### Пример + +```python +def newton_method(f, df, x0, epsilon): + x_n = x0 + while True: + f_x_n = f(x_n) + df_x_n = df(x_n) + if df_x_n == 0: + print("Производная равна нулю, метод Ньютона не применим") + return + + x_n1 = x_n - f_x_n / df_x_n + + if abs(x_n1 - x_n) < epsilon: + return x_n1 + + x_n = x_n1 + +# Пример функции и её производной +def f(x): + return x**3 - x - 2 + +def df(x): + return 3*x**2 - 1 + +# Начальное приближение x0 и точность epsilon +x0 = 1.5 +epsilon = 0.0001 + +# Найти корень +root = newton_method(f, df, x0, epsilon) +print("Корень:", root) +``` + +## 9 Решение уравнения методом хорд + +### Краткий ответ + +Метод хорд (метод секущих) использует итеративный процесс, в котором вычисляются пересечения хорд с осью абсцисс для приближения корня уравнения. + +### Развернутый ответ + +Метод хорд, или метод секущих, является численным методом для нахождения корня уравнения *f(x) = 0*. В отличие от метода Ньютона, он не требует вычисления производной функции. Вместо этого метод использует две начальные точки и итеративно приближает корень, используя хордовые отрезки. + +Алгоритм метода хорд состоит из следующих шагов: + +1. **Выбор начальных приближений**: Выбираются две начальные точки *x_0* и *x_1* так, чтобы *f(x_0) \neq f(x_1)*. +2. **Итеративный процесс**: + * Вычисляется новое приближение *x_{n+1}* по формуле: + ![img](./img/Решение_уравнения_методом_хорд.png) + * Проверяется условие остановки: если *|x_{n+1} - x_n| < epsilon*, где *epsilon* — заданная точность, итерации прекращаются. +3. **Результат**: Последнее вычисленное значение *x_{n+1}* считается приближением к корню уравнения. + +Метод хорд является эффективным численным методом, особенно когда производная функции недоступна или трудна для вычисления. Он часто требует больше итераций по сравнению с методом Ньютона, но в некоторых случаях может быть более удобным и применимым. Этот метод подходит для функций, где значения в начальных точках *x_0* и *x_1* не равны и обеспечивают приближение к корню. + +### Пример + +```python +def secant_method(f, x0, x1, epsilon): + f_x0 = f(x0) + f_x1 = f(x1) + + if f_x0 == f_x1: + raise ValueError("Значения функции в начальных точках не должны быть равны") + + while abs(x1 - x0) >= epsilon: + x2 = x1 - f_x1 * (x1 - x0) / (f_x1 - f_x0) + x0, x1 = x1, x2 + f_x0, f_x1 = f_x1, f(x1) + + return x1 + +# Пример функции +def f(x): + return x**3 - x - 2 + +# Начальные приближения x0 и x1 и точность epsilon +x0 = 1 +x1 = 2 +epsilon = 0.0001 + +# Найти корень +root = secant_method(f, x0, x1, epsilon) +print("Корень:", root) +``` + +## 10 Метод наименьших квадратов. Регрессия + +### Краткий ответ + +Метод наименьших квадратов минимизирует сумму квадратов отклонений между наблюдаемыми значениями и предсказанными, чтобы определить наилучшие параметры модели. + +### Развернутый ответ + +Метод наименьших квадратов — это статистический метод, используемый для нахождения наилучшего приближения зависимости между зависимой переменной и одной или несколькими независимыми переменными. Этот метод минимизирует сумму квадратов отклонений наблюдаемых значений от предсказанных значений модели. + +Метод наименьших квадратов является основой многих более сложных методов регрессии и широко применяется в статистике и машинном обучении для анализа и предсказания данных. + +## 11 Алгоритм Евклида для поиска наибольшего общего делителя (НОД) + +### Краткий ответ + +Алгоритм Евклида — это эффективный метод для нахождения наибольшего общего делителя двух целых чисел. + +### Развернутый ответ + +Алгоритм Евклида предназначен для нахождения наибольшего общего делителя (НОД) двух целых чисел *a* и *b*. НОД двух чисел — это наибольшее число, на которое делятся оба числа без остатка. + +### Шаги алгоритма Евклида + +1. **Исходные числа**: Пусть *a* и *b* — два целых числа, для которых мы ищем НОД. +2. **Основной шаг**: Пока *b != 0*: + * Вычисляем остаток от деления *a* на *b*: *r = a \mod b*. + * Обновляем значения: *a = b* и *b = r*. +3. **Результат**: Когда *b = 0*, значение *a* будет наибольшим общим делителем чисел *a* и *b*. + +### Сложность и эффективность + +Алгоритм Евклида имеет линейную сложность *O(log(min(a, b)))*, что делает его очень эффективным для вычисления НОД даже для очень больших чисел. Он является одним из базовых алгоритмов в арифметике и используется в различных областях, включая криптографию и математические расчеты. + +### Пример + +```python +def gcd(a, b): + while b != 0: + a, b = b, a % b + return a + +# Пример использования +num1 = 36 +num2 = 60 +result = gcd(num1, num2) +print("Наибольший общий делитель чисел", num1, "и", num2, ":", result) +``` + +## 12 Понятие о факторизации числа + +### Краткий ответ + +Факторизация числа — это процесс разложения числа на простые множители. + +### Развернутый ответ + +Факторизация числа представляет собой математический процесс, в результате которого число разлагается на простые множители. Простые числа являются числами, которые имеют ровно два различных положительных делителя: единицу и само число. Факторизация чисел является важной задачей в математике и криптографии. + +Факторизация чисел имеет большое значение в криптографии, где сложность факторизации больших чисел используется для создания надёжных криптографических алгоритмов, таких как RSA. Также факторизация играет важную роль в алгоритмах решения уравнений, кодировании данных и других областях математики и информатики. + +## 13 Алгоритм Ферма факторизации + +### Краткий ответ + +Алгоритм Ферма факторизации — это метод для разложения составного числа на множители, основанный на предположении, что составное число может быть представлено в виде разности квадратов. + +### Развернутый ответ + +Алгоритм Ферма факторизации был разработан итальянским математиком Пьерре де Ферма в XVII веке. Он является одним из старейших известных методов факторизации чисел и предполагает, что любое нечётное составное число *n* может быть представлено в виде разности квадратов: +*n = a^2 - b^2 = (a - b)(a + b)* + +### Шаги алгоритма Ферма + +1. **Выбор начальных значений**: Выбираются целые числа *a* и *b*, такие что *a^2 >= n*. +2. **Проверка условия квадратности**: Вычисляется *x = sqrt(a^2 - n)*. Если *x* является целым числом, то *n* уже является квадратом, и факторизация завершается. +3. **Итерационный процесс**: + * Увеличиваем *a* и проверяем, если *a^2 >= n*, то уменьшаем *b*. + * Проверяем, является ли *a^2 - b^2* квадратом. + * Если находим такие *a* и *b*, что *a^2 - b^2* является квадратом, то разлагаем *n* на множители как *n = (a - b)(a + b)*. +4. **Остановка**: Процесс продолжается до тех пор, пока не будет найдено разложение числа *n* на множители. + +### Пример + +```python +import math + +def fermat_factorization(n): + x = int(n ** 0.5) + 1 + while not math.sqrt(x * x - n): + x += 1 + + y = int((x * x - n) ** 0.5) + a = x - y + b = x + y + return a, b + +# Пример использования +n = 8051 +p, q = fermat_factorization(n) +print(f"Число {n} разложено на множители: {p} и {q}") +``` + +## 14 Алгоритмы поиска простых чисел. Решето Эратосфена + +### Краткий ответ + +Решето Эратосфена — это алгоритм для эффективного поиска всех простых чисел до заданного числа *n*. + +### Развернутый ответ + +Решето Эратосфена — это алгоритм для нахождения всех простых чисел до заданного числа *n*. Он был разработан древнегреческим математиком Эратосфеном около 240 года до н. э. и остаётся одним из самых эффективных способов нахождения простых чисел. + +### Шаги алгоритма Решето Эратосфена + +1. **Инициализация**: Создаётся список чисел от 2 до *n*. В начале считаем, что все числа являются простыми. +2. **Обход списка**: Начиная с первого числа *p = 2*: Если число *p* не помечено как не простое (т.е. простое), помечаем все его кратные числа (кроме самого числа *p*) как не простые. +3. **Переход к следующему простому числу**: Переходим к следующему числу в списке, которое ещё не было помечено как не простое. +4. **Остановка**: Процесс продолжается до тех пор, пока не будут рассмотрены все числа до *sqrt(n)*. Все числа, которые остались помеченными как простые, являются простыми числами. + +### Пример + +```python +def sieve_of_eratosthenes(n): + # Создаём список для хранения информации о простоте чисел + is_prime = [True] * (n + 1) + is_prime[0] = is_prime[1] = False # 0 и 1 не являются простыми числами + + p = 2 + while (p * p <= n): + if (is_prime[p] == True): + # Помечаем все кратные p как не простые числа + for i in range(p * p, n + 1, p): + is_prime[i] = False + p += 1 + + # Собираем список всех простых чисел до n + primes = [p for p in range(n + 1) if is_prime[p]] + return primes + +# Пример использования +n = 30 +primes = sieve_of_eratosthenes(n) +print(f"Простые числа до {n}: {primes}") +``` + +### Значение и применение + +Решето Эратосфена широко используется в задачах, требующих быстрого нахождения простых чисел, таких как криптография, оптимизация алгоритмов и математические расчёты. Он является классическим примером эффективного алгоритма для работы с большими наборами чисел. + +## 15 Числа Мерсенна. Тест Люка-Лемера + +![img](./img/Числа_Мерсенна._Тест_Люка-Лемера.png) + +## 16 Псевдослучайные числа + +Числа фон Неймана (von Neumann numbers) — это один из первых методов генерации псевдослучайных чисел, предложенный учёным Джоном фон Нейманом во второй половине XX века. Основная идея метода заключается в том, чтобы использовать физический процесс, который теоретически обладает случайной природой, для генерации случайных чисел. + +### Принцип работы метода + +1. **Физический процесс**: В основе метода фон Неймана лежит использование физических процессов, которые считаются случайными в классическом понимании. Например, это могут быть шумы в электрических цепях, тепловое движение атомов и молекул (так называемый тепловой шум), колебания цен на финансовых рынках и т.д. + +2. **Преобразование в случайные числа**: Полученные данные из физического процесса (например, последовательность случайных чисел) подвергаются специальной обработке, которая приводит их к форме псевдослучайных чисел. + +3. **Использование алгоритмов**: Полученные числа могут использоваться как исходные данные для дальнейших алгоритмов, которые обеспечивают равномерное распределение и большой период. + +### Пример алгоритма + +Приведу пример простого алгоритма, демонстрирующего принцип работы метода фон Неймана: + +1. Зафиксируем два показания часов. +2. Сложим их. +3. Разделим сумму на 2 и возьмем остаток от деления. + +## 17 Метод Карацубы для быстрого умножения двух чисел + +Метод Карацубы — это алгоритм для быстрого умножения двух больших чисел, который основывается на принципе декомпозиции чисел на более мелкие части и рекурсивного использования умножения. Этот метод позволяет значительно уменьшить количество элементарных операций по сравнению с классическим методом умножения. + +![img](./img/метод_Карацубы.png) + +## 18 Алгоритм быстрого возведения в степень + +Алгоритм быстрого возведения в степень — это эффективный метод для вычисления степени числа *x* в целочисленной степени *n*. Он использует принцип разделяй и властвуй для уменьшения числа операций. + +### Основные идеи алгоритма + +1. **Разделяй и властвуй**: Вместо прямого умножения числа *x* на себя *n* раз, алгоритм разбивает вычисление степени на более мелкие подзадачи. +2. **Чётность степени *n***: + * Если степень *n* чётная, то *x^n = (x^(n/2))^2*. + * Если степень *n* нечётная, то *x^n = x * x^(n-1)*. +3. **Рекурсивное уменьшение степени**: Процесс повторяется до тех пор, пока степень *n* не станет равной нулю. + +### Пример + +```python +def power(x, n): + if n == 0: + return 1 + elif n == 1: + return x + elif n < 0: + return 1 / power(x, -n) + else: + half_power = power(x, n // 2) + if n % 2 == 0: + return half_power * half_power + else: + return x * half_power * half_power + +# Пример использования +x = 2 +n = 10 +print(f"{x} в степени {n} равно {power(x, n)}") +``` + +## 19 Понятие о рекурсии + +Рекурсия — это концепция в программировании, при которой функция вызывает саму себя непосредственно или через цепочку вызовов. Это основной механизм во многих алгоритмах и структурах данных. + +### Преимущества и недостатки + +**Преимущества**: + +* Простота и естественность для некоторых задач. +* Позволяет уменьшить размер и упростить код для определенных алгоритмов. +* Удобство для решения задач, которые естественно разбиваются на подзадачи. + +**Недостатки**: + +* Может привести к глубокой вложенности вызовов и использованию большого объема памяти. +* Неправильная реализация может привести к бесконечному циклу вызовов (бесконечная рекурсия). + +Рекурсия является мощным инструментом в программировании, который позволяет элегантно решать множество задач, однако требует осторожности при реализации и понимании базовых и рекурсивных случаев для предотвращения потенциальных проблем с производительностью и памятью. + +### Пример + +Рассмотрим пример вычисления факториала с использованием рекурсии: + +```python +def factorial(n): + # Базовый случай + if n == 0: + return 1 + # Рекурсивный случай + else: + return n * factorial(n - 1) + +# Пример использования +print(factorial(5)) # Output: 120 +``` + +## 20 Числа Фибоначчи + +Числа Фибоначчи — это последовательность чисел, где каждое следующее число равно сумме двух предыдущих. Обычно последовательность начинается с чисел 0 и 1. + +## 21 Задача о Ханойской башне + +Задача о Ханойской башне — это классическая головоломка, которая состоит в перемещении всех дисков с одного стержня на другой, используя третий стержень в качестве промежуточного, с условием, что на более крупный диск нельзя класть меньший. + +## 22 Динамическое программирование + +Динамическое программирование (DP) — это метод решения сложных задач путём разбиения их на более простые подзадачи и сохранения результатов этих подзадач для последующего использования. + +### Основные принципы + +1. **Разбиение задачи**: Исходная задача разбивается на несколько подзадач. +2. **Сохранение результатов**: Результаты каждой подзадачи сохраняются для последующего повторного использования. +3. **Комбинирование результатов**: Результаты подзадач комбинируются для получения решения исходной задачи. + +## 23 Задача сортировки массива + +Сортировка массива — это процесс упорядочивания элементов массива в определенном порядке, таком как по возрастанию или убыванию. + +## 24 Алгоритм пузырьковой сортировки + +Алгоритм пузырьковой сортировки (Bubble Sort) — это простой алгоритм сортировки, который проходит по списку несколько раз. На каждом проходе он сравнивает соседние элементы и меняет их местами, если они находятся в неправильном порядке. После каждого прохода наибольший элемент "всплывает" в конец списка, как пузырёк в воде, отсюда и название алгоритма. + +### Краткое описание алгоритма + +1. **Проходы по списку**: Начиная с начала списка, сравниваются два соседних элемента. +2. **Поменять местами, если нужно**: Если элементы стоят в неправильном порядке (меньший следует за большим), они меняются местами. +3. **Повторение проходов**: Этот процесс повторяется для всех элементов списка, пока не будет достигнут конец списка. +4. **Уменьшение диапазона**: После каждого прохода самый большой элемент "всплывает" в конец списка, поэтому на следующем проходе его можно не рассматривать. +5. **Оптимизация**: Если за проход не было ни одной перестановки, значит, список уже отсортирован, и алгоритм может завершить работу. + +### Сложность + +* В худшем случае (когда список отсортирован в обратном порядке) время выполнения пузырьковой сортировки составляет *O(n^2)*, где *n* — количество элементов в списке. +* В лучшем случае (когда список уже отсортирован или почти отсортирован) время выполнения может быть *O(n)*, но алгоритм все равно требует прохода по списку для проверки. +* Память: Алгоритм сортировки пузырьком выполняется "на месте" и требует только постоянной дополнительной памяти *O(1)*. + +Хотя пузырьковая сортировка не является самым эффективным алгоритмом сортировки для больших массивов данных из-за своей квадратичной сложности, она легко понимается и реализуется, что делает её полезной для обучения и первоначальных прототипов. + +## 25 Алгоритм сортировки вставками + +Алгоритм сортировки вставками (Insertion Sort) — это простой алгоритм сортировки, который строит отсортированную последовательность по одному элементу за раз. На каждом шаге текущий элемент вставляется в упорядоченную часть списка (или массива) на своё правильное место. + +### Описание алгоритма + +1. **Начало с неупорядоченного списка**: Алгоритм начинает с первого элемента, предполагая, что он уже отсортирован (так как одноэлементный список считается упорядоченным). +2. **Вставка элементов**: Для каждого последующего элемента алгоритм сравнивает его со всеми предыдущими элементами в отсортированной части списка. Элементы, которые больше текущего, сдвигаются вправо, чтобы освободить место для вставки текущего элемента. +3. **Повторение**: Этот процесс продолжается до тех пор, пока все элементы не будут вставлены на свои места в отсортированной части списка. + +### Сложность + +* В худшем и среднем случае время выполнения пузырьковой сортировки составляет *O(n^2)*, где *n* — количество элементов в списке. +* В лучшем случае (когда список уже отсортирован) время выполнения может быть *O(n)*, так как вставка элементов происходит без перемещений. +* Память: Алгоритм сортировки вставками выполняется "на месте" и требует только постоянной дополнительной памяти *O(1)*. + +### Заключение + +Алгоритм сортировки вставками эффективен для небольших списков или уже частично упорядоченных данных, где его квадратичная сложность не слишком сказывается на производительности. Он легко реализуется и понимается, что делает его полезным инструментом в образовательных и прототипных задачах. + +## 26 Алгоритм сортировки выбором + +Алгоритм сортировки выбором (Selection Sort) — это простой алгоритм сортировки, который на каждом шаге выбирает минимальный (или максимальный) элемент из неотсортированной части списка и помещает его в конец отсортированной части. + +### Описание алгоритма + +1. **Начало с неотсортированного списка**: Алгоритм начинает с предположения, что весь список является неотсортированным. +2. **Поиск минимального элемента**: На каждом проходе алгоритм ищет минимальный элемент в неотсортированной части списка. +3. **Обмен с началом отсортированной части**: Минимальный элемент меняется местами с первым элементом неотсортированной части списка. +4. **Увеличение границы отсортированной части**: После каждого прохода граница отсортированной части списка увеличивается на один элемент. +5. **Повторение процесса**: Этот процесс повторяется до тех пор, пока не весь список не будет отсортирован. + +### Сложность + +* Всегда выполняет *O(n^2)* сравнений и *O(n)* обменов, где *n* — количество элементов в списке. +* В худшем, среднем и лучшем случае алгоритм имеет одинаковую временную сложность, так как всегда выполняет одинаковое количество операций. +* Память: Алгоритм сортировки выбором выполняется "на месте" и требует только постоянной дополнительной памяти *O(1)*. + +### Заключение + +Алгоритм сортировки выбором прост в реализации, но из-за своей квадратичной сложности он не является эффективным для сортировки больших массивов данных. Однако он может быть полезен в случаях, когда требуется простой и понятный алгоритм сортировки для небольших наборов данных или для обучающих целей. + +## 27 Алгоритм шейкерной сортировки + +Алгоритм шейкерной сортировки (Cocktail Sort), также известный как двунаправленная сортировка пузырьком, является модификацией классической сортировки пузырьком. Он обеспечивает улучшение производительности путем уменьшения количества проходов по списку в сравнении с обычной сортировкой пузырьком. + +### Описание алгоритма + +1. **Проходы по списку**: Алгоритм начинает сначала списка и двигается вперед, как в сортировке пузырьком, сравнивая соседние элементы и меняя их местами, если они находятся в неправильном порядке. +2. **Обратное движение**: После завершения прохода от начала до конца списка, алгоритм начинает движение в обратном направлении от конца списка к началу, снова сравнивая и меняя элементы при необходимости. +3. **Оптимизация**: При каждом проходе вперед и назад самый большой (или самый маленький, в зависимости от направления сортировки) элемент "всплывает" в конец (или начало) списка, что уменьшает количество элементов, которые нужно рассматривать на следующем проходе. +4. **Условие завершения**: Алгоритм завершает работу, когда на каком-то проходе не было ни одной перестановки, что означает, что список уже отсортирован. + +### Сложность + +* В среднем и в худшем случае время выполнения шейкерной сортировки составляет *O(n^2)*, где *n* — количество элементов в списке. +* В лучшем случае (когда список уже отсортирован) время выполнения может быть *O(n)*, так как алгоритм может завершиться после первого прохода. +* Память: Алгоритм шейкерной сортировки выполняется "на месте" и требует только постоянной дополнительной памяти *O(1)*. + +### Заключение + +Шейкерная сортировка является улучшенной версией классической сортировки пузырьком, которая позволяет уменьшить количество проходов по списку и улучшить производительность на практике. Однако она все еще не является наилучшим выбором для сортировки больших массивов данных из-за своей квадратичной сложности. + +## 28 Алгоритм сортировки Шелла + +Алгоритм сортировки Шелла (Shell Sort) является усовершенствованным алгоритмом вставочной сортировки, который применяет сортировку вставками к группам элементов с некоторым шагом (gap), который уменьшается на каждом проходе. Этот алгоритм придуман Дональдом Шеллом в 1959 году и является одним из первых "быстрых" алгоритмов сортировки. + +### Описание алгоритма + +1. **Выбор шага (gap)**: Выбирается начальное значение шага (обычно половина длины списка), которое постепенно уменьшается до 1. +2. **Сортировка вставками с шагом**: Для каждого значения шага выполняется сортировка вставками элементов, находящихся на расстоянии шага друг от друга. То есть элементы находятся на позициях `i`, `i + gap`, `i + 2 * gap`, и так далее. +3. **Уменьшение шага**: После завершения сортировки вставками с текущим шагом, шаг уменьшается. Процесс повторяется до тех пор, пока шаг не станет равным 1. +4. **Финальная сортировка**: После завершения всех проходов с минимальным шагом (1), список считается почти отсортированным, и окончательная сортировка вставками приводит к завершенной сортировке. + +### Сложность + +* В среднем случае время выполнения алгоритма сортировки Шелла составляет *O(n^(3/2))*. +* В худшем случае алгоритм имеет асимптотическую сложность *O(n^2)*. +* Лучшая временная сложность зависит от выбора последовательности шагов, но обычно составляет *O(n \log n)*. +* Память: Алгоритм сортировки Шелла также выполняется "на месте" и требует только постоянной дополнительной памяти *O(1)*. + +### Заключение + +Алгоритм сортировки Шелла является эффективным вариантом сортировки вставками, особенно для небольших наборов данных. Он обеспечивает значительное улучшение производительности по сравнению с простой сортировкой вставками за счет предварительной сортировки подгрупп элементов с различными интервалами. + +## 29 Алгоритм быстрой сортировки + +Алгоритм быстрой сортировки (Quick Sort) — это один из самых эффективных алгоритмов сортировки, используемый для сортировки массивов и списков. Он основан на принципе "разделяй и властвуй" (divide and conquer), который заключается в разбиении массива на две подмассива, которые затем сортируются рекурсивно. + +### Описание алгоритма + +1. **Выбор опорного элемента**: Из массива выбирается опорный элемент (pivot). Существует несколько стратегий выбора опорного элемента: случайный выбор, медиана трёх элементов и т.д. +2. **Разбиение массива**: Массив разделяется на две части: + * Элементы, которые меньше или равны опорному элементу. + * Элементы, которые больше опорного элемента. +3. **Рекурсивная сортировка**: Рекурсивно сортируются обе подмассива, полученные после разбиения. +4. **Объединение**: После рекурсивной сортировки подмассивов, опорный элемент вставляется на своё место, объединяя отсортированные подмассивы в итоговый отсортированный массив. + +### Сложность + +* **Лучший случай**: *O(n log n)*, когда массив уже отсортирован или опорный элемент делит массив на две почти равные части. +* **Худший случай**: *O(n^2)*, когда массив уже отсортирован в обратном порядке, и опорный элемент всегда выбирается как самый первый или последний элемент. +* **Средний случай**: *O(n log n)*, при случайном распределении элементов. +* **Память**: Алгоритм выполняется "на месте" и требует только постоянной дополнительной памяти *O(log n)* для стека вызовов рекурсии. + +### Заключение + +Быстрая сортировка является одним из наиболее эффективных алгоритмов сортировки для больших массивов данных благодаря своей высокой производительности в среднем случае. Однако её эффективность сильно зависит от выбора опорного элемента и может ухудшаться в худших случаях. + +## 30 Алгоритм сортировки + +Алгоритмы сортировки являются ключевым элементом в компьютерных науках и программировании. Они представляют собой методы организации элементов в определенном порядке, чаще всего по возрастанию или убыванию значений. Вот несколько основных алгоритмов сортировки: + +1. **Сортировка пузырьком (Bubble Sort)**: + * Простой алгоритм, который многократно проходит по списку, сравнивая соседние элементы и меняя их местами, если они находятся в неправильном порядке. + * Сложность: *O(n^2)* в худшем и среднем случае, *O(n)* в лучшем случае (если список уже отсортирован). +2. **Сортировка выбором (Selection Sort)**: + * Алгоритм выбирает минимальный элемент из неотсортированной части массива и помещает его в начало. + * Сложность: *O(n^2)* в худшем, среднем и лучшем случае. +3. **Сортировка вставками (Insertion Sort)**: + * Алгоритм проходит по массиву и вставляет каждый элемент в отсортированную часть массива на своё место. + * Сложность: *O(n^2)* в худшем и среднем случае, *O(n)* в лучшем случае (если список уже отсортирован). +4. **Сортировка слиянием (Merge Sort)**: + * Рекурсивный алгоритм, который разделяет список пополам, сортирует каждую половину отдельно, а затем объединяет их в один отсортированный список. + * Сложность: *O(n log n)* во всех случаях (худшем, среднем и лучшем). +5. **Быстрая сортировка (Quick Sort)**: + * Рекурсивный алгоритм, который выбирает опорный элемент (pivot), разделяет массив на элементы, меньшие и большие опорного, и рекурсивно сортирует подмассивы. + * Сложность: *O(n log n)* в среднем и лучшем случае, *O(n^2)* в худшем случае (если выбор опорного элемента неудачен). +6. **Пирамидальная сортировка (Heap Sort)**: + * Сортировка, основанная на структуре данных куча (heap). Строится max-куча из массива, после чего корень кучи (максимальный элемент) перемещается в конец массива и уменьшается размер кучи, чтобы продолжать процесс сортировки. + * Сложность: *O(n log n)* во всех случаях. + +## 31 Основные структуры данных + +1. **Массив (Array)**: + * Упорядоченная коллекция элементов фиксированного размера. + * Доступ к элементам происходит по индексу. + * Прост в использовании и эффективен для доступа к элементам по индексу. + * Ограничен статическим размером. +2. **Связный список (Linked List)**: + * Коллекция элементов, где каждый элемент (узел) содержит данные и ссылку на следующий элемент в списке. + * Позволяет эффективно добавлять и удалять элементы в середине списка. + * Разновидности: односвязный, двусвязный, кольцевой связный список. +3. **Стек (Stack)**: + * Коллекция элементов, работающая по принципу LIFO (Last-In-First-Out). + * Операции: push (добавление элемента), pop (удаление элемента), peek (просмотр верхнего элемента). + * Часто используется в рекурсивных алгоритмах и управлении памятью. +4. **Очередь (Queue)**: + * Коллекция элементов, работающая по принципу FIFO (First-In-First-Out). + * Операции: enqueue (добавление элемента), dequeue (удаление элемента), peek (просмотр первого элемента). + * Используется для моделирования процесса управления задачами. +5. **Двоичное дерево (Binary Tree)**: + * Иерархическая структура данных, где каждый узел имеет не более двух дочерних узлов. + * Разновидности: двоичное дерево поиска (Binary Search Tree), AVL-дерево, красно-чёрное дерево и другие. +6. **Граф (Graph)**: + * Абстрактная математическая структура, представляющая собой множество вершин и рёбер между ними. + * Используется для моделирования сложных отношений и сетей. +7. **Хэш-таблица (Hash Table)**: + * Структура данных, которая позволяет эффективно хранить и извлекать пары ключ-значение. + * Операции вставки, удаления и поиска выполняются в среднем за константное время. +8. **Куча (Heap)**: + * Структура данных, которая представляет собой полное бинарное дерево. + * Разновидности: мин-куча (min-heap), где каждый узел меньше или равен своим дочерним узлам, и макс-куча (max-heap), где каждый узел больше или равен своим дочерним узлам. + * Часто используется для реализации приоритетных очередей. + +## 32 Массив и динамический массив + +Массив и динамический массив — это две основные структуры данных, используемые для хранения элементов в программировании. Они имеют свои особенности, преимущества и недостатки, которые следует учитывать при выборе для конкретной задачи. + +### Массив (Static Array) + +Массив представляет собой упорядоченную коллекцию элементов фиксированного размера. Элементы массива хранятся в непрерывной области памяти, и каждый элемент имеет индекс, по которому можно обращаться к нему. + +#### Основные характеристики массива + +* **Фиксированный размер**: При создании массива вы должны указать его размер. Размер массива не может изменяться после его создания. +* **Быстрый доступ к элементам**: Элементы массива расположены последовательно в памяти, поэтому доступ к элементу по индексу *i* выполняется за *O(1)* времени. +* **Ограниченность размером**: Размер массива определяется при создании, и его изменение требует создания нового массива и копирования всех элементов, что может быть дорогостоящей операцией в случае больших массивов. +* **Подходит для статических данных**: Массивы хорошо подходят для статических данных или когда заранее известно количество элементов. + +### Динамический массив (Dynamic Array) + +Динамический массив является расширяемой версией статического массива, которая автоматически увеличивает свой размер при необходимости. + +#### Основные характеристики динамического массива + +* **Динамическое изменение размера**: Динамический массив позволяет добавлять и удалять элементы, увеличивая или уменьшая свой размер при необходимости. В Python такие массивы реализуются через список (`list`). +* **Амортизированное время доступа**: В среднем время доступа к элементу по индексу все еще *O(1)*, но иногда добавление новых элементов может потребовать перевыделения памяти и копирования всех элементов в новый массив, что может занимать *O(n)* времени в худшем случае. +* **Гибкость и удобство**: Динамические массивы позволяют эффективно управлять изменяющимися данными и не требуют заранее заданного размера. + +Выбор между статическим и динамическим массивом зависит от конкретной задачи и требований к производительности. Статические массивы подходят для случаев, когда размер данных известен заранее и не меняется. Динамические массивы предоставляют большую гибкость и удобство при управлении изменяющимися данными, но могут иметь большую временную сложность при операциях изменения размера. + +## 33 Связный список + +Связный список (Linked List) в структурах данных представляет собой линейную коллекцию элементов, где каждый элемент (узел) содержит данные и ссылку (или указатель) на следующий элемент в списке. Связный список позволяет эффективно добавлять и удалять элементы в любом месте списка, что отличает его от массива, где операции вставки и удаления могут быть дорогостоящими из-за необходимости перекопирования элементов. + +### Основные типы связных списков + +1. **Односвязный список (Singly Linked List)**: + * Каждый узел содержит данные и ссылку на следующий узел в списке. + * Последний узел ссылается на `None` (или `null`), что указывает на конец списка. + * Простая реализация, которая обеспечивает эффективную вставку и удаление элементов в начале и в конце списка (за *O(1)*), но имеет ограниченные возможности для эффективного доступа к элементам по индексу. +2. **Двусвязный список (Doubly Linked List)**: + * Каждый узел содержит данные, ссылку на следующий узел и ссылку на предыдущий узел. + * Это позволяет эффективно перемещаться в обе стороны по списку, что полезно для операций удаления и вставки элементов в середине списка (за *O(1)* при доступе к соседним узлам). +3. **Кольцевой связный список (Circular Linked List)**: + * В этом типе связного списка последний узел ссылается на первый узел, образуя замкнутую структуру. + * Обычно используется для реализации кольцевых буферов или кольцевых очередей, где элементы обрабатываются в циклическом порядке. + +### Основные операции со связным списком + +* **Добавление элемента**: + * Вставка нового узла в начало списка или между существующими узлами. + * В случае односвязного списка: *O(1)*, если имеется ссылка на голову списка. + * В случае двусвязного списка: *O(1)*, если имеется ссылка на предыдущий и следующий узлы. +* **Удаление элемента**: + * Удаление узла из начала, конца или середины списка. + * В случае односвязного списка: *O(1)*, если узлы корректно связаны. + * В случае двусвязного списка: *O(1)*, если известны предыдущий и следующий узлы. +* **Поиск элемента**: + * Поиск узла по значению или индексу. + * В односвязном и двусвязном списках может потребоваться просмотреть список от начала до конца, что занимает *O(n)* времени в худшем случае. + +Связные списки представляют мощный инструмент для реализации множества алгоритмов и структур данных, требующих эффективного добавления, удаления и перемещения элементов, особенно в случаях, когда количество элементов неизвестно заранее или может изменяться динамически. + +## 34 Стек + +Стек (Stack) в контексте структур данных представляет собой коллекцию элементов, работающую по принципу "последним пришёл — первым вышел" (Last-In-First-Out, LIFO). Это означает, что элементы добавляются и извлекаются только с одного конца стека, называемого вершиной. Стек используется для управления вызовами функций, вычислений выражений, реализации обратной польской записи и других задач, где необходим порядок доступа к элементам по принципу LIFO. + +### Основные операции со стеком + +1. **Добавление элемента (push)**: + * Элемент добавляется на вершину стека. + * Эта операция выполняется за константное время *O(1)*. +2. **Извлечение элемента (pop)**: + * Элемент удаляется с вершины стека и возвращается. + * Эта операция также выполняется за константное время *O(1)*. +3. **Проверка наличия элементов (empty)**: + * Проверка, содержит ли стек элементы. + * Эта операция также выполняется за константное время *O(1)*. +4. **Получение элемента с вершины стека (peek)**: + * Возвращает элемент, находящийся на вершине стека, без его удаления. + * Эта операция также выполняется за константное время *O(1)*. + +Стек — важная структура данных, которая находит применение во многих областях программирования и алгоритмов благодаря своей простоте и эффективности операций вставки и удаления элементов. Он используется для реализации обратного порядка доступа к данным, управления вызовами функций, выполнения операций undo/redo и в других сценариях, где требуется LIFO-порядок доступа к элементам. + +## 35 Очередь + +Очередь (Queue) в контексте структур данных представляет собой коллекцию элементов, которая работает по принципу "первым пришёл — первым вышел" (First-In-First-Out, FIFO). Это означает, что элементы добавляются в конец очереди, а извлекаются из её начала. Очередь часто используется для моделирования процесса управления задачами и в различных алгоритмах, где важен порядок выполнения операций. + +### Основные операции с очередью + +1. **Добавление элемента (enqueue)**: + * Элемент добавляется в конец очереди. + * Эта операция выполняется за константное время *O(1)*. +2. **Извлечение элемента (dequeue)**: + * Элемент извлекается из начала очереди. + * Эта операция также выполняется за константное время *O(1)*. +3. **Проверка наличия элементов (empty)**: + * Проверка, содержит ли очередь элементы. + * Эта операция также выполняется за константное время *O(1)*. +4. **Получение элемента из начала очереди (peek)**: + * Возвращает элемент, находящийся в начале очереди, без его удаления. + * Также выполняется за константное время *O(1)*. + +Очередь — важная структура данных, обеспечивающая упорядоченное выполнение операций по принципу FIFO. Она применяется в различных областях, таких как обработка задач, моделирование систем с ограниченным доступом и реализация различных алгоритмов, где важен порядок выполнения операций. + +## 36 Множество + +Множество в контексте структур данных представляет собой коллекцию элементов, где каждый элемент уникален (то есть в множестве не может быть повторяющихся элементов). Основные характеристики множества включают в себя: + +1. **Уникальность элементов**: В множестве не может содержаться два одинаковых элемента. Если элемент уже присутствует в множестве и попытаться добавить его снова, то операция добавления просто не изменит состояние множества. +2. **Операции с множеством**: + * **Добавление элемента**: *O(1)* + * **Удаление элемента**: *O(1)* + * **Поиск элемента**: *O(1)* +3. **Пример использования**: + * Множества полезны для хранения уникальных значений и быстрого выполнения операций проверки наличия элемента и его добавления или удаления. + * Часто используются для удаления дубликатов из коллекций, проверки уникальности элементов или для реализации различных алгоритмов, где необходимо поддерживать набор уникальных элементов. + +Множества предоставляют удобный и эффективный способ работы с уникальными данными во многих сценариях программирования и алгоритмических задачах. + +## 38 Двоичное дерево поиска + +Двоичное дерево поиска (Binary Search Tree, BST) — это бинарное дерево данных, которое обеспечивает эффективное хранение и поиск упорядоченных данных. Каждый узел в таком дереве содержит ключ и ссылки на два поддерева: левое поддерево, где ключи меньше ключа текущего узла, и правое поддерево, где ключи больше ключа текущего узла. + +### Основные характеристики двоичного дерева поиска + +1. **Упорядоченность**: Все ключи в левом поддереве любого узла *x* меньше ключа узла *x*, а все ключи в правом поддереве больше ключа узла *x*. +2. **Операции**: + * **Поиск**: Операция поиска ключа в дереве выполняется за время, пропорциональное высоте дерева, то есть *O(h)*, где *h* — высота дерева. В сбалансированном BST высота близка к *\log n*, где *n* — количество узлов в дереве. + * **Вставка**: Вставка нового элемента происходит также за время *O(h)*. Для вставки элемента нужно спуститься по дереву до нужного места и добавить новый узел в соответствующее поддерево. + * **Удаление**: Удаление узла из дерева также происходит за время *O(h)*. В зависимости от структуры дерева может потребоваться выполнить различные операции для поддержания упорядоченности. +3. **Преимущества**: + * Двоичные деревья поиска обеспечивают эффективные операции поиска, вставки и удаления, особенно в сбалансированных вариантах, таких как AVL-деревья или красно-чёрные деревья. + * Они удобны для реализации ассоциативных массивов и словарей. + +Двоичные деревья поиска представляют собой важную структуру данных, которая обеспечивает эффективное хранение и операции с упорядоченными данными. Важно учитывать, что эффективность операций зависит от структуры дерева, и в некоторых случаях может потребоваться сбалансировка для обеспечения оптимальной производительности. + +## 39 Префиксное дерево поиска + +Префиксное дерево поиска, также известное как Trie (от английского "retrieval"), это структура данных, используемая для хранения ассоциативных массивов, где ключами являются строки. Она позволяет эффективно осуществлять операции вставки, удаления и поиска по строкам, а также выполнять операции с префиксами. + +### Основные характеристики префиксного дерева (Trie) + +1. **Структура узлов**: + * Каждый узел представляет собой элемент дерева и содержит ссылки на дочерние узлы. + * Узлы могут быть либо ветвями, либо листьями. Листья часто содержат дополнительную информацию, например, флаги, указывающие на конец строки. + +2. **Вставка**: + * При вставке строки в Trie каждый символ строки последовательно добавляется как узел дерева. + * Если символ уже существует в текущем узле, просто переходим к следующему символу. + * Если символ отсутствует, создаем новый узел. + * После вставки строки можно установить флаг конца строки в последний узел. + +3. **Поиск**: + * Поиск строки в Trie выполняется путем последовательного прохода по символам строки. + * Начиная с корня, для каждого символа проверяется, существует ли соответствующая ветвь в текущем узле. + * Если вся строка найдена (и флаг конца строки установлен), операция поиска завершается успешно. + +4. **Удаление**: + * Удаление строки из Trie требует удаления всех узлов, соответствующих символам этой строки. + * При этом необходимо обращать внимание на сохранение структуры Trie и удаление только тех узлов, которые больше не используются другими ключами. + +5. **Применение**: + * Trie часто используется для реализации словарей, автодополнения в текстовых редакторах, поиска слов в текстах и других задач, где необходимо эффективно работать с множеством строк и их префиксами. + * Эта структура данных также полезна при реализации алгоритмов сжатия данных, обработки текстов и различных форм индексации. + +### Пример префиксного дерева (Trie) + +Рассмотрим Trie, содержащий строки "tea", "ted", "ten", "a", "in", "inn". + +```text + root + / | \ + t a i + /|\ \ + e d n n + / \ \ + a e n +``` + +В этом примере: + +* Каждый узел представляет символ строки. +* Листья соответствуют завершению строк, например, узел 'n' в слове 'ten' имеет флаг конца строки. + +### Заключение + +Префиксные деревья (Trie) представляют собой мощную структуру данных для эффективного хранения и поиска строковых данных. Они позволяют быстро находить строки и их префиксы, что делает их идеальными для решения ряда задач в области обработки текстовой информации и структурирования данных. + +## 40 Сложность алгоритма. Сложность в среднем и худшем cлучае. O-нотация + +Сложность алгоритма — это мера, которая описывает, как быстро возрастает время выполнения алгоритма по мере увеличения размера входных данных. Она может быть выражена с помощью O-нотации, указывающей верхнюю границу времени выполнения алгоритма в зависимости от размера входных данных. + +O-нотация — это математическая нотация, которая используется для описания асимптотической сложности алгоритмов. Она позволяет определить, как быстро возрастает время выполнения алгоритма в зависимости от размера входных данных *n*. + +### Примеры O-нотации + +* **O(1)**: Константная сложность. Время выполнения алгоритма не зависит от размера входных данных. Пример: доступ к элементу в массиве по индексу. +* **O(log n)**: Логарифмическая сложность. Время выполнения алгоритма растёт логарифмически с ростом размера входных данных. Пример: бинарный поиск в отсортированном массиве. +* **O(n)**: Линейная сложность. Время выполнения алгоритма линейно зависит от размера входных данных. Пример: последовательный поиск в неотсортированном массиве. +* **O(n^2)**: Квадратичная сложность. Время выполнения алгоритма пропорционально квадрату размера входных данных. Пример: сортировка пузырьком. +* **O(2^n)**: Экспоненциальная сложность. Время выполнения алгоритма растёт экспоненциально с ростом размера входных данных. Пример: решение задачи коммивояжёра перебором всех возможных путей. + +### Виды сложности + +1. **В среднем случае (Average Case Complexity)**: Это оценка среднего времени выполнения алгоритма для всех возможных входных данных размера *n*. Сложность в среднем случае обычно используется в анализе случайных алгоритмов, где предполагается равновероятное возникновение всех возможных входов. +2. **В худшем случае (Worst Case Complexity)**: Это оценка максимального времени выполнения алгоритма для любого входного набора размера *n*. Сложность в худшем случае является наиболее пессимистичной оценкой времени выполнения, так как она определяет верхнюю границу времени выполнения алгоритма при наихудших условиях входных данных. + +### Значение сложности алгоритма + +Знание сложности алгоритма важно для оценки его эффективности и выбора наиболее подходящего метода решения задачи в зависимости от требований к скорости и используемых ресурсов. O-нотация позволяет сравнивать алгоритмы и прогнозировать их поведение при различных входных данных. + +## 42 АВЛ-дерево + +АВЛ-дерево (AVL Tree) — это форма самобалансирующегося бинарного дерева поиска, в котором для каждого узла разница высоты его двух дочерних поддеревьев (баланс-фактор) равна -1, 0 или +1. Это означает, что высоты поддеревьев каждого узла различаются не более чем на один уровень, что обеспечивает логарифмическую временную сложность для операций поиска, вставки и удаления. + +### Основные характеристики АВЛ-дерева + +1. **Самобалансировка**: Каждый раз, когда выполняется операция вставки или удаления, АВЛ-дерево проверяет баланс своих узлов и, при необходимости, выполняет повороты (rotations), чтобы восстановить баланс. +2. **Баланс-фактор**: Для каждого узла в АВЛ-дереве вычисляется баланс-фактор, который равен разности высоты правого поддерева и высоты левого поддерева узла. Баланс-фактор должен быть -1, 0 или +1 для всех узлов. +3. **Операции**: + * **Поиск**: Выполняется аналогично обычному бинарному дереву поиска за время *O(log n)*, где *n* — количество узлов в дереве. + * **Вставка**: После вставки нового узла АВЛ-дерево проверяет баланс и, при необходимости, выполняет повороты, чтобы восстановить баланс. Вставка также выполняется за время *O(log n)*. + * **Удаление**: После удаления узла АВЛ-дерево также проверяет баланс и, при необходимости, выполняет повороты, чтобы восстановить баланс. Удаление также выполняется за время *O(log n)*. +4. **Преимущества**: + * АВЛ-дерево обеспечивает быстрые операции поиска, вставки и удаления благодаря строгому соблюдению баланса. + * Гарантированная логарифмическая сложность операций делает его подходящим для широкого спектра задач, где требуется эффективное управление данными. + +АВЛ-дерево является важной структурой данных, обеспечивающей эффективную балансировку во время операций вставки, удаления и поиска. Оно находит широкое применение в базах данных, компиляторах, поисковых системах и других приложениях, где требуется быстрый доступ к данным с гарантированным временем выполнения операций. + +## 43 Красно-черное дерево + +Красно-чёрное дерево (Red-Black Tree) — это форма самобалансирующегося бинарного дерева поиска, которое гарантирует логарифмическую временную сложность для основных операций, таких как вставка, удаление и поиск. Оно получило своё название благодаря двум основным свойствам узлов: они либо красные, либо черные, и удовлетворяют определённым правилам балансировки. + +### Основные характеристики красно-чёрного дерева + +1. **Самобалансировка**: Каждый узел в красно-чёрном дереве имеет дополнительное поле — цвет (красный или черный), которое используется для поддержания баланса в дереве. +2. **Основные правила**: + * Узлы могут быть красными или черными. + * Корень дерева всегда черный. + * Все листья (NIL-узлы) являются черными. + * Если узел красный, то его потомки должны быть черными. + * Для каждого узла все пути от узла до его листьев должны содержать одинаковое количество черных узлов. Это свойство называется "черная высота". +3. **Операции**: + * **Поиск**: Операция поиска в красно-чёрном дереве выполняется так же, как и в обычном бинарном дереве поиска, за время *O(log n)*, где *n* — количество узлов в дереве. + * **Вставка**: После вставки нового узла дерево перебалансируется (при необходимости), чтобы сохранить все свойства красно-чёрного дерева. Вставка также выполняется за время *O(log n)*. + * **Удаление**: После удаления узла дерево также может потребовать перебалансировки для сохранения свойств. Удаление также выполняется за время *O(log n)*. +4. **Применение**: + * Красно-чёрные деревья широко используются в реализации словарей, ассоциативных массивов и других структур данных, где требуется эффективное управление данными с гарантированной сложностью операций. + +Красно-чёрные деревья являются важной структурой данных, обеспечивающей эффективную балансировку при операциях вставки, удаления и поиска. Они широко используются в различных приложениях и алгоритмах благодаря своей эффективности и предсказуемости времени выполнения операций. + +## 44 Splay-дерево + +Splay-дерево (Splay Tree) — это самобалансирующееся бинарное дерево поиска, которое обеспечивает эффективный доступ, вставку и удаление элементов. Основная особенность Splay-дерева заключается в том, что оно поддерживает операцию "splay" после каждой основной операции (поиска, вставки или удаления), чтобы поддерживать оптимальное распределение элементов и высокую скорость доступа к данным. + +### Основные характеристики Splay-дерева + +1. **Самобалансировка**: После каждой операции (поиска, вставки, удаления) узлы поднимаются ближе к корню (splay), что улучшает время доступа к наиболее часто используемым элементам. + +2. **Локальность**: Splay-дерево основывается на предположении, что операции с элементами, к которым часто обращаются, должны быть быстрыми, поскольку такие элементы часто окажутся ближе к корню. + +3. **Бинарное дерево поиска**: Каждый узел имеет не более двух потомков, и ключи в левом поддереве меньше ключа узла, а ключи в правом поддереве больше. + +4. **Операции**: + * **Поиск**: При поиске узел, найденный по ключу, поднимается к корню (splay). + * **Вставка**: Вставка элемента происходит как в обычном бинарном дереве поиска, после чего вставленный узел поднимается к корню. + * **Удаление**: Удаление элемента также происходит как в обычном бинарном дереве поиска, с последующим "сплэем" узла, который стал корнем после удаления. + +5. **Эффективность**: + * В среднем и худшем случае операции в Splay-дереве имеют амортизированную временную сложность *O(log n)*, где *n* — количество элементов в дереве. + * В лучшем случае, когда все операции сосредоточены в одной части дерева, могут возникнуть худшие случаи, когда операции могут занимать *O(n)* времени. + +Splay-дерево — это эффективная структура данных, которая обеспечивает балансировку в процессе выполнения операций, что делает его подходящим выбором для приложений, где требуется частый доступ к часто используемым элементам. Оно широко используется в реализации кешей, ассоциативных массивов и других задач, где требуется эффективное управление данными. + +## 45 Двоичная куча + +Двоичная куча (Binary Heap) — это структура данных, представляющая собой полное бинарное дерево, в котором каждый узел имеет ключ больше (или меньше, в зависимости от типа кучи) ключей своих потомков. Двоичные кучи обеспечивают эффективный доступ к элементу с наивысшим (или наименьшим) приоритетом, что делает их полезными для реализации приоритетных очередей и других алгоритмов, где необходим быстрый доступ к наибольшему (наименьшему) элементу. + +### Основные характеристики двоичной кучи + +1. **Типы куч**: + * **Максимальная двоичная куча (Max-Heap)**: В каждом узле ключ больше или равен ключам его потомков. + * **Минимальная двоичная куча (Min-Heap)**: В каждом узле ключ меньше или равен ключам его потомков. + +2. **Структура**: + * Двоичная куча обычно представляется в виде массива, где элементы располагаются таким образом, что для любого узла с индексом *i*: + * Левый потомок узла *i* имеет индекс *2i + 1*. + * Правый потомок узла *i* имеет индекс *2i + 2*. + * Родитель узла *i* имеет индекс *(i - 1) / 2*. + +3. **Операции**: + * **Вставка**: Новый элемент добавляется в конец массива, затем происходит "всплытие" (heapify-up), чтобы восстановить свойство кучи. + * **Извлечение максимального (минимального) элемента**: Корень (самый приоритетный элемент) удаляется, последний элемент массива перемещается на его место, и затем происходит "погружение" (heapify-down), чтобы восстановить свойство кучи. + * **Построение кучи**: Преобразование неупорядоченного массива в кучу за линейное время *O(n)*. + * **Удаление произвольного элемента**: Удаление элемента в произвольной позиции, затем перестройка кучи. + +4. **Применение**: + * Двоичные кучи часто используются для реализации приоритетных очередей и алгоритмов, таких как алгоритм сортировки Heapsort. + * Они также полезны для решения задач, где требуется эффективное нахождение наибольшего (наименьшего) элемента, например, в алгоритмах поиска кратчайших путей (например, алгоритм Дейкстры). + +Двоичные кучи представляют собой важную структуру данных, которая обеспечивает эффективный доступ и изменение наибольшего (или наименьшего) элемента. Их использование позволяет реализовать различные алгоритмы с оптимальной временной сложностью операций, что делает их важным инструментом в области алгоритмов и структур данных. + +## 46 Хэш-таблица + +### Краткий ответ + +Хэш-таблица — это структура данных, которая использует хэширование для быстрого доступа к данным. Она основана на принципе хранения данных с использованием хэш-функции, которая отображает ключи на индексы массива, где хранятся значения. + +### Развернутый ответ + +Хэш-таблица — это одна из самых эффективных структур данных для реализации ассоциативных массивов или словарей, где каждый элемент (запись) ассоциируется с уникальным ключом. Основная идея заключается в использовании хэш-функции для преобразования ключа в индекс массива, в котором будет храниться соответствующее значение. Это позволяет достигать очень быстрого доступа к данным (в среднем за константное время *O(1)*). + +### Преимущества хэш-таблиц + +* **Быстрый доступ**: В среднем время доступа *O(1)*, что делает хэш-таблицы очень эффективными для операций поиска, вставки и удаления элементов. +* **Универсальность**: Хэш-таблицы могут использоваться для различных задач, включая реализацию словарей, кэширование данных, проверку уникальности элементов и т.д. + +Хэш-таблицы широко применяются в программировании и являются основой для реализации словарей во многих языках программирования, таких как Python, Java, C++, и других. Их эффективность и универсальность делают их неотъемлемой частью современных вычислительных систем. + +## 47 Алгоритм шифрования Цезаря + +Алгоритм шифрования Цезаря — это метод шифрования, при котором каждая буква в открытом тексте заменяется на букву, находящуюся на некотором постоянном числе позиций левее или правее в алфавите. +Алгоритм шифрования Цезаря один из самых простых и известных методов шифрования, который был использован ещё в древности. Он назван в честь римского полководца Юлия Цезаря, который использовал этот метод для секретной переписки. + +### Принцип работы алгоритма + +1. **Выбор ключа шифрования**: Выбирается число *k*, которое называется ключом шифрования. Это число определяет, на сколько позиций в алфавите сдвигаются буквы. + +2. **Шифрование открытого текста**: Каждая буква открытого текста заменяется на букву, которая находится на *k* позиций вперёд или назад по алфавиту (в зависимости от выбранного направления шифрования). + +3. **Дешифрование шифротекста**: Для расшифровки шифротекста используется тот же ключ *k*, но сдвиг происходит в обратном направлении (т.е. в другую сторону по алфавиту). + +### Значение и применение + +Алгоритм шифрования Цезаря имеет простую реализацию и предназначен для защиты информации от неавторизованного доступа в случае, когда требуется быстрая и надёжная зашифровка текста. Однако он не обеспечивает высокой степени защиты в современных условиях из-за простоты алгоритма и возможности легкого взлома методами криптоанализа. + +### Пример + +```python +from string import ascii_lowercase + + +def caesar_cipher(alphabet: str, key: int, message: str) -> str: + new_message = "" + for char in message: + is_upper = char.isupper() + char = char.lower() + + if char not in alphabet: + new_message += char + continue + + index_of_new_char = (alphabet.find(char) + key) % len(alphabet) + new_char = alphabet[index_of_new_char] + new_message += new_char.upper() if is_upper else new_char + + return new_message + + +def main() -> None: + input_message = input("Please enter text: ") + key = int(input("Please enter key: ")) + alphabet = ascii_lowercase + + encrypted_message = caesar_cipher(alphabet, key, input_message) + print("Encrypted message:", encrypted_message) + + decrypted_message = caesar_cipher(alphabet, -key, encrypted_message) + print("Decrypted message:", decrypted_message) + + +if __name__ == "__main__": + main() +``` + +## 48 Блочные алгоритмы шифрования + +Блочные алгоритмы шифрования представляют собой методы шифрования, которые оперируют не отдельными символами или битами, а блоками данных фиксированного размера. Эти алгоритмы широко используются для защиты данных в современных криптографических приложениях. Вот несколько основных блочных алгоритмов шифрования: AES, DES, ГОСТ 28147-89 + +## 49 Понятие о графе + +### Краткий ответ + +Граф — это абстрактная математическая структура, которая представляет собой набор вершин (узлов) и рёбер (связей) между этими вершинами. + +### Развернутый ответ + +#### Основные понятия + +1. **Вершина (узел)**: Каждая точка или объект в графе, которая может иметь определённые атрибуты или свойства. +2. **Ребро (связь)**: Связь между двумя вершинами, которая может быть направленной или не направленной. Направленное ребро указывает на однонаправленную связь между вершинами, тогда как не направленное ребро представляет собой двустороннюю связь. +3. **Вес ребра**: Дополнительная информация, связанная с ребром, которая может представлять его стоимость, расстояние или другие метрики. +4. **Путь**: Последовательность рёбер, которая соединяет вершины в графе. + +#### Типы графов + +* **Ориентированный граф**: Граф, в котором рёбра имеют направление. Также известен как диграф. +* **Неориентированный граф**: Граф, в котором рёбра не имеют направления. Все рёбра двунаправленные. +* **Взвешенный граф**: Граф, в котором каждое ребро имеет ассоциированный вес, который может представлять стоимость, длину и т.д. +* **Невзвешенный граф**: Граф, в котором рёбра не имеют веса. +* **Ациклический граф**: Граф, в котором нет циклов. Также известен как DAG (Directed Acyclic Graph) для ориентированных графов. + +#### Применение графов + +Графы широко используются в различных областях, включая: + +* **Социальные сети**: Представление дружеских связей между людьми. +* **Транспортные сети**: Моделирование дорог, маршрутов, логистики. +* **Компьютерные сети**: Представление сетевых узлов и соединений. +* **Биоинформатика**: Представление генетических структур и их взаимодействий. +* **Алгоритмы и структуры данных**: Множество алгоритмов работает на основе графов (например, поиск в ширину, поиск в глубину). + +#### Представление графа + +Граф можно представить с использованием матриц смежности или списков смежности: + +* **Матрица смежности**: Квадратная матрица, где значение *A[i][j]* показывает наличие (или отсутствие) ребра между вершинами *i* и *j*. +* **Список смежности**: Для каждой вершины хранится список смежных с ней вершин. + +## 50 Алгоритм Прима + +Алгоритм Прима — это алгоритм для нахождения минимального остовного дерева во взвешенном связном графе. Он был разработан чешским математиком Робертом Примом в 1930 году. Основная идея алгоритма заключается в построении остовного дерева путём последовательного добавления к нему рёбер с минимальным весом, при этом обеспечивая отсутствие циклов. + +### Краткий алгоритм Прима + +1. **Инициализация**: Выбирается начальная вершина графа (обычно это любая вершина, откуда начинается строительство дерева). + +2. **Выбор рёбер**: На каждом шаге выбирается ребро с наименьшим весом, которое соединяет уже включенные в остовное дерево вершины с вершинами, не включенными. + +3. **Добавление ребра**: Выбранное ребро добавляется к остовному дереву. + +4. **Обновление списка доступных рёбер**: После добавления нового ребра обновляется список рёбер, которые соединяют вершины остовного дерева с оставшимися вершинами. + +5. **Повторение**: Шаги 2-4 повторяются, пока все вершины графа не будут включены в остовное дерево. + +Алгоритм Прима является эффективным методом для нахождения минимального остовного дерева и находит широкое применение в различных областях, включая сетевое проектирование, транспортные и логистические задачи, а также в теории алгоритмов и компьютерных сетях. + +## 51 Число связности + +Число связности (Connectivity Number) в теории графов обозначает минимальное количество вершин, которое необходимо удалить из графа, чтобы он перестал быть связным. В контексте графов, число связности часто используется для определения степени сетевой надёжности или для оценки влияния отказа на работоспособность системы. + +### Основные понятия + +1. **Связный граф**: Граф, в котором существует путь между любыми двумя вершинами. +2. **Компоненты связности**: Связный граф может состоять из нескольких связных подграфов, называемых компонентами связности. +3. **Число связности**: Минимальное количество вершин, которое необходимо удалить, чтобы граф перестал быть связным. + +### Примеры использования + +* **Транспортная инфраструктура**: Оценка минимального количества аварийных ситуаций (отключенных дорог или мостов), при которых граф транспортных маршрутов перестанет быть связным. +* **Компьютерные сети**: Определение минимального числа компонент отказа, которые могут привести к разделению сети на несколько изолированных подсетей. +* **Электрические сети**: Оценка минимального числа повреждений, при которых электрическая сеть разобъется на несколько изолированных сегментов. + +## 52 Матрицы смежности и инцидентности графа + +![img](./img/матрица_смежности.png) + +![img](./img/матрица_инцедентности.png) + +## 53 Алгоритм ближайшего соседа + +Алгоритм ближайшего соседа (Nearest Neighbor Algorithm) — это жадный алгоритм для решения задачи коммивояжёра, который стремится найти приближённое решение, близкое к оптимальному. Задача коммивояжёра заключается в нахождении самого короткого маршрута, проходящего через все города (вершины графа), возвращаясь в начальную точку. + +### Описание алгоритма + +1. **Выбор начальной вершины**: Выбирается начальная вершина (город). +2. **Поиск ближайшего соседа**: На каждом шаге текущая вершина соединяется с ближайшей ещё не посещённой вершиной. Это означает выбор вершины, к которой минимальное расстояние от текущей вершины. +3. **Посещение вершины**: После выбора ближайшей вершины она помечается как посещённая. +4. **Повторение**: Шаги 2 и 3 повторяются до тех пор, пока все вершины не будут посещены. +5. **Возвращение в начальную вершину**: После посещения всех вершин, последняя выбранная вершина соединяется с начальной вершиной, завершая цикл. +6. **Вычисление общей длины маршрута**: Вычисляется общее расстояние (длина маршрута), пройденного по этому маршруту. + +### Сложность алгоритма ближайшего соседа + +* Время выполнения: *O(n^2)*, где *n* — количество вершин. Это связано с необходимостью выполнить *n* итераций (поиск ближайшего соседа на каждом шаге) и *n* проверок. +* Память: *O(n)*, для хранения списка посещённых вершин. + +Алгоритм ближайшего соседа хоть и не гарантирует оптимальное решение, но часто применяется для быстрого нахождения приближённого решения задачи коммивояжёра в случае больших графов, где точное решение затруднительно или слишком долгое для вычисления. + +## 54 Расширенный алгоритм Евклида + +Расширенный алгоритм Евклида — это алгоритм для нахождения наибольшего общего делителя (НОД) двух целых чисел *a* и *b*, а также нахождения целочисленных коэффициентов *x* и *y*, таких что *ax + by = НОД(a, b)*. + +### Шаги расширенного алгоритма Евклида + +1. **Инициализация**: Начинаем с базовых значений: + * *gcd(a, b)* — текущий НОД, начально *a* и *b*. + * *x_0 = 1, y_0 = 0* + * *x_1 = 0, y_1 = 1* +2. **Итерационный процесс**: Пока *b != 0*: + * Вычисляем остаток от деления *a* на *b*: *r = a mod b*. + * Вычисляем новые коэффициенты *x* и *y*: + + *x = x_0 - (a // b) * x_1* + + *y = y_0 - (a // b) * y_1* + + * Обновляем значения: *a = b, b = r*, *x_0 = x_1, x_1 = x*, *y_0 = y_1, y_1 = y*. +3. **Результат**: По завершении алгоритма *gcd(a, b)* будет содержать НОД *a* и *b*, а переменные *x* и *y* будут соответствующими коэффициентами, удовлетворяющими уравнению *ax + by = НОД(a, b)*. + +### Применение расширенного алгоритма Евклида + +Расширенный алгоритм Евклида часто используется в криптографии, особенно в алгоритмах шифрования и подписи, где необходимо работать с обратимыми операциями по модулю. Например, он может использоваться для нахождения обратного элемента по модулю *n*, который важен для реализации алгоритмов RSA и других криптографических протоколов. Также он применяется в различных математических задачах, требующих нахождения решений линейных диофантовых уравнений. + +### Пример + +```python +def gcd_extended(a: int, b: int) -> tuple[int, int, int]: + if b == 0: + return a, 1, 0 + + gcd, x, y = gcd_extended(b, a % b) + return gcd, y, x - (a // b) * y + + +def main() -> None: + print(gcd_extended(240, 46)) + + +if __name__ == "__main__": + main() +``` + +## 55 Шифрование с открытым ключом (RSA) + +RSA (Rivest–Shamir–Adleman) — один из наиболее известных и широко используемых алгоритмов криптографии с открытым ключом. Он был разработан в 1977 году Рональдом Ривестом, Ади Шамиром и Леонардом Адлеманом. Основная особенность RSA заключается в том, что он использует два ключа: открытый и закрытый, что обеспечивает безопасное шифрование и подпись данных. + +### Основные шаги работы RSA + +1. **Генерация ключей**: + * Выбираются два больших простых числа *p* и *q*. + * Вычисляется их произведение *n = p * q*, которое становится модулем для RSA. + * Вычисляется значение функции Эйлера *phi(n) = (p-1)(q-1)*. +2. **Выбор открытой экспоненты**: + * Выбирается целое число *e*, взаимно простое с *phi(n)* (такое, что *gcd(e, phi(n)) = 1*). +3. **Вычисление закрытой экспоненты**: + * Находится число *d*, обратное *e* по модулю *\phi(n)* (такое, что *e * d == 1 mod phi(n)*). +4. **Шифрование и дешифрование**: + * **Шифрование**: Для шифрования сообщения *M* с использованием открытого ключа *(e, n)* вычисляется *C = M^e mod n*. + * **Дешифрование**: Для расшифровки шифротекста *C* с использованием закрытого ключа *(d, n)* вычисляется *M = C^d mod n*. + +**P.S.** Я ебал это все писать + +--- + +***With ❤️ by NKTKLN*** diff --git a/Second term/Algorithms/exam/questions-sdo-version.md b/Second term/Algorithms/exam/questions-sdo-version.md new file mode 100755 index 0000000..6792fed --- /dev/null +++ b/Second term/Algorithms/exam/questions-sdo-version.md @@ -0,0 +1,365 @@ +# Вопросы из СДО + +## 1. Понятие алгоритма + +Алгоритм – это последовательность шагов, предназначенная для решения конкретной задачи или достижения цели. + +## 2. Основные свойства алгоритма + +* Дискретность: Алгоритм состоит из отдельных шагов. +* Понятность: Каждый шаг должен быть понятен исполнителю (компьютеру). +* Определённость: Результат каждого шага однозначно определяется. +* Результативность: Алгоритм должен приводить к результату за конечное число шагов. +* Массовость: Алгоритм должен быть применим для решения целого класса задач. + +## 3. Способы описания алгоритма + +* Словесный: Обычный текст, как рецепт. +* Графический: Блок-схемы, где каждый блок - это действие. +* Программный: На языке программирования, понятном компьютеру. + +## 4. Линейные алгоритмы + +Линейные алгоритмы выполняются последовательно, шаг за шагом, без ветвлений и циклов. + +## 5. Ветвящиеся алгоритмы + +Ветвящиеся алгоритмы включают условия, по которым выполнение алгоритма может пойти по разным путям. + +## 6. Циклические алгоритмы + +Циклические алгоритмы выполняют определённые действия многократно, пока выполняется заданное условие. + +## 7. Решение уравнения методом деления отрезка пополам + +![img](./img/метод_половинного_деления.png) + +## 8. Решение уравнения методом касательных + +![img](./img/метод_касательных.png) + +## 9. Решение уравнения методом хорд + +Метод хорд — итерационный численный метод приближённого нахождения корня уравнения. + +Половинное деление не учитывает никаких свойств функции F(x), а эта функция может нести в себе очень полезную информацию. Метод хорд предполагает следующее. От точек, ограничивающих кривую (заданные концы отрезка L и R), строится хорда, затем определяется точка её пересечения с осью абсцисс, точка пересечения становится новой границей отрезка, после чего строится новая хорда. Итерационный процесс задается следующей формулой: + +![img](./img/формула_метод_хорд.png) + +--- + +## 10. Метод наименьших квадратов. Регрессия + +--- + +## 11. Алгоритм Евклида для поиска наибольшего общего делителя + +Хорошее решение проблемы поиска наибольшего общего делителя двух чисел нашел еще Евклид. В самом простом случае алгоритм Евклида применяется к паре положительных целых чисел и формирует новую пару, которая состоит из меньшего числа и разницы между большим и меньшим числом. Процесс повторяется, пока числа не станут равными. Найденное число и есть наибольший общий делитель исходной пары. Блок-схема алгоритма выглядит следующим образом: + +![img](./img/евклид.png) + +![img](./img/пример_евклида.png) + +## 12. Понятие о факторизации числа + +Факторизация числа — это процесс разложения числа на простые множители. + +## 13. Алгоритм Ферма факторизации + +![img](./img/алгоритм_ферма.png) + +## 14. Алгоритмы поиска простых чисел. Решето Эратосфена + +### Решето Эратосфена + +![img](./img/решето_Эратосфена.png) + +## 15. Числа Мерсенна. Тест Люка-Лемера + +Число Мерсе́нна — число вида 2n-1, где n — натуральное число; такие числа примечательны тем, что некоторые из них являются простыми при больших значениях n. Названы в честь французского математика Маре́на Мерсенна, исследовавшего их свойства в XVII веке. + +Для проверки числа Мерсенна на простоту существует простой тест Люка-Лемера. Это алгоритм, который предполагает на первом этапе построение последовательности по следующему правилу: + +![img](./img/тест_мерсена.png) + +## 16. Псевдослучайные числа + +В различных технических и математических приложениях часто необходим ряд случайных чисел. Числа называются случайными в силу того, что в их ряду нет никакой закономерности, зная некоторое количество последовательных чисел ряда, нельзя вычислить следующее. + +Алгоритм фон Неймана для генерации псевдослучайных чисел состоит в следующем. Предположим, что некоторое случайное, достаточно большое число уже известно. Определить такое число совершенно не представляет проблему: так как оно первое, то оно может быть просто любым. Пусть, например, нас интересуют 5-значные случайные числа. Возьмем в качестве первого число 14 563. Возведем его в квадрат, получим 212 080 969. Возьмем из середины пять цифр 20 809. Это и будет следующее случайное число. Псевдослучайность получаемой последовательности очевидна. Каждое следующее число совершенно однозначно определяется предыдущим. Но нас это смущать не должно. Если неизвестно, как получены числа, то они выглядят вполне случайно. Но у метода есть более серьезный недостаток. Если последовательность продолжить, то может проявиться так называемый период. Периодом называется строго повторяющаяся последовательность чисел. Впрочем, для алгоритма фон Неймана можно подобрать исходное число, дающее период только после очень большого количества шагов. + +## 17. Метод Карацубы для быстрого умножения двух чисел + +Метод Карацубы — это алгоритм для быстрого умножения двух больших чисел, который основывается на принципе декомпозиции чисел на более мелкие части и рекурсивного использования умножения. Этот метод позволяет значительно уменьшить количество элементарных операций по сравнению с классическим методом умножения. + +![img](./img/метод_Карацубы.png) + +## 18. Алгоритм быстрого возведения в степень + +![img](./img/алгоритм_быстрого_возведения_в_степень.png) + +## 19. Понятие о рекурсии + +Рекурсия — это такой способ организации вспомогательного алгоритма (подпрограммы), при котором эта подпрограмма (процедура или функция) в ходе выполнения ее операторов обращается сама к себе. То есть в теле функции она вызывает саму себя. + +## 20. Числа Фибоначчи + +Числа Фибоначчи — это последовательность чисел, где каждое следующее число равно сумме двух предыдущих. Обычно последовательность начинается с чисел 0 и 1. + +## 21. Задача о Ханойской башне + +Задача о Ханойской башне — это классическая головоломка, которая состоит в перемещении всех дисков с одного стержня на другой, используя третий стержень в качестве промежуточного, с условием, что на более крупный диск нельзя класть меньший. + +## 22. Динамическое программирование + +Динамическое программирование (DP) — это метод решения сложных задач путём разбиения их на более простые подзадачи и сохранения результатов этих подзадач для последующего использования. + +### Основные принципы + +1. **Разбиение задачи**: Исходная задача разбивается на несколько подзадач. +2. **Сохранение результатов**: Результаты каждой подзадачи сохраняются для последующего повторного использования. +3. **Комбинирование результатов**: Результаты подзадач комбинируются для получения решения исходной задачи. + +## 23. Задача сортировки массива + +Сортировка массива — это процесс упорядочивания элементов массива в определенном порядке, таком как по возрастанию или убыванию. + +## 24. Алгоритм пузырьковой сортировки + +Алгоритм состоит из повторяющихся проходов по сортируемому массиву. За каждый проход элементы последовательно сравниваются попарно и, если порядок в паре неверный, выполняется перестановка элементов. Проходы по массиву повторяются N-1 раз или до тех пор, пока на очередном проходе не окажется, что обмены больше не нужны, что означает — массив отсортирован. При каждом проходе алгоритма по внутреннему циклу очередной наибольший элемент массива ставится на своё место в конце массива рядом с предыдущим «наибольшим элементом», а наименьший элемент перемещается на одну позицию к началу массива («всплывает» до нужной позиции, как пузырёк в воде — отсюда и название алгоритма). + +## 25. Алгоритм сортировки вставками + +Алгоритм сортировки, в котором элементы входной последовательности просматриваются по одному, и каждый новый поступивший элемент размещается в подходящее место среди ранее упорядоченных элементов. + +![img](./img/сортировка_вставками_пример.png) + +## 26. Алгоритм сортировки выбором + +Шаги алгоритма: + +1. находим номер минимального значения в текущем списке +2. производим обмен этого значения со значением первой неотсортированной позиции (обмен не нужен, если минимальный элемент уже находится на данной позиции) +3. теперь сортируем хвост списка, исключив из рассмотрения уже отсортированные элементы + +## 27. Алгоритм шейкерной сортировки + +Анализируя метод пузырьковой сортировки, можно отметить два обстоятельства. Во-первых, если при движении по части массива перестановки не происходят, то эта часть массива уже отсортирована и, следовательно, её можно исключить из рассмотрения. Во-вторых, при движении от конца массива к началу минимальный элемент «всплывает» на первую позицию, а максимальный элемент сдвигается только на одну позицию вправо. Эти две идеи приводят к следующим модификациям в методе пузырьковой сортировки. Границы рабочей части массива (то есть части массива, где происходит движение) устанавливаются в месте последнего обмена на каждой итерации. Массив просматривается поочередно справа налево и слева направо. + +## 28. Алгоритм сортировки Шелла + +Алгоритм сортировки, являющийся усовершенствованным вариантом сортировки вставками. Идея метода Шелла состоит в сравнении элементов, стоящих не только рядом, но и на определённом расстоянии друг от друга. Иными словами — это сортировка вставками с предварительными «грубыми» проходами. При сортировке Шелла сначала сравниваются и сортируются между собой значения, стоящие один от другого на некотором расстоянии d. После этого процедура повторяется для некоторых меньших значений d, а завершается сортировка Шелла упорядочиванием элементов при d=1 (то есть обычной сортировкой вставками). Эффективность сортировки Шелла в определённых случаях обеспечивается тем, что элементы «быстрее» встают на свои места (в простых методах сортировки, например, пузырьковой, каждая перестановка двух элементов уменьшает количество инверсий в списке максимум на 1, а при сортировке Шелла это число может быть больше) + +## 29. Алгоритм быстрой сортировки + +![img](./img/быстрая_сортировка.png) + +## 30. Алгоритм сортировки + +Алгоритм сортировки — это алгоритм для упорядочивания элементов в массиве. + +## 31. Основные структуры данных + +Структура данных — это способ организации информации для более эффективного использования. В программировании структурой обычно называют набор данных, связанных определённым образом. + +1. Массив (Array) +2. Динамический массив (Dynamic array) +3. Связный список (Linked list) +4. Стек (Stack) +5. Очередь (Queue) + +## 32. Массив и динамический массив + +### Массив + +Одна из самых простых структур данных, которая встречается чаще всего. Именно на массивах основаны многие другие структуры данных: списки, стеки, очереди. Для простоты восприятия можно считать, что массив — это таблица. Каждый его элемент имеет индекс — «адрес», по которому этот элемент можно извлечь. В большинстве языков программирования индексы начинаются с нуля. То есть первый элемент массива имеет индекс не [1], а [0]. Данные в массиве можно просматривать, сортировать и изменять с помощью специальных операций. + +Массивы бывают двух видов: + +* **Одномерные.** У каждого элемента только один индекс. Можно представить это как строку с данными, где одного номера достаточно, чтобы чётко определить положение каждой переменной. +* **Многомерные.** У каждого элемента два или больше индексов. По сути, это комбинация из нескольких одномерных массивов, то есть вложенная структура. + +Как применяют массивы: + +* В качестве блоков для более сложных структур данных. Массивы предусмотрены в синтаксисе большинства языков программирования, и на их основе удобно строить другие структуры. +* Для хранения несложных данных небольших объёмов. +* Для сортировки данных. + +### Динамический массив + +В классическом массиве размер задан заранее — мы точно знаем, сколько в нём индексов. А динамический массив — это тот, у которого размер может изменяться. При его создании задаётся максимальная величина и количество заполненных элементов. При добавлении новых элементов они сначала заполняются до максимальной величины, а при превышении сразу создаётся новый массив, с большей максимальной величиной. Элементы в динамический массив можно добавлять без ограничений и куда угодно. Однако, если добавлять их в середину, остальные придётся сдвигать, что занимает много времени. Поэтому лучше всего динамический массив работает при добавлении элементов в конце. + +Как применяют динамические массивы: + +* В качестве блоков для структур данных +* Для хранения неопределённого количества элементов + +## 33. Связный список + +Ещё одна базовая структура данных, которую, как и массивы, используют для реализации других структур. Связный список — это группа из узлов. В каждом узле содержатся: + +* Данные +* Указатель или ссылка на следующий узел +* В некоторых списках — ещё и ссылка на предыдущий узел + +В итоге получается список, у которого есть чёткая последовательность элементов. При этом сами элементы более разрозненны, чем в массиве, поскольку хранятся отдельно. Быстро перемещаться между элементами списка помогают указатели. + +Как применяют связные списки: + +* Для построения более сложных структур данных +* Для реализации файловых систем +* Для формирования хэш-таблиц +* Для выделения памяти в динамических структурах данных + +![img](./img/связанные_списки.png) + +## 34. Стек + +Эта структура данных позволяет добавлять и удалять элементы только из начала. Она работает по принципу LIFO — Last In, First Out (англ. «последним пришёл — первым ушёл»). Последний добавленный в стек элемент должен будет покинуть его раньше остальных. + +Как применяют стеки: + +* Для реализации рекурсии +* Для вычислений постфиксных значений +* Для временного хранения данных, например истории запросов или изменений + +![img](./img/стек.png) + +## 35. Очередь + +Этот вид структуры представляет собой ряд данных, как и стек. Но в отличие от него она работает по принципу FIFO — First In, First Out (англ. «первым пришёл — первым ушёл»). Данные добавляют в конец, а извлекают из начала. + +![img](./img/очередь.png) + +## 36. Множество + +Множество в контексте структур данных представляет собой коллекцию элементов, где каждый элемент уникален (то есть в множестве не может быть повторяющихся элементов). + +## 37. Карта + +Карта - это структура данных, содержащая пары ключ-значение. + +![img](./img/карта.png) + +## 38. Двоичное дерево поиска + +Двоичное дерево поиска (англ. binary search tree, BST) — двоичное дерево, для которого выполняются следующие дополнительные условия (свойства дерева поиска): + +* оба поддерева — левое и правое — являются двоичными деревьями поиска; +* у всех узлов левого поддерева произвольного узла X значения ключей данных меньше либо равны, нежели значение ключа данных самого узла X; +* у всех узлов правого поддерева произвольного узла X значения ключей данных больше, нежели значение ключа данных самого узла X. + +## 39. Префиксное дерево поиска + +Trie или префиксное дерево — это особый вид дерева поиска, в котором для ключей узлов обычно используются строки. + +![img](./img/префиксное_дерево.png) + +## 40. Сложность алгоритма. Сложность в среднем и худшем случае. O-нотация + +Сложность алгоритма — это мера, которая описывает, как быстро возрастает время выполнения алгоритма по мере увеличения размера входных данных. Она может быть выражена с помощью O-нотации, указывающей верхнюю границу времени выполнения алгоритма в зависимости от размера входных данных. + +### Примеры O-нотации + +* **O(1)**: Константная сложность. Время выполнения алгоритма не зависит от размера входных данных. Пример: доступ к элементу в массиве по индексу. +* **O(log n)**: Логарифмическая сложность. Время выполнения алгоритма растёт логарифмически с ростом размера входных данных. Пример: бинарный поиск в отсортированном массиве. +* **O(n)**: Линейная сложность. Время выполнения алгоритма линейно зависит от размера входных данных. Пример: последовательный поиск в неотсортированном массиве. +* **O(n^2)**: Квадратичная сложность. Время выполнения алгоритма пропорционально квадрату размера входных данных. Пример: сортировка пузырьком. +* **O(2^n)**: Экспоненциальная сложность. Время выполнения алгоритма растёт экспоненциально с ростом размера входных данных. Пример: решение задачи коммивояжёра перебором всех возможных путей. + +### Виды сложности + +1. **В среднем случае (Average Case Complexity)**: Это оценка среднего времени выполнения алгоритма для всех возможных входных данных размера *n*. Сложность в среднем случае обычно используется в анализе случайных алгоритмов, где предполагается равновероятное возникновение всех возможных входов. +2. **В худшем случае (Worst Case Complexity)**: Это оценка максимального времени выполнения алгоритма для любого входного набора размера *n*. Сложность в худшем случае является наиболее пессимистичной оценкой времени выполнения, так как она определяет верхнюю границу времени выполнения алгоритма при наихудших условиях входных данных. + +## 42. АВЛ-дерево + +АВЛ-дерево — сбалансированное по высоте двоичное дерево поиска: для каждой его вершины высота её двух поддеревьев различается не более чем на 1 + +Для АВЛ-деревьев сбалансированность определяется разностью высот правого и левого поддеревьев любого узла. Если эта разность по модулю не превышает 1, то дерево считается сбалансированным. Данное условие проверяется после каждого добавления или удаления узла, и определен минимальный набор операций перестройки дерева, который приводит к восстановлению свойства сбалансированности, если оно оказалось нарушено. + +![img](./img/расход_памяти_АВЛ.png) + +## 43. Красно-черное дерево + +КЧ-деревья – это двоичные деревья поиска, каждый узел которых хранит дополнительное поле color, обозначающее цвет: красный или черный. + +Свойства КЧ-деревьев: + +1. каждый узел либо красный, либо черный; +2. каждый лист (фиктивный) – черный; +3. если узел красный, то оба его сына – черные; +4. все пути, идущие от корня к любому фиктивному листу, содержат одинаковое количество черных узлов; +5. корень – черный. + +Черной высотой узла называется количество черных узлов на пути от этого узла к узлу, у которого оба сына – фиктивные листья. Черная высота дерева – черная высота его корня. + +![img](./img/пример_кч_дерева.png) + +![img](./img/расход_памяти_КЧ.png) + +## 44. Splay-дерево + +Самоперестраивающееся дерево – это двоичное дерево поиска, которое, в отличие от предыдущих двух видов деревьев не содержит дополнительных служебных полей в структуре данных (баланс, цвет и т.п.). Оно позволяет находить быстрее те данные, которые использовались недавно. Самоперестраивающееся дерево было придумано Робертом Тарьяном и Даниелем Слейтером в 1983 году. + +Идея самоперестраивающихся деревьев основана на принципе перемещения найденного узла в корень дерева. + +![img](./img/расход_памяти_Сплай.png) + +## 45. Двоичная куча + +Куча (англ. heap) — это специализированная структура данных типа дерево, которая удовлетворяет свойству кучи: если B является узлом-потомком узла A, то ключ(A) ≥ ключ(B). Из этого следует, что элемент с наибольшим ключом всегда является корневым узлом кучи, поэтому иногда такие кучи называют max-кучами (в качестве альтернативы, если сравнение перевернуть, то наименьший элемент будет всегда корневым узлом, такие кучи называют min-кучами). Не существует никаких ограничений относительно того, сколько узлов-потомков имеет каждый узел кучи, хотя на практике их число обычно не более двух. + +Двоичная куча — та, что создана с помощью двоичного дерева. Иногда ее называют пирамидой. + +![img](./img/пример_двоичной_кучи.png) + +## 46. Хэш-таблица + +Хеш-таблица — линейная структура данных, в которой хранятся пары «ключ — значение» с уникальными ключами. + +## 47. Алгоритм шифрования Цезаря + +Шифр Цезаря – это преобразование информации методом замены букв на другие, стоящие от данных через определенное количество символов в алфавите. + +## 48. Блочные алгоритмы шифрования + +Блочные алгоритмы шифрования представляют собой методы шифрования, которые оперируют не отдельными символами или битами, а блоками данных фиксированного размера. Эти алгоритмы широко используются для защиты данных в современных криптографических приложениях. Вот несколько основных блочных алгоритмов шифрования: AES, DES, ГОСТ 28147-89 + +## 49. Понятие о графе + +Граф — это абстрактная математическая структура, которая представляет собой набор вершин (узлов) и рёбер (связей) между этими вершинами. + +## 50. Алгоритм Прима + +![img](./img/алгоритм_Прима.png) + +## 51. Число связности + +![img](./img/число_связанности.png) + +## 52. Матрицы смежности и инцидентности графа + +![img](./img/матрица_смежности.png) + +![img](./img/матрица_инцедентности.png) + +## 53. Алгоритм ближайшего соседа + +* **Выбор начальной вершины**: Выбирается начальная вершина +* **Поиск ближайшего соседа**: Текущая вершина соединяется с ближайшей ещё не посещённой вершиной. После выбора ближайшей вершины она помечается как посещённая и становится текущей. +* **Повторение**: Шаг 2 повторяются до тех пор, пока все вершины не будут посещены. +* **Возвращение в начальную вершину**: После посещения всех вершин, последняя выбранная вершина соединяется с начальной вершиной, завершая цикл. + +## 54. Расширенный алгоритм Евклида + +![img](./img/расширенный_алгоритм_Евклида.png) + +## 55. Шифрование с открытым ключом + +![img](./img/алгоритм_RSA_1.png) +![img](./img/алгоритм_RSA_2.png) + +--- + +***With ❤️ by NKTKLN*** diff --git a/Second term/Algorithms/exam/questions-sdo-version.pdf b/Second term/Algorithms/exam/questions-sdo-version.pdf new file mode 100755 index 0000000..f704e4d Binary files /dev/null and b/Second term/Algorithms/exam/questions-sdo-version.pdf differ diff --git a/Second term/Algorithms/exam/questions.pdf b/Second term/Algorithms/exam/questions.pdf new file mode 100755 index 0000000..085abd9 Binary files /dev/null and b/Second term/Algorithms/exam/questions.pdf differ diff --git a/Second term/Discrete math/README.md b/Second term/Discrete math/README.md new file mode 100755 index 0000000..18c960f --- /dev/null +++ b/Second term/Discrete math/README.md @@ -0,0 +1,18 @@ +# Discrete math + +number | name | grade +:----: | ---------------------------------------------------------- | :---: +1 | Теория множеств | ✅ +2 | Теория множеств (jupyter) | ✅ +3 | Комбинаторика | ✅ +4 | Комбинаторика (jupyter) | ✅ +5 | Математическая логика | ✅ +6 | Метод резолюции | ✅ +7 | Теорема Поста | ✅ +8 | Алгоритм Дейкстры (python) | ✅ +9 | Графы №1 (jupyter) | ✅ +10-11 | Графы №2 (jupyter) | ✅ +12 | Венгерский алгоритм (python) | ✅ +13 | Внутренне устойчивые (независимые) множества вершин графа | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Second term/Discrete math/Задание_1.pdf b/Second term/Discrete math/Задание_1.pdf new file mode 100755 index 0000000..3eb6259 Binary files /dev/null and b/Second term/Discrete math/Задание_1.pdf differ diff --git a/Second term/Discrete math/Задание_11.ipynb b/Second term/Discrete math/Задание_11.ipynb new file mode 100755 index 0000000..a5a1e0d --- /dev/null +++ b/Second term/Discrete math/Задание_11.ipynb @@ -0,0 +1,379 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6059efcd", + "metadata": {}, + "source": [ + "# Графы" + ] + }, + { + "cell_type": "markdown", + "id": "2bb2048b", + "metadata": {}, + "source": [ + "## Связность и разреженность графов. " + ] + }, + { + "cell_type": "markdown", + "id": "dbe8a4df", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана1.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "9b3416ff", + "metadata": {}, + "source": [ + "## Гигантсткие компоненты" + ] + }, + { + "cell_type": "markdown", + "id": "328b16c7", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана2.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "fd5b6604", + "metadata": {}, + "source": [ + "## Диаметр сложных сетей" + ] + }, + { + "cell_type": "markdown", + "id": "dff99fcf", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана3.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "34c62bab", + "metadata": {}, + "source": [ + "## Устойчивость гигантской компоненты" + ] + }, + { + "cell_type": "markdown", + "id": "b5bb7b77", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана4.jpg)\n", + "\n", + "![title](images/Снимок_экрана4_1.jpg)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "700c5810", + "metadata": {}, + "source": [ + "## Устойчивость к атакам на хабы" + ] + }, + { + "cell_type": "markdown", + "id": "31179960", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана5.jpg)\n", + "\n", + "![title](images/Снимок_экрана5_2.jpg)\n", + "\n", + "![title](images/Снимок_экрана5_3.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "211e44bf", + "metadata": {}, + "source": [ + "## Степенной закон распределения вершин" + ] + }, + { + "cell_type": "markdown", + "id": "824edd9a", + "metadata": {}, + "source": [ + "\n", + "![title](images/Снимок_экрана6.jpg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "42640b23", + "metadata": {}, + "source": [ + "## Задачи" + ] + }, + { + "cell_type": "markdown", + "id": "21d8b493", + "metadata": {}, + "source": [ + "### Задача 1. Рассмотрим модель случайных графов на n вершинах, в котором каждое из возможных ребер проводится независимо от всех остальных с с одной и той же вероятностью. Используя библиотеку NetworkX, сгегенрируйте граф на 1000 вершинах при р=0,003. Оцените разницу между количеством ребер и их ожидаемым количеством. Постройте график распределения вершин в log-log координатах. Оцените степенную зависимость закона распределения вершин. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cc065936", + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import matplotlib\n", + "matplotlib.rcParams['xtick.labelsize'] = 18\n", + "matplotlib.rcParams['ytick.labelsize'] = 18\n", + "import matplotlib.pyplot as plt\n", + "import pylab\n", + "%matplotlib inline\n", + "pylab.rcParams['figure.figsize'] = 10, 10" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "9dfe4c39", + "metadata": {}, + "outputs": [], + "source": [ + "G = nx.gnp_random_graph(1000, 0.003)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2d19ab3c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ожидаемое количество рёбер: 1498\n", + "Колличество рёбер в графе: 1540\n" + ] + } + ], + "source": [ + "## ваш код здесь для подсчета количества сгенерированных ребер и ожидаемого их количества\n", + "import itertools\n", + "\n", + "x = G.nodes()\n", + "number_of_nodes = len(list(itertools.combinations(x, 2)))\n", + "print(\"Ожидаемое количество рёбер:\", round(0.003 * number_of_nodes))\n", + "print(\"Колличество рёбер в графе: \", G.number_of_edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7b3aaf8c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# подсчет количества вершин каждой степени\n", + "degrees = dict()\n", + "for degree in dict(G.degree()).values():\n", + " if degree in degrees:\n", + " degrees[degree] += 1\n", + " else:\n", + " degrees[degree] = 1\n", + "# Ваш код для формирования такого же словаря, с помощью библиотечных функций\n", + "\n", + "\n", + "sorted_degree_values = sorted(degrees.keys())\n", + "counts = [degrees[d] for d in sorted_degree_values]\n", + "plt.loglog(sorted_degree_values, counts, ls='None', marker='o', color='r', markersize=8)\n", + "plt.xlabel(\"degree (log)\", fontsize=18)\n", + "plt.ylabel(\"number of vertices (log)\", fontsize=18)\n", + "plt.title(\"Degree distribution\", fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f2b1060f", + "metadata": {}, + "source": [ + "### Задача 2. Найдите число компонено связности в графе из предыдущей задачи. Есть ли в нем гигантская уомпонента? Сколько в ней вершин, каков ее диаметр? Удажите из графа 10- ую часть вершин. Остентся ли в графе гигантская компонента? Сделайте исследование при какой доле вершин гигантская компонента разрушается." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "24ccb3b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "46\n", + "Graph with 950 nodes and 1535 edges\n", + "13\n" + ] + } + ], + "source": [ + "components = nx.number_connected_components(G)\n", + "print (components)\n", + "giant_component_list = sorted(nx.connected_components(G), key=len, reverse=True) # reverse для сортировки по убыванию\n", + "giant_component = G.subgraph(giant_component_list[0])\n", + "print (G.subgraph(giant_component))\n", + "# print(len(max(nx.connected_components(G), key=len))) # количество вершин в гигантской компоненте\n", + "print (nx.diameter(giant_component))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "172d4d3f", + "metadata": {}, + "outputs": [], + "source": [ + "# Ваш код здесь для удаления 10 процентов случайных вершин\n", + "import random\n", + "\n", + "H = G.copy()\n", + "for node in list(H.nodes()):\n", + " if random.random() < 0.1:\n", + " H.remove_node(node)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "7af62d1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "895\n", + "57\n", + "831\n" + ] + } + ], + "source": [ + "# вывести количество оставшихся вершин, количество компонент связности, гигантскую компоненту связности\n", + "comps = list(nx.connected_components(H))\n", + "print(H.order())\n", + "print(len(comps))\n", + "print(len(comps[0]))" + ] + }, + { + "cell_type": "markdown", + "id": "87d38664", + "metadata": {}, + "source": [ + "### Задача 3. Найдите число компонено связности в графе из предыдущей задачи. Есть ли в нем гигантская уомпонента? Сколько в ней вершин, каков ее диаметр? Удажите из графа 50 самых больших по степени вершин. Остентся ли в графе гигантская компонента? Сделайте исследование при какой доле вершин гигантская компонента разрушается." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "2380c355", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "900\n", + "774\n" + ] + } + ], + "source": [ + "# Ваш код здесь для удаления 50 вершин-хабов\n", + "H = G.copy()\n", + "nodes = sorted(H.nodes(), key=lambda v: H.degree(v), reverse=True)\n", + "for node in nodes[:100]:\n", + " H.remove_node(node)\n", + "\n", + "print(H.order())\n", + "print(len(next(nx.connected_components(H))))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "b8228d0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "900\n", + "105\n", + "774\n" + ] + } + ], + "source": [ + "# вывести количество оставшихся вершин, количество компонент связности, гигантскую компоненту связности\n", + "comps = list(nx.connected_components(H))\n", + "print(H.order())\n", + "print(len(comps))\n", + "print(len(comps[0]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Second term/Discrete math/Задание_12.py b/Second term/Discrete math/Задание_12.py new file mode 100755 index 0000000..b2b70b4 --- /dev/null +++ b/Second term/Discrete math/Задание_12.py @@ -0,0 +1,139 @@ +import numpy as np + + +def min_zero_row(zero_mat, mark_zero): + min_row = [99999, -1] + + for row_num in range(zero_mat.shape[0]): + if np.sum(zero_mat[row_num] == True) > 0 and min_row[0] > np.sum(zero_mat[row_num] == True): + min_row = [np.sum(zero_mat[row_num] == True), row_num] + + zero_index = np.where(zero_mat[min_row[1]] == True)[0][0] + mark_zero.append((min_row[1], zero_index)) + zero_mat[min_row[1], :] = False + zero_mat[:, zero_index] = False + + +def mark_matrix(mat): + cur_mat = mat + zero_bool_mat = (cur_mat == 0) + zero_bool_mat_copy = zero_bool_mat.copy() + + marked_zero = [] + while (True in zero_bool_mat_copy): + min_zero_row(zero_bool_mat_copy, marked_zero) + + marked_zero_row = [] + marked_zero_col = [] + for i in range(len(marked_zero)): + marked_zero_row.append(marked_zero[i][0]) + marked_zero_col.append(marked_zero[i][1]) + + non_marked_row = list(set(range(cur_mat.shape[0])) - set(marked_zero_row)) + + marked_cols = [] + check_switch = True + while check_switch: + check_switch = False + for i in range(len(non_marked_row)): + row_array = zero_bool_mat[non_marked_row[i], :] + for j in range(row_array.shape[0]): + if row_array[j] == True and j not in marked_cols: + marked_cols.append(j) + check_switch = True + + for row_num, col_num in marked_zero: + if row_num not in non_marked_row and col_num in marked_cols: + non_marked_row.append(row_num) + check_switch = True + + marked_rows = list(set(range(mat.shape[0])) - set(non_marked_row)) + + return (marked_zero, marked_rows, marked_cols) + + +def adjust_matrix(mat, cover_rows, cover_cols): + cur_mat = mat + non_zero_element = [] + + for row in range(len(cur_mat)): + if row not in cover_rows: + for i in range(len(cur_mat[row])): + if i not in cover_cols: + non_zero_element.append(cur_mat[row][i]) + min_num = min(non_zero_element) + + for row in range(len(cur_mat)): + if row not in cover_rows: + for i in range(len(cur_mat[row])): + if i not in cover_cols: + cur_mat[row, i] = cur_mat[row, i] - min_num + + for row in range(len(cover_rows)): + for col in range(len(cover_cols)): + cur_mat[cover_rows[row], cover_cols[col]] = cur_mat[cover_rows[row], cover_cols[col]] + min_num + + return cur_mat + + +def hungarian_algorithm(mat): + dim = mat.shape[0] + cur_mat = mat + + for row_num in range(mat.shape[0]): + cur_mat[row_num] = cur_mat[row_num] - np.min(cur_mat[row_num]) + + for col_num in range(mat.shape[1]): + cur_mat[:, col_num] = cur_mat[:, col_num] - np.min(cur_mat[:, col_num]) + + zero_count = 0 + while zero_count < dim: + ans_pos, marked_rows, marked_cols = mark_matrix(cur_mat) + zero_count = len(marked_rows) + len(marked_cols) + + if zero_count < dim: + cur_mat = adjust_matrix(cur_mat, marked_rows, marked_cols) + + return ans_pos + + +def ans_calculation(mat, ans_pos): + total = 0 + ans_mat = np.zeros((mat.shape[0], mat.shape[1])) + for i in range(len(ans_pos)): + total += mat[ans_pos[i][0], ans_pos[i][1]] + ans_mat[ans_pos[i][0], ans_pos[i][1]] = mat[ans_pos[i][0], ans_pos[i][1]] + + return total, ans_mat + + +def main(): + cost_matrix = np.array([ + [7, 3, 6, 9, 5], + [7, 5, 7, 5, 6], + [7, 6, 8, 8, 9], + [3, 1, 6, 5, 7], + [2, 4, 9, 9, 5] + ]) + + ans_pos = hungarian_algorithm(cost_matrix.copy()) + ans, ans_mat = ans_calculation(cost_matrix, ans_pos) + print(f"Result min: {ans:.0f}\n{ans_mat}") + + profit_matrix = np.array([ + [7, 3, 6, 9, 5], + [7, 5, 7, 5, 6], + [7, 6, 8, 8, 9], + [3, 1, 6, 5, 7], + [2, 4, 9, 9, 5] + ]) + max_value = np.max(profit_matrix) + cost_matrix = max_value - profit_matrix + + ans_pos = hungarian_algorithm(cost_matrix.copy()) + ans, ans_mat = ans_calculation(profit_matrix, ans_pos) + print(f"Result max: {ans:.0f}\n{ans_mat}") + + +if __name__ == '__main__': + main() diff --git a/Second term/Discrete math/Задание_13.pdf b/Second term/Discrete math/Задание_13.pdf new file mode 100755 index 0000000..38ff085 Binary files /dev/null and b/Second term/Discrete math/Задание_13.pdf differ diff --git a/Second term/Discrete math/Задание_2.ipynb b/Second term/Discrete math/Задание_2.ipynb new file mode 100755 index 0000000..02f7314 --- /dev/null +++ b/Second term/Discrete math/Задание_2.ipynb @@ -0,0 +1,904 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e02cd782", + "metadata": {}, + "source": [ + "# Практика №2\n" + ] + }, + { + "cell_type": "markdown", + "id": "48a6e585", + "metadata": {}, + "source": [ + "## Операции над множествами. Свойства бинарных отношений. Замыкания отношений\n" + ] + }, + { + "cell_type": "markdown", + "id": "2ae75977", + "metadata": {}, + "source": [ + "Множества являются неопределяемыми понятиями и представляют собой неупорядоченную коллекцию уникальных элементов.\n", + "То есть, что два множества совпадают, если содержат одинаковые элементы.\n", + "Множества, состоящие из конечного числа элементов, называются конечными, в противном случае множества являются бесконечными. Конечное множество можно задать перечислением его элементов. Рассмотрим как можно работать с множествами средствами языка Python на примере конечных множеств.\n" + ] + }, + { + "cell_type": "markdown", + "id": "ca4afee1", + "metadata": {}, + "source": [ + "### Способы задания множеств\n" + ] + }, + { + "cell_type": "markdown", + "id": "d848525f", + "metadata": {}, + "source": [ + "перечисление элементов множества в фигурных скобках:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "569b7ff7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'orange', 'apple', 'banana'}\n", + "\n" + ] + } + ], + "source": [ + "fruits = {\"banana\", \"apple\", \"orange\"}\n", + "print(fruits)\n", + "print(type(fruits))" + ] + }, + { + "cell_type": "markdown", + "id": "b3e9458e", + "metadata": {}, + "source": [ + "Единственное ограничение, что таким образом нельзя создать пустое множество. Вместо этого будет создан пустой словарь:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d446184f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "wrong_empty_set = {}\n", + "print(type(wrong_empty_set))" + ] + }, + { + "cell_type": "markdown", + "id": "60a0a658", + "metadata": {}, + "source": [ + "Для создания пустого множества нужно непосредственно использовать set():\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3b7ce4b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "correct_empty_set = set()\n", + "print(type(correct_empty_set))" + ] + }, + { + "cell_type": "markdown", + "id": "47b6bfac", + "metadata": {}, + "source": [ + "Множество можно задать с помощью set(), если передать в нее какой-либо объект, по которому можно проитерироваться\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6d41db64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'orange', 'apple', 'banana'}\n", + "\n" + ] + } + ], + "source": [ + "fruits_set = set({\"banana\", \"apple\", \"banana\", \"orange\"})\n", + "print(fruits_set)\n", + "print(type(fruits_set))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "99b8c1ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "fruits_set_1 = set({\"apple\", \"orange\", \"banana\", })\n", + "print(fruits_set == fruits_set_1)" + ] + }, + { + "cell_type": "markdown", + "id": "4b420cc2", + "metadata": {}, + "source": [ + "### Подмножество и надмножество\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "98eb8ea5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Подмножество!\n", + "Надмножество!\n" + ] + } + ], + "source": [ + "# Множество чисел Фибоначчи меньших 100\n", + "fibonacci_numbers = {0, 1, 2, 3, 34, 5, 8, 13, 21, 55, 89}\n", + "\n", + "# Множество натуральных чисел меньших 100\n", + "natural_numbers = set(range(100))\n", + "\n", + "# Множество чисел Фибоначчи является подмножеством множества\n", + "# натуральных чисел\n", + "if fibonacci_numbers.issubset(natural_numbers):\n", + " print(\"Подмножество!\")\n", + "\n", + "# В свою очередь множество натуральных чисел является\n", + "# надмножеством множества чисел Фибоначчи\n", + "if natural_numbers.issuperset(fibonacci_numbers):\n", + " print(\"Надмножество!\")" + ] + }, + { + "cell_type": "markdown", + "id": "6c861227", + "metadata": {}, + "source": [ + "Пустое множество является подмножеством абсолютно любого множества.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2946f658", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "empty = set()\n", + "\n", + "# Методы issubset и issuperset могут принимать любой iterable-объект\n", + "print(\n", + " empty.issubset(range(100))\n", + " and empty.issubset([\"red\", \"green\", \"blue\"])\n", + " and empty.issubset(set())\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "eb5a7764", + "metadata": {}, + "source": [ + "Само множество является подмножеством самого себя.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "019bb3ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Подмножество!\n" + ] + } + ], + "source": [ + "natural_numbers = set(range(100))\n", + "\n", + "if natural_numbers.issubset(natural_numbers):\n", + " print(\"Подмножество!\")" + ] + }, + { + "cell_type": "markdown", + "id": "effdf363", + "metadata": {}, + "source": [ + "### Операции над множествами\n" + ] + }, + { + "cell_type": "markdown", + "id": "1bc824be", + "metadata": {}, + "source": [ + "Объединение множеств\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ce1f88c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'orange', 'pear', 'banana', 'apple'}\n" + ] + } + ], + "source": [ + "my_fruits = {\"apple\", \"orange\"}\n", + "your_fruits = {\"orange\", \"banana\", \"pear\"}\n", + "\n", + "# Для объединения множеств (типа set) можно использовать оператор `|`,\n", + "\n", + "our_fruits = my_fruits | your_fruits\n", + "print(our_fruits)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "36e34918", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'orange', 'pear', 'apple', 'banana'}\n" + ] + } + ], + "source": [ + "# Также можно использовать ментод union.\n", + "# Отличие состоит в том, что метод union принимает не только\n", + "# объект типа set, а любой iterable-объект\n", + "you_fruit_list: list = list(your_fruits)\n", + "our_fruits: set = my_fruits.union(you_fruit_list)\n", + "print(our_fruits)" + ] + }, + { + "cell_type": "markdown", + "id": "edb92d2a", + "metadata": {}, + "source": [ + "Добавление элементов в множество.\n", + "Добавление элементов в множество можно рассматривать как частный случай объединения множеств за тем исключением, что добавление элементов изменяет исходное множество, а не создает новый объект\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "af8a9b6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'red', 'purple', 'green', 'blue'}\n" + ] + } + ], + "source": [ + "colors = {\"red\", \"green\", \"blue\"}\n", + "\n", + "# Метод add добаляет новый элемент в множество\n", + "colors.add(\"purple\")\n", + "# Добавление элемента, который уже есть в множестве, не изменяет\n", + "# это множество\n", + "colors.add(\"red\")\n", + "print(colors)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "103d30b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1, 2, 3, 4, 9}\n" + ] + } + ], + "source": [ + "# Метод update принимает iterable-объект (список, словарь, генератор и т.п.)\n", + "# и добавляет все элементы в множество\n", + "numbers = {1, 2, 3}\n", + "numbers.update(i**2 for i in [1, 2, 3])\n", + "print(numbers)" + ] + }, + { + "cell_type": "markdown", + "id": "765338fd", + "metadata": {}, + "source": [ + "### Свойства множеств\n" + ] + }, + { + "cell_type": "markdown", + "id": "8cb16831", + "metadata": {}, + "source": [ + "К основным свойствам множеств, которые мы хотим проверять, относятся рефлексивность, антирефлексивность, симметричность, антисимметричность, транзитивность.\n", + "Сгенерируем произвольное бинарное отношение\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fac374b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 0, 0]]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import random\n", + "x = 4\n", + "y = 4\n", + "array = [[random.randint(0, 1) for _ in range(x)] for _ in range(y)]\n", + "array" + ] + }, + { + "cell_type": "markdown", + "id": "71d50746", + "metadata": {}, + "source": [ + "Проверим рефлексивность. Чтобы выявить наличие единиц на главной диагонали, сгенерируем единичную матрицу нужной размерности, и проверим включается ли она в исходное отношение. Но можно и напрямую проверить, что элементы с i=j в отношении равны 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "23da8a2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def reflexivity_check(array: list[list[int]]) -> bool:\n", + " return all(array[i][i] == 1 for i in range(max(len(array), len(array[0]))))\n", + "\n", + "\n", + "reflexivity_check(array)" + ] + }, + { + "cell_type": "markdown", + "id": "08976a67", + "metadata": {}, + "source": [ + "Для проверки антирефлексивности необходимо проверить, что что элементы с i=j в отношении равны 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ab2ec981", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def antireflexivity_check(array: list[list[int]]) -> bool:\n", + " return all(array[i][i] == 0 for i in range(max(len(array), len(array[0]))))\n", + "\n", + "\n", + "antireflexivity_check(array)" + ] + }, + { + "cell_type": "markdown", + "id": "7cbc0e84", + "metadata": {}, + "source": [ + "Для проверки симметричности нужно проверить, что если в отношении i,j-ый элемент равен 1, то и j,i-ый элемент тоже равен единице\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "434cfe13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def symmetry_check(array: list[list[int]]) -> bool:\n", + " return all(array[i][j] == array[j][i] for j in range(len(array[0])) for i in range(len(array)))\n", + "\n", + "\n", + "symmetry_check(array)" + ] + }, + { + "cell_type": "markdown", + "id": "a186d882", + "metadata": {}, + "source": [ + "Для проверки антисимметричности нужно проверить, что если в отношении i,j-ый элемент равен единице, то и j,i-ый элемент равен нулю\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7727ec98", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def antisymmetry_check(array: list[list[int]]) -> bool:\n", + " return all(array[i][j] != array[j][i] or i == j for j in range(len(array[0])) for i in range(len(array)))\n", + "\n", + "\n", + "antisymmetry_check(array)" + ] + }, + { + "cell_type": "markdown", + "id": "88678087", + "metadata": {}, + "source": [ + "Для проверки транзитивности нужно проверить, что если i,j-ый и j,k-ый элементы принадлежат отношению, то и i,k-ый элемент тоже равен единице\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "518a0e6c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def transitivity_check(array: list[list[int]]) -> bool:\n", + " x = len(array[0])\n", + " y = len(array)\n", + " for x_1 in range(x):\n", + " for y_1 in range(y):\n", + " for x_2 in range(x):\n", + " if array[y_1][x_1] * array[x_1][x_2] and not array[y_1][x_2]:\n", + " return False\n", + " \n", + " return True\n", + "\n", + "\n", + "transitivity_check(array)" + ] + }, + { + "cell_type": "markdown", + "id": "16f83129", + "metadata": {}, + "source": [ + "### Множество всех подмножеств\n", + "\n", + "Алгоритм Грея генерирует последовательность всех подмножеств п-элементного множества, причём каждое следующее подмножество получается из предыдущего удалением или добавлением в точности одного элемента.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f3f4a62f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Рефлективна - False\n", + "Антирефлективна - False\n", + "Симметрична - False\n", + "Антисимметрична - False\n", + "Транзитивна - True\n", + "Замкнута - True\n", + "\n" + ] + } + ], + "source": [ + "# ваш код\n", + "def some_funtion(first_array: list[list[int]], second_array: list[list[int]]) -> list[list[int]]:\n", + " if len(first_array) != len(second_array) or len(first_array[0]) != len(second_array[0]):\n", + " return None\n", + "\n", + " x = len(first_array[0])\n", + " y = len(first_array)\n", + " new_matrix = [[0 for _ in range(x)] for _ in range(y)]\n", + " \n", + " for y_1 in range(y):\n", + " for x_1 in range(x):\n", + " for y_2 in range(y):\n", + " new_matrix[y_1][x_1] = int(new_matrix[y_1][x_1] or\n", + " first_array[y_1][y_2] * second_array[y_2][x_1])\n", + " \n", + " return new_matrix\n", + "\n", + "\n", + "def some_function_check(array: list[list[int]]) -> bool:\n", + " return some_funtion(some_funtion(array, array), array) == \\\n", + " some_funtion(some_funtion(some_funtion(array, array), array), array)\n", + "\n", + "\n", + "array = [[1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 0, 0]]\n", + "\n", + "print(f\"\"\"\n", + "Рефлективна - {reflexivity_check(array)}\n", + "Антирефлективна - {antireflexivity_check(array)}\n", + "Симметрична - {symmetry_check(array)}\n", + "Антисимметрична - {antisymmetry_check(array)}\n", + "Транзитивна - {transitivity_check(array)}\n", + "Замкнута - {some_function_check(array)}\n", + "\"\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc2c6a7d", + "metadata": {}, + "source": [ + "### Транзитивное замыкание\n" + ] + }, + { + "cell_type": "markdown", + "id": "77642242", + "metadata": {}, + "source": [ + "Транзитивное замыкание бинарного отношения, представленного в виде бинарной матрицы,\n", + "представляет собой объединение положительных степеней (всех) исходного отношения\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7a3af8c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 0 1 0]\n", + " [0 0 1 1]\n", + " [1 0 0 0]\n", + " [0 0 1 0]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "A = np.array([[0, 0, 1, 0],\n", + " [0, 0, 1, 1],\n", + " [1, 0, 0, 0],\n", + " [0, 0, 1, 0]])\n", + "print(A)" + ] + }, + { + "cell_type": "markdown", + "id": "92d6fac0", + "metadata": {}, + "source": [ + "Исходный алгоритм Уоршелла проще, поскольку он находит только транзитивное замыкание графа и не использует никакой информации о весах ребер. Алгоритм Флойда в основном является этим алгоритмом с дополнительными соображениями о таких весах. Алгоритм Флойда-Уоршалла решает проблему кратчайшего пути для всех пар. Соответственно, на вход алгоритма Флойда-Уоршалла нужно подавать взвешенноую матрицу бинарного отношения, в которой ненулевой элемент обозначает не только наличие отношения между i и j элементами, но и силу этой связи (выраженную положительным числом).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f071103e", + "metadata": {}, + "outputs": [], + "source": [ + "def warshall(G):\n", + " W = G\n", + " n = len(G)\n", + " for k in range(n):\n", + " for i in range(n):\n", + " for j in range(n):\n", + " G[i, j] = G[i, j] or (G[i, k] and G[k, j])\n", + " return W" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2c977eb9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 0, 1, 0],\n", + " [1, 0, 1, 1],\n", + " [1, 0, 1, 0],\n", + " [1, 0, 1, 0]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "warshall(A)" + ] + }, + { + "cell_type": "markdown", + "id": "87b5bb3e", + "metadata": {}, + "source": [ + "Так как транзитивное замыкание показывает, что если есть путь из i-ой вершины в k-ую и из k-ой вершины в j-ую, то есть путь и из i-ой вершины в j-ую. Соответственно сама матрица отношения это пути дляны 1, если мы строим композицию RR, то в итоге получаем наличие пути, длины 2, а если выполняем обычное возведение в степень, то за счет сложения будем видеть количество путей, длина которых соответствует степени.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3a6c20c0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 0, 3, 0],\n", + " [4, 0, 5, 1],\n", + " [3, 0, 2, 0],\n", + " [2, 0, 3, 0]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_1 = ([[0, 0, 1, 0], [0, 0, 1, 1], [1, 0, 0, 0], [0, 0, 1, 0]])\n", + "np.linalg.matrix_power(array_1, 1) + np.linalg.matrix_power(array_1, 2) + np.linalg.matrix_power(\n", + " array_1, 3)+np.linalg.matrix_power(array_1, 4)+np.linalg.matrix_power(array_1, 5)" + ] + }, + { + "cell_type": "markdown", + "id": "a52bca04", + "metadata": {}, + "source": [ + "Поэтому встает закономерный вопрос, какой путь из предложенных будет иметь наименьшую длину?\n", + "Ответ можно найти с помощью алгоритма Флойда-Уоршалла. Только зададим веса. Обратите внимание на нули, которые обозначают отсутствующие пути.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "dc53474a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 3, 0, 7],\n", + " [8, 0, 2, 0],\n", + " [5, 0, 0, 1],\n", + " [2, 0, 0, 0]])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваша матрица\n", + "graph = np.array([\n", + " [0, 3, 0, 7],\n", + " [8, 0, 2, 0],\n", + " [5, 0, 0, 1],\n", + " [2, 0, 0, 0]\n", + "])\n", + "\n", + "graph" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "db277779", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 3., 5., 6.],\n", + " [5., 0., 2., 3.],\n", + " [3., 6., 0., 1.],\n", + " [2., 5., 7., 0.]])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ваш код\n", + "def floyd_warshall(graph: np.ndarray) -> np.ndarray:\n", + " num_vertices = len(graph)\n", + " dist = np.array([[0 if i == j else graph[i][j] if graph[i][j] != 0 else np.inf for j in range(num_vertices)] for i in range(num_vertices)])\n", + "\n", + " for k in range(num_vertices):\n", + " for i in range(num_vertices):\n", + " for j in range(num_vertices):\n", + " if dist[i][k] != np.inf and dist[k][j] != np.inf:\n", + " dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])\n", + "\n", + " return dist\n", + "\n", + "\n", + "floyd_warshall(graph)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Second term/Discrete math/Задание_3.pdf b/Second term/Discrete math/Задание_3.pdf new file mode 100755 index 0000000..fbd8d47 Binary files /dev/null and b/Second term/Discrete math/Задание_3.pdf differ diff --git a/Second term/Discrete math/Задание_4.ipynb b/Second term/Discrete math/Задание_4.ipynb new file mode 100755 index 0000000..fcacf66 --- /dev/null +++ b/Second term/Discrete math/Задание_4.ipynb @@ -0,0 +1,1003 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "iWFWs9SjJR1o" + }, + "source": [ + "### Комбинаторика в Питоне" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Nh4EhvMbJUIa", + "outputId": "871cbe2f-db64-4ed6-a5bf-7678acdbdafa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None [2 1 3 4 5]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "# создадим массив и передадим его в функцию np.random.shuffle()\n", + "arr = np.array([1, 2, 3, 4, 5])\n", + "\n", + "# сама функция выдала None, исходный массив при этом изменился\n", + "print(np.random.shuffle(arr), arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Xrf3CqP2Fg1O", + "outputId": "fe95126f-2591-496d-a00a-eea6f92b99d0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([2, 4, 5, 1, 3]), array([1, 2, 3, 4, 5]))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# еще раз создадим массив\n", + "arr = np.array([1, 2, 3, 4, 5])\n", + "\n", + "# передав его в np.random.permutation(),\n", + "# мы получим перемешанную копию и исходный массив без изменений\n", + "np.random.permutation(arr), arr" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CRc0_oP1eO3y" + }, + "source": [ + "#### Модуль itertools" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ib9u0kxzA785" + }, + "source": [ + "##### Перестановки" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WdlV4ZrwdliN" + }, + "source": [ + "###### Перестановки без замены" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fOdk6SujdoLH" + }, + "source": [ + "1. Перестановки без повторений" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xdlxohSLeRUW", + "outputId": "9e9bfd0e-9a7a-4a41-a1e5-cb17668c5408" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# импортируем модуль math\n", + "import math\n", + "\n", + "# передадим функции factorial() число 3\n", + "math.factorial(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "S5ceeFMfeNwT", + "outputId": "679f6eb5-2ef6-4f6a-e748-ea187470de80" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B', 'C'),\n", + " ('A', 'C', 'B'),\n", + " ('B', 'A', 'C'),\n", + " ('B', 'C', 'A'),\n", + " ('C', 'A', 'B'),\n", + " ('C', 'B', 'A')]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# импортируем модуль itertools\n", + "import itertools\n", + "\n", + "# создадим строку из букв A, B, C\n", + "x = 'ABC'\n", + "# помимо строки можно использовать и список\n", + "# x = ['A', 'B', 'C']\n", + "\n", + "# и передадим ее в функцию permutations()\n", + "# так как функция возвращает объект itertools.permutations,\n", + "# для вывода результата используем функцию list()\n", + "list(itertools.permutations(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DufioTwtfH5v", + "outputId": "93bfc07b-856b-4aa4-8d7f-0b82b20e58c4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# чтобы узнать количество перестановок, можно использовать функцию len()\n", + "len(list(itertools.permutations(x)))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B-J32YZ4fQCL", + "outputId": "183f8a99-6ab5-4578-c584-ff5fa45332a7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B', 'C'),\n", + " ('A', 'B', 'D'),\n", + " ('A', 'B', 'E'),\n", + " ('A', 'B', 'F'),\n", + " ('A', 'C', 'B')]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# теперь элементов исходного множества шесть\n", + "x = 'ABCDEF'\n", + "\n", + "# чтобы узнать, сколькими способами их можно разместить на трех местах,\n", + "# передадим параметр r = 3 и выведем первые пять элементов\n", + "list(itertools.permutations(x, r = 3))[:5]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NAkXrmpKfzUC", + "outputId": "c33775a0-0c6b-4cae-e7cb-1961fe254a5a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "120" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посмотрим на общее количество таких перестановок\n", + "len(list(itertools.permutations(x, r = 3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PqRx8pF0dtKm" + }, + "source": [ + "2. Перестановки с повторениями" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "3qQ5QpTFpIJc" + }, + "outputs": [], + "source": [ + "# импортируем необходимые библиотеки\n", + "import itertools\n", + "import numpy as np\n", + "import math\n", + "\n", + "# объявим функцию permutations_w_repetition(), которая будет принимать два параметра\n", + "# x - строка, список или массив Numpy\n", + "# r - количество мест в перестановке, по умолчанию равно количеству элементов в x\n", + "def permutations_w_repetition(x, r = len(x)):\n", + "\n", + " # если передается строка,\n", + " if isinstance(x, str):\n", + " # превращаем ее в список\n", + " x = list(x)\n", + "\n", + " # в числителе рассчитаем количество перестановок без повторений\n", + " numerator = len(list(itertools.permutations(x, r = r)))\n", + "\n", + " # для того чтобы рассчитать знаменатель найдем,\n", + " # сколько раз повторяется каждый из элементов\n", + " _, counts = np.unique(x, return_counts = True)\n", + "\n", + " # объявим переменную для знаменателя\n", + " denominator = 1\n", + "\n", + " # и в цикле будем помещать туда произведение факториалов\n", + " # повторяющихся элементов\n", + " for c in counts:\n", + "\n", + " # для этого проверим повторяется ли элемент\n", + " if c > 1:\n", + "\n", + " # и если да, умножим знаменатель на факториал повторяющегося элемента\n", + " denominator *= math.factorial(c)\n", + "\n", + " # разделим числитель на знаменатель\n", + " # деление дает тип float, поэтому используем функцию int(),\n", + " # чтобы результат был целым числом\n", + " return int(numerator/denominator)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Fq0vyfdg--5m", + "outputId": "478c5a0b-0768-473c-ff1f-fd48231e0bda" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "120" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# создадим строку со словом \"молоко\"\n", + "x = 'МОЛОКО'\n", + "\n", + "# вызовем функцию\n", + "permutations_w_repetition(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GoAiKH8-pIo3" + }, + "source": [ + "###### Перестановки с заменой" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-uevbl8WdvsA", + "outputId": "b320a8a8-bfed-43b0-b8bf-8f041c6d256f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Ваниль', 'Ваниль'),\n", + " ('Ваниль', 'Клубника'),\n", + " ('Клубника', 'Ваниль'),\n", + " ('Клубника', 'Клубника')]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посмотрим, сколькими способами можно выбрать два сорта мороженого\n", + "list(itertools.product(['Ваниль', 'Клубника'], repeat = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9uxp4aeItTED", + "outputId": "29ce5a18-39fd-4bf3-b3d5-0eb977763122" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'A'),\n", + " ('A', 'B'),\n", + " ('A', 'C'),\n", + " ('A', 'D'),\n", + " ('B', 'A'),\n", + " ('B', 'B'),\n", + " ('B', 'C'),\n", + " ('B', 'D'),\n", + " ('C', 'A'),\n", + " ('C', 'B'),\n", + " ('C', 'C'),\n", + " ('C', 'D'),\n", + " ('D', 'A'),\n", + " ('D', 'B'),\n", + " ('D', 'C'),\n", + " ('D', 'D')]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посмотрим на способы переставить с заменой два элемента из четырех\n", + "list(itertools.product('ABCD', repeat = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LLlYVJ6Cgwc9", + "outputId": "fe8ce0c1-d717-49c2-bd59-6c8ae45335fc" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# убедимся, что таких способов 16\n", + "len(list(itertools.product('ABCD', repeat = 2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9TKsA791BEES" + }, + "source": [ + "##### Сочетания" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tIbK4PNsyVwB", + "outputId": "09dbb8bf-a98c-4101-d465-2b6a19e88015" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B'),\n", + " ('A', 'C'),\n", + " ('A', 'D'),\n", + " ('A', 'E'),\n", + " ('B', 'A'),\n", + " ('B', 'C'),\n", + " ('B', 'D'),\n", + " ('B', 'E'),\n", + " ('C', 'A'),\n", + " ('C', 'B'),\n", + " ('C', 'D'),\n", + " ('C', 'E'),\n", + " ('D', 'A'),\n", + " ('D', 'B'),\n", + " ('D', 'C'),\n", + " ('D', 'E'),\n", + " ('E', 'A'),\n", + " ('E', 'B'),\n", + " ('E', 'C'),\n", + " ('E', 'D')]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# возьмем пять элементов\n", + "x = 'ABCDE'\n", + "\n", + "# и найдем способ переставить два элемента из этих пяти\n", + "list(itertools.permutations(x, r = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9NJLHZVP9xve", + "outputId": "1ec51fcc-93ee-4cc9-b130-47935e0a1d01" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# уменьшим на количество перестановок каждого типа r!\n", + "int(len(list(itertools.permutations(x, r = 2)))/math.factorial(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "imUV1aSA_JI4", + "outputId": "44cc4c14-993e-492a-8a17-839cc41d0f0f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B'),\n", + " ('A', 'C'),\n", + " ('A', 'D'),\n", + " ('A', 'E'),\n", + " ('B', 'C'),\n", + " ('B', 'D'),\n", + " ('B', 'E'),\n", + " ('C', 'D'),\n", + " ('C', 'E'),\n", + " ('D', 'E')]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# то же самое можно рассчитать с помощью функции combinations()\n", + "list(itertools.combinations(x, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GNuEIKwl_Px1", + "outputId": "23f3ec43-59a5-4914-f2ad-aae6291ac8ad" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посмотрим на количество сочетаний\n", + "len(list(itertools.combinations(x, 2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CPpGYzYJMuiv" + }, + "source": [ + "Сочетания с заменой" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "75SIWA4TMgj1", + "outputId": "f622aa9c-c089-4352-c2b1-f5f423947286" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'A'), ('A', 'B'), ('B', 'B')]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# сколькими способами с заменой можно выбрать два элемента из двух\n", + "list(itertools.combinations_with_replacement('AB', 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DgCya-oDUIyd", + "outputId": "f78b7f06-b597-4006-d9cc-fa49fe45f809" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B')]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# очевидно, что без замены есть только один такой способ\n", + "list(itertools.combinations('AB', 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9xgg_wXLbjuu" + }, + "source": [ + "Биномиальные коэффициенты" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6dDgzQTlB7ZF", + "outputId": "768cf35c-a548-450e-935c-dc84a6533d70" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('H', 'H', 'H'),\n", + " ('H', 'H', 'T'),\n", + " ('H', 'T', 'H'),\n", + " ('H', 'T', 'T'),\n", + " ('T', 'H', 'H'),\n", + " ('T', 'H', 'T'),\n", + " ('T', 'T', 'H'),\n", + " ('T', 'T', 'T')]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# дерево вероятностей можно построить с помощью декартовой степени\n", + "list(itertools.product('HT', repeat = 3))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NFqzBH7lblyY", + "outputId": "e2d1b80c-a022-4878-8a5a-111019cdd561" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посмотрим, в скольких комбинациях выпадет два орла при трех бросках\n", + "comb = len(list(itertools.combinations('ABC', 2)))\n", + "comb" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q5YrLz3_sffO" + }, + "source": [ + "### Упражнения" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Задание 1**. Реализовать комбинаторные конструкции без использования библиотеки intertools. Проведите сравнительный анализ на быстродействие и объем используемой памяти. Сделайте выводы." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "def permutations(items: list[int]):\n", + " if len(items) == 0:\n", + " yield []\n", + " else:\n", + " for i in range(len(items)):\n", + " for perm in permutations(items[:i] + items[i+1:]):\n", + " yield [items[i]] + perm\n", + "\n", + "def combinations(items: list[int], k: int):\n", + " if k == 0:\n", + " yield []\n", + " elif len(items) == k:\n", + " yield items\n", + " else:\n", + " for comb in combinations(items[1:], k-1):\n", + " yield [items[0]] + comb\n", + " for comb in combinations(items[1:], k):\n", + " yield comb\n", + "\n", + "def arrangements(items: list[int], k: int):\n", + " if k == 0:\n", + " yield []\n", + " else:\n", + " for i in range(len(items)):\n", + " for arr in arrangements(items[:i] + items[i+1:], k-1):\n", + " yield [items[i]] + arr" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "my func\n", + "\n", + "===Permutations===\n", + "Output: [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3], [1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]]\n", + "Time: 4.315376281738281e-05\n", + "===Combinations===\n", + "Output: [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n", + "Time: 1.0013580322265625e-05\n", + "===Arrangements===\n", + "Output: [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\n", + "Time: 1.4066696166992188e-05\n", + "\n", + "itertools\n", + "\n", + "===Permutations===\n", + "Output: [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]\n", + "Time: 2.1219253540039062e-05\n", + "===Combinations===\n", + "Output: [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n", + "Time: 5.0067901611328125e-06\n", + "===Arrangements===\n", + "Output: [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]\n", + "Time: 5.0067901611328125e-06\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "\n", + "def measure(func, *args):\n", + " start_time = time.time()\n", + " print(\"Output:\", list(func(*args)))\n", + " end_time = time.time()\n", + " print(\"Time:\", end_time - start_time)\n", + "\n", + "\n", + "items = [1, 2, 3, 4]\n", + "k = 2\n", + "\n", + "print(\"my func\\n\")\n", + "\n", + "print(\"===Permutations===\")\n", + "measure(permutations, items)\n", + "print(\"===Combinations===\")\n", + "measure(combinations, items, k)\n", + "print(\"===Arrangements===\")\n", + "measure(arrangements, items, k)\n", + "\n", + "print(\"\\nitertools\\n\")\n", + "print(\"===Permutations===\")\n", + "measure(itertools.permutations, items)\n", + "print(\"===Combinations===\")\n", + "measure(itertools.combinations, items, k)\n", + "print(\"===Arrangements===\")\n", + "measure(itertools.permutations, items, k)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "awwMLMoylUED" + }, + "source": [ + "**Задание 2**. В новую школу не успели завезти парты в один из классов. Поэтому в этот класс принесли круглые столы из столовой. Столы в столовой разных размеров — на 4, 7 и 13 человек, всего их хватало на 59 человек. Когда часть столов отнесли в класс, в столовой осталось 33 места. Какие столы могли быть отнесены в класс?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Столы по 4 места: 0 | Столы по 7 мест: 0 | Столы по 13 мест: 2\n", + "Столы по 4 места: 3 | Столы по 7 мест: 2 | Столы по 13 мест: 0\n" + ] + } + ], + "source": [ + "def find_possible_tables():\n", + " total_seats = 59\n", + " remaining_seats = 33\n", + " table_sizes = [4, 7, 13]\n", + "\n", + " for counts in itertools.product(range(total_seats // 4 + 1),\n", + " range(total_seats // 7 + 1),\n", + " range(total_seats // 13 + 1)):\n", + " if sum(count * size for count, size in zip(counts, table_sizes)) == total_seats-remaining_seats:\n", + " yield counts\n", + "\n", + "\n", + "for tables in find_possible_tables():\n", + " print(\"Столы по 4 места:\", tables[0], end=\" | \")\n", + " print(\"Столы по 7 мест:\", tables[1], end=\" | \")\n", + " print(\"Столы по 13 мест:\", tables[2])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Задание 3**. Продавец имеет достаточное количество гирь для взвешивания следующих номиналов: 5гр, 10гр, 20гр, 50гр. каждый день к нему в магазин заходит житель соседнего дома и покупает ровно 500гр докторской колбасы. Продавец решил в течение месяца использовать различные наборы гирек для взвешивания. Сможет ли он выполнить задуманное?" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Да\n" + ] + } + ], + "source": [ + "def find_possible_weights():\n", + " total = 500\n", + " weights = [5, 10, 20, 50]\n", + " \n", + " for counts in itertools.product(range(total // 5 + 1),\n", + " range(total // 10 + 1),\n", + " range(total // 20 + 1),\n", + " range(total // 50 + 1)):\n", + " if sum(count * weight for count, weight in zip(counts, weights)) == total:\n", + " yield counts\n", + "\n", + "print(\"Да\" if len(list(find_possible_weights())) >= 31 else \"Нет\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Задание 4**. Сколько можно найти различных семизначных чисел, сумма цифр которых равна ровно 50?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "26418\n" + ] + } + ], + "source": [ + "def find_numbers() -> list[int]:\n", + " possible_combinations = itertools.product(range(10), repeat=7)\n", + " valid_numbers = []\n", + "\n", + " for combination in possible_combinations:\n", + " if combination[0] != 0:\n", + " if sum(combination) == 50:\n", + " number = int(\"\".join(map(str, combination)))\n", + " valid_numbers.append(number)\n", + "\n", + " return valid_numbers\n", + "\n", + "\n", + "print(len(find_numbers()))\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Second term/Discrete math/Задание_5.pdf b/Second term/Discrete math/Задание_5.pdf new file mode 100755 index 0000000..2834854 Binary files /dev/null and b/Second term/Discrete math/Задание_5.pdf differ diff --git a/Second term/Discrete math/Задание_6.pdf b/Second term/Discrete math/Задание_6.pdf new file mode 100755 index 0000000..beacbe2 Binary files /dev/null and b/Second term/Discrete math/Задание_6.pdf differ diff --git a/Second term/Discrete math/Задание_7.pdf b/Second term/Discrete math/Задание_7.pdf new file mode 100755 index 0000000..3e51c5e Binary files /dev/null and b/Second term/Discrete math/Задание_7.pdf differ diff --git a/Second term/Discrete math/Задание_8.py b/Second term/Discrete math/Задание_8.py new file mode 100755 index 0000000..03b2bd8 --- /dev/null +++ b/Second term/Discrete math/Задание_8.py @@ -0,0 +1,39 @@ +def main() -> None: + inf = float("inf") + graph = [ + [ 0, 7, inf, inf, 4, inf], + [ 7, 0, 5, inf, inf, 2], + [inf, 5, 0, 11, inf, 6], + [inf, inf, 11, 0, 8, 9], + [ 4, inf, inf, 8, 0, 3], + [inf, 2, 6, 9, 3, 0], + ] + + start_node = 0 + + dist = graph[start_node].copy() + queue = list(range(len(dist))) + routes = [[] if dist[index] == inf else [start_node] for index in range(len(dist))] + while len(queue) > 0: + min_index = queue[0] + for node in queue: + if dist[node] < dist[min_index]: + min_index = node + queue.remove(min_index) + + for node in queue: + new_dist = dist[min_index] + graph[min_index][node] + if dist[node] > new_dist: + dist[node] = new_dist + routes[node] = routes[min_index] + [min_index] + + for index in range(len(routes)): + if index == start_node: + continue + + print(f"{start_node} --> {index} ({dist[index] :>2}):", end=" ") + print(" --> ".join(map(str, routes[index] + [index]))) + + +if __name__ == "__main__": + main() diff --git a/Second term/Discrete math/Задание_9.ipynb b/Second term/Discrete math/Задание_9.ipynb new file mode 100755 index 0000000..01a1d2d --- /dev/null +++ b/Second term/Discrete math/Задание_9.ipynb @@ -0,0 +1,1020 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ee388e8", + "metadata": {}, + "source": [ + "# Графы" + ] + }, + { + "cell_type": "markdown", + "id": "31fe6bcc", + "metadata": {}, + "source": [ + "## Определение графов. " + ] + }, + { + "cell_type": "markdown", + "id": "6cbbbe70", + "metadata": {}, + "source": [ + "\n", + " Неориентированным графом (или графом) называется пара $(V,E)$, где $V = \\{v_1, v_2,... \\}$ — множество вершин, $E = \\{e_1, e_2,... \\}$ — множество ребер, в котором каждый элемент $e_k$ является неупорядоченной парой $\\{v_i, v_j\\}$. Пара $(V,E)$, в которой множество $E$ состоит из упорядоченных пар $(v_i, v_j )$, называется ориентированным графом, а элементы из $E$ — дугами, или ориентированными ребрами. Вершины $v_i$ и $v_j$ , составляющие ребро или дугу, называются концевыми вершинами ребра или дуги, а про ребро и дугу говорят, что они соединяют свои концевые вершины.

\n" + ] + }, + { + "cell_type": "markdown", + "id": "26e31d3b", + "metadata": {}, + "source": [ + "## Локальные характеристики" + ] + }, + { + "cell_type": "markdown", + "id": "ccdb2118", + "metadata": {}, + "source": [ + "Если $ e=\\{v_i, v_j\\} $– ребро графа, то вершина $ v_i $ и ребро е инцидентны. Вершина $ v_j $ и ребро е также инцидентны.
\n", + "Вершины, инцидентные одному ребру, называются смежными.
\n", + "Два ребра смежные, если инцидентны одной вершине.
\n", + "Число вершин графа называется его порядком.
\n", + "Число ребер графа, инцидентных данной вершине $vi$ , называется степенью $p(v_i)$ вершины $vi$ (другое обозначение $deg(v_i)$).
\n", + "Если $ p(v_i)$ то $v_i$ – изолированная вершина, если $p(v_i)=1$, то $v_i$ – висячая вершина.
\n", + "Если концевые вершины совпадают, то дугу $e=(v_i, v_j)$ называют петлей.
\n", + "Очевидно, что для неориентированного графа $\\{v_i, v_j\\}=\\{v_j, v_i\\}$, а для ориентированного $(v_i, v_j)\\neq (v_j, v_i)$ .\n" + ] + }, + { + "cell_type": "markdown", + "id": "5eb6495a", + "metadata": {}, + "source": [ + "Нетрудно подсчитать число графов с фиксированным множеством вершин. Обозначим через $ N_g $ число неориентированных графов без петель с множеством вершин n.\n", + "
Теорема (О количестве графов)
\n", + " $$ N_g = 2^{\\frac{n(n-1)}{2}} $$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e8785f8f", + "metadata": {}, + "source": [ + "
Теорема (Лемма о рукопожатиях)
Сумма степеней всех вершин графа равна удвоенному числу ребер: \n", + " $$ \\sum p(v_i)=2|E| $$\n" + ] + }, + { + "cell_type": "markdown", + "id": "b4003ab7", + "metadata": {}, + "source": [ + "
Следствие
Сумма степеней вершин графа всегда четное число." + ] + }, + { + "cell_type": "markdown", + "id": "9d0d01ae", + "metadata": {}, + "source": [ + "
Теорема
\tВ любом графе число вершин нечетной степени четно.\n" + ] + }, + { + "cell_type": "markdown", + "id": "8efea77a", + "metadata": {}, + "source": [ + "## Способы представления графов" + ] + }, + { + "cell_type": "markdown", + "id": "a53868fa", + "metadata": {}, + "source": [ + "### Графическое представление графов. представление в виде списков смежности" + ] + }, + { + "cell_type": "markdown", + "id": "7e31a24f", + "metadata": {}, + "source": [ + "Обычно граф изображают на плоскости в виде множества точек, соответствующих вершинам, и множества линий, которые соединяют вершины и соответствуют ребрам. При изображении ориентированных графов линии снабжаются стрелками, указывающими ориентацию дуги, т. е. порядок вершин в паре." + ] + }, + { + "cell_type": "markdown", + "id": "eb9279ad", + "metadata": {}, + "source": [ + "Для работы с графами можно использовать библиотеку NetworkX, предназначенную для создания, манипуляции и изучения структуры, динамики и функционирования сложных сетевых структур. Внутреннее представление графов реализовано в виде списков смежности.
\n", + "Основные возможности библиотеки:\n", + "
    \n", + "
  1. Классы для работы с простыми, ориентированными и взвешенными графами
    2. \n", + "
  2. Узлом может быть практически что угодно: time-series, текст, изображение, XML
    3. \n", + "
  3. Сохранение / загрузка графов в/из наиболее распространённых форматов файлов хранения графов
    4. \n", + "
  4. Встроенные процедуры для создания графов базовых типов
    5. \n", + "
  5. Методы для обнаружения подграфов, клик и К-дольных графов (K-core) ( максимальный подграф в котором каждая вершина имеет по крайней мере уровень К )
    6. \n", + "
  6. Получение таких характеристик графа как степени вершин, высота графа, диаметр, радиус, длинны путей, центр, промежуточности, и т. д.
    7. \n", + "
  7. Визуализировать сети в виде 2D и 3D графиков
    8. \n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "98e1dde0", + "metadata": {}, + "outputs": [], + "source": [ + "#Если требуется установить библиотеку\n", + "# !pip install networkx" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "b254ada3", + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx \n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "519b710b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G = nx.Graph() # пустой неориентированный граф\n", + "G1 = nx.DiGraph() # пустой ориентированный граф\n", + "GG = nx.MultiGraph() # пустой мультиграф\n", + "GG1 = nx.MultiDiGraph() # пустой ориентированный мультиграф\n", + "\n", + "G.add_node(1) # добавляем одину вершину, получаем тоже пустой граф\n", + "G.add_nodes_from([3, 4, 5, 6, 7]) # добавляем еще шесть вершин сразу\n", + "\n", + "# В качестве обозначений вершин можем использовать ярлыки:\n", + "G1.add_nodes_from([\"node_1\", \"node_2\"]) # пустой ориентированный граф\n", + "\n", + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(211)\n", + "nx.draw_networkx(G)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(212)\n", + "nx.draw_networkx(G1, with_labels = True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "283ba2d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# добавляем в графы ребра и дуги\n", + "G.add_edges_from([(1, 2), (1, 3), (1, 4), (2, 4), (2, 6), (3, 6), (4,7), (5, 7)]) # для неориентированного графа\n", + "G.add_edge(8,9) # добавление ребра с новыми вершинами, добавит их тоже\n", + "\n", + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(211)\n", + "nx.draw_networkx(G)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d273c0ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NodeView((1, 3, 4, 5, 6, 7, 2, 8, 9))" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G.nodes()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "98549f52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Количество вершин в графе G\n", + "G.number_of_nodes()\n", + "# G.order\n", + "# len(G)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "b8d574e8", + "metadata": {}, + "outputs": [], + "source": [ + "G.edges()\n", + "nx.write_edgelist(G, \"Graf.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "ea2178eb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# количество ребер\n", + "G.number_of_edges()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "2925c211", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiGraph with 9 nodes and 9 edges\n" + ] + } + ], + "source": [ + "# создание графа из файла\n", + "G2 = nx.read_edgelist(\"Graf.txt\", nodetype = int, create_using = nx.DiGraph()) #считываем список ребер из файла, по умолчанию неориентированный\n", + "nx.is_directed(G2)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4316a607", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 3, 4]\n", + "[5, 6, 7, 8, 9]\n" + ] + } + ], + "source": [ + "# список соседей вершины графа\n", + "#list(G.neighbors(1))\n", + "print(list(nx.all_neighbors(G, 1))) # список соседних вершин\n", + "print(list(nx.non_neighbors(G, 1))) # список остальных вершин" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "be070e29", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G1.add_edges_from([(\"node_1\", \"node_2\")]) # для ориентированного графа\n", + "\n", + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(212)\n", + "nx.draw_networkx(G1)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "04767bda", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "data": { + "text/plain": [ + "DegreeView({1: 3, 3: 2, 4: 3, 5: 1, 6: 2, 7: 2, 2: 3, 8: 1, 9: 1})" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# степени вершин\n", + "print(G.degree(1))\n", + "G.degree()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd241395", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "de4d11f9", + "metadata": {}, + "source": [ + "### Представление графов виде матриц" + ] + }, + { + "cell_type": "markdown", + "id": "ad160898", + "metadata": {}, + "source": [ + "#### Матрица смежности" + ] + }, + { + "cell_type": "markdown", + "id": "c35cad09", + "metadata": {}, + "source": [ + "Матрицей смежности $A=A(a_{ij})$ графа G называется матрица порядка n, определенная следующим образом:\n", + "$$a_{ij}=\\begin{cases} 1, &если& e_{ij} \\in E \\\\ 0, &если& e_{ij} \\notin E \\end{cases} $$\n", + " \n", + "Матрица смежности для неориентированного графа будет симметрична относительно главной диагонали. Матрица смежности для ориентированного графа в общем случае не симметрична относительно главной диагонали." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b9ef4b36", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1 1 0 0 0 1 0 0]\n", + " [1 0 0 0 1 0 0 0 0]\n", + " [1 0 0 0 0 1 1 0 0]\n", + " [0 0 0 0 0 1 0 0 0]\n", + " [0 1 0 0 0 0 1 0 0]\n", + " [0 0 1 1 0 0 0 0 0]\n", + " [1 0 1 0 1 0 0 0 0]\n", + " [0 0 0 0 0 0 0 0 1]\n", + " [0 0 0 0 0 0 0 1 0]]\n" + ] + } + ], + "source": [ + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(212)\n", + "nx.draw_networkx(G)\n", + "plt.show()\n", + "\n", + "a= nx.adjacency_matrix(G) # список вершин, которые соединены попарно, и веса связывающих их ребер.\n", + "A=a.todense() # Формируем матрицу смежности\n", + "print(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "22c6a448", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAFyCAYAAADvfDCoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABPaElEQVR4nO3deVyNaR8G8OucUikqZbLWGFKUkiXZyTqWsRuGLJN9GcYSXjL2GMMYxmAYZM8Y69hFkiihTaEUFWZQkZROnXOe9w9Tk9GqU2fp+n4+83nHebbf8U7nXN33/XsekSAIAoiIiIjUkFjZBRARERF9LAYZIiIiUlsMMkRERKS2GGSIiIhIbTHIEBERkdpikCEiIiK1xSBDREREaotBhoiIiNSWdlF2ksvlePr0KSpXrgyRSFTaNREREVE5JwgCUlNTUbNmTYjF+Y+7FCnIPH36FObm5gorjoiIiKgoEhISULt27Xy3FynIVK5cOedkhoaGiqmMiIiIKB+vX7+Gubl5TgbJT5GCTPZ0kqGhIYMMERERlZnClrRwsS8RERGpLQYZIiIiUlsMMkRERKS2GGSIiIhIbTHIEBERkdpikCEiIiK1xSBDREREaotBhoiIiNQWgwwRERGpLQYZIiIiUlsMMkRERKS2GGSIiIhIbTHIEBERkdpikCEiIiK1pa3sAoiIiBQhTSLFo6Q0ZErl0NEWo46pAQx0+TWn6fj/MBERqa3oZ6nYFxgPn/vPEZ+cDiHXNhEACxN9OFubYbiTBepXq6ysMqkUiQRBEArb6fXr1zAyMkJKSgoMDQ3Loi4iIqJ8JSSnY/7RcPg9SISWWASZPP+vsuzt7SyrwqO/HcxN9MuwUvpYRc0eXCNDRERqxSsoHl3W+eJabBIAFBhicm+/FpuELut84RUUX+o1Utnh1BIREamNjT7RWHM+6qOOlckFyOQC5h0JR+IbCaY611dwdaQMHJEhIiK14BUU/9Eh5r/WnI/CQY7MaAQGGSIiUnkJyelYdCJCoef87kQEEpLTFXpOKnsMMkREpPLmHw2HtJC1MMUllQuYfzRcoeekssc1MkREpNKin6XC70FioftJUxPx6spevI25CbnkDSpUqQlDx36o1LhbnvvL5AL8HiTiwfNUWJqxNVtdcUSGiIhU2r7AeGiJRQXuI0t7ib93z0ZGXCgqN+sFky7joW1cA0lnNuB10PF8j9MSi7A3gGtl1BmDDBERqTSf+88LbbF+5bsHEOSo8fV6GLf5CpWb9ITZoIXQb9ger67uhzxLkudxMrkAn6jnpVE2lREGGSIiUllvJFLEF7IgVxAEpN/3R0XLFoAgQJaekvNPxc+aQpCkIfNZTL7HxyelI00iVXTpVEa4RoaIiFRWXFIaClviK09PgVyShjchZ/Em5Gze+6S9yvd4AcCjpDTY1jT66DpJeRhkiIhIZWVK5YXv9M+TdgxsnWFg1znPXXQ+qVPy65BKYpAhIiKVpaNd+AoIsb4hRDoVIQhyVKzjUGrXIdXE/+eIiEhl1TE1QMH9SoBIrAV96zZIv++PzBePPtguS08p+Ph/rkPqiSMyRESksgx0tWFhoo+4Qhb8Vuk4ChlxYfh79yxUatwdFapaQP42FZnPYpDxKATm33rle6yFqT4MdPl1qK44IkNERCrN2dqs0PvIaBlUQY1RP6KSXRekR11H8vktSL15AvK3qTDuODrf4wS5DG9jbuLUqVOQStm5pI5EgiAUes/n169fw8jICCkpKTA0NCyLuoiIiAC8u7Nv15+ulNr5DXx/ROT1S6hWrRpcXFwwatQo2NnZldr1qGiKmj04IkNERCqtfrXKaGdZtdBRmeLSEovQzrIq7vh74/bt2xgyZAh27doFe3t7NGvWDD///DMSEwt/NAIpF0dkiIhIJTx48AAPHjxAfHx8zj9BQUF4/PgxTlz0x8Q/n0CiwDZpXW0xvGd0gLmJfs5rmZmZOH36NHbt2oWTJ09CJBKhd+/eGDVqFHr27IkKFSoo7PpUsKJmDwYZIiJSuuDgYDRt2jTnz9ra2pDJZBAEATo6Onj27BnORr/GvCOKe1r19wPsMMTRIt/tL168wIEDB+Dp6Yng4GB88sknGDZsGEaPHg0HBweF1UF549QSERGpDVtbW9jY2EAsfve1JJVKkf179pYtW2BsbIyhjhaY3c1KIddz62ZdYIgBgE8++QTTpk3D7du3ERoaihEjRsDLywtNmjSBg4MD1q1bh+fP+ZwmZeOIDBERqYSzZ8+iR48eOX/W0tJC48aNERQUlBNwAMArKB6LTkRAKhcKfZhkblpiEbTFIiztY1toiMmPVCrFuXPn4OnpiRMnTkAul6NHjx4YPXo0evfuDR0dnY86L32IU0tERKQWBEGAp6cnZsyYAalUivT09JzRmOvXr6Nly5YfHJOQnI75R8Ph9yARWmJRgYEme3s7y6rw6G/33pqYkkhOToaXlxc8PT0RFBQEExOTnKmnpk2bQiRS7OLk8oZBhoiIVF5cXBzGjx+P8+fPY9SoUfDw8EDHjh0RHR2N4cOHY+/evQUeH/0sFfsC4+ET9RzxSenvPWBShHc3u3O2MoNLSwtYmlUutfcRGRmJXbt2Ye/evXj69ClsbW0xatQouLi4oEaNGqV2XU3GIENERCpLLpfj119/xZw5c2BsbIytW7fmTCsFBQVh1qxZOHDgAGrVqlXkc6ZJpHiUlIZMqRw62mLUMTUo8zv2ymQyeHt7w9PTE8eOHUNmZia6d++O0aNHo0+fPtDT0yuTOlTh76KkGGSIiEglxcTEYOzYsbh8+TImTJiA1atXa+R3y6tXr/D777/D09MT169ff7dgeehQjBo1Ck5OTgqfesoZnbr/HPHJeYxOmejD2doMw50sUL9a6Y1OKQqDDBERqRSZTIaff/4Z8+fPR/Xq1bFt2zZ07txZ2WWViaioKOzatQu7d+/G48ePYW1tjVGjRmHEiBGoXbv2B/vLZDKcP38eXbt2hbZ2wSMpqrBeqDSw/ZqIiFTGvXv30K5dO8ycORPjxo1DWFhYuQkxAGBlZYUVK1bg0aNHuHDhApo3b45ly5bBwsIC3bt3x/79+5Ge/u+DMQ8ePIiePXti3LhxkMvzvwmgV1A8uqzzxbXYJAAotIsre/u12CR0WecLr6B4Bbw75WKQISKiUiOVSrFq1So4ODggKSkJV65cwfr161GpUiVll6YUWlpa6NKlC/bu3Yu///4b27Ztw9u3bzF8+HDUqFED48aNg7+/P7Zv3w6RSARPT0/MmjULeU2ebPSJxrwj4ZBI5cVqQwfeBRqJVI55R8Kx0SdaUW9PKTi1REREpSIsLAyurq4IDg7G7NmzsXjxYlSsWFHZZamkmJgY7N69G7t27UJcXNwH25ctWwZ3d/ecP3sFxZfpXY6VgVNLRESkFJmZmViyZAmaN2+OjIwMBAQE4Pvvv2eIKUC9evWwZMkSxMbGYsyYMR8sBF64cCHWrl0L4N2amEUnIhR6/e9ORCAhOb3wHVWQevViERGRSrt16xa+/vpr3L17F/Pnz8f8+fOhq6ur7LLUhkgkwqVLl/KcSpo9ezaqV6+OsxmWkBZzKqkwUrmA+UfDsWeMk0LPWxY4IkNERCWWkZGB//3vf3BycoK2tjaCgoKwZMkShphievnyJR4+fAgAqFChAszNzdGqVSv07t0bXbt2hVl9e/g9SMx3TUxGXBjiVvVG+v1rH2xLi7iMuFW9IXly94NtMrkAvweJePA8VbFvqAxwRIaIiErk2rVrcHV1xcOHD7F06VK4ubmhQoUKyi5LLZmYmODJkyfQ0dGBqanpB1NMi09EFNhirWthBy3DT5AWeRn61q3f25YWeRnaxjWgW6thnsdqiUXYGxCPxX1sFfNmyghHZIiI6KOkp6dj5syZaNu2LYyNjREcHIz58+czxJRQzZo1UbVq1TxvmOdz/3mBHUoikQgGth2R/iAI8oy0nNdl6Sl4+zAYBrYd8z1WJhfgE6V+T/NmkCEiomK7fPky7O3tsXnzZqxZswb+/v6wsbFRdlka7Y1EivgiLMit1KgTIMtC2n3/nNfS7l4B5DIYNHIu8Nj4pHSkSaQlrrUsMcgQEVGRpaamYvLkyXB2dkbNmjURFhaGmTNnQktLS9mlaby4pDQUZYlvBVNz6NSoj7SIyzmvpUVchk5Na1SoUrPAYwUAj5LSCtxH1TDIEBFRkZw7dw6NGjXC7t27sXHjRly+fBn169dXdlnlRqY0/zv8/pdBo06QJNyB9HUisl7+hcyn91HJtuDRmI+5jipgkCEiogK9evUKY8aMweeffw4rKyvcuXMHU6ZMgVjMr5CypKNd9L9vg4btAZEYaXd9343MiLWh37Cdwq+jCti1RERE+Tpx4gQmTpyItLQ0/Pbbb3B1dVX4U5upaOqYGkAEFGl6SUvfCBXrNkPaHR8IsixUrNsUWvpGhR4n+uc66kS9YhcREZWJxMREDB8+HH379kWTJk0QERGR5x1nqewY6GrDohhPqzZo1AlZLx5BmvwEBkWcVrIw1YeBrnqNcTDIEBHRew4dOgQbGxucOXMGe/bswcmTJ1G7dm1ll0UAnK3NoCUuWpjUr98CYr1KEOkaQL9+4Xfs1RKL4GxlVtISy5x6xS4iIio1f//9N6ZOnYrDhw9jwIAB+OWXX1C9enVll1XuJCcnY8eOHXjz5g3evn2LjIwMZGRkIC4uDn+lA7I23xTtRCIxINaCvmULiLR1Ct1dJhfg0lK1HhxZFAwyRETlnCAI2LdvH6ZPnw4tLS0cOnQIgwYNUnZZ5VZAQADc3NwgFouhpaUFQRAgk8kgCAK0tLQwaLg7guJfF3hjPABIj7oOeXrKu/vKFEJLLELruqawNKusqLdRZji1RERUjj1+/BhffPEFRowYgc8//xyRkZEMMUrWvXt3WFtbAwCysrIglUpzHiJ5+PBh/DC4KbQLmF6SPL2P1JCzeHlpO3Sq1YOehV2h19QWi+DRv/D9VBGDDBFROSQIAn777TfY2tri9u3bOH78OPbt24eqVasqu7Ry782bN7Czs4Nc/u/9XMRiMcaNG4e+ffvC3EQfSwp4HlLq7dNIPrcJWvpGMO09o0jXXNrHFubFWEisSkRCXs8K/4/Xr1/DyMgIKSkpMDQ0LIu6iIiolDx69Ajjxo2Dt7c3XF1dsXbtWhgbGyu7rHJPIpFg06ZNWL58OdLT01G1alX89ddfAAALCwuEh4fDwODf1uiNPtFYcz6qxNd162aNKc6WJT6PohU1e3BEhoionJDL5di4cSMaNWqEqKgonDt3Dtu3b2eIUTK5XI69e/fC2toabm5uGDRoEGJiYvD777/nrI3x8vJ6L8QAwFTn+lg1wA662uIidzJl0xKLoKstxvcD7FQyxBQHF/sSEZUD0dHRGDNmDPz8/DBp0iSsWrWKI+xKJggCzp8/j7lz5yI0NBT9+/fH2bNn0aBBAwDvnoI9b9481KlTBy1atMjzHEMdLdCmXlXMPxoOvweJ0BKLClwEnL29dV1TePS3U9vppNw4tUREpMFkMhl++uknuLu7o2bNmti+fTs6duyo7LLKvVu3bmHu3Lm4ePEi2rZti9WrV6NVq1YlOmf0s1TsC4yHT9RzxCelv3cHYBHe3ezO2coMLi0t1KI7qajZg0GGiEhDRUZGwtXVFTdu3MC3336LZcuWfTA9QWUrJiYG7u7u8PLygo2NDVatWoXevXsr/I7JaRIpHiWlIVMqh462GHVMDdTujr1FzR7q9a6IiKhQWVlZWL16NZYuXYq6devC39+/xL/tU8k8f/4cy5cvx5YtW2BmZobt27dj5MiR0NYuna9hA11t2NYs/NlKmoBBhohIg4SEhMDV1RVhYWFwc3PDokWLoKenp+yyyq03b95g3bp1WL16NbS0tLBs2TJ888030NdX/7UpqoJBhohIA0gkEqxYsQIrV65Ew4YNERAQgObNmyu7rHIrKysL27dvx+LFi/Hy5Ut88803+N///gdTU1Nll6Zx2H5NRKTmbty4gWbNmmHlypVwd3fHzZs3GWKURBAEHD58GI0aNcLkyZPRvXt3REVFYc2aNQwxpYRBhohITb19+xZz5sxBq1atoKenh1u3bmHRokXQ0Sn8AYGkeFeuXEGrVq0waNAg1KtXD8HBwdi1axc+/fRTZZem0RhkiIjUkL+/PxwcHLBhwwasWLECAQEBsLe3V3ZZ5dKdO3fQu3dvdOjQATKZDJcuXcLp06fRuHFjZZdWLjDIEBGpkbS0NEyfPh3t2rWDqakpgoODMW/evFLrfqH8JSQk4Ouvv4a9vT3u3buHgwcP4saNG3B2dlZ2aeUK/8snIlITly5dwtixY/H333/jxx9/xDfffAMtLS1ll1XuvHz5EitXrsSGDRtgaGiIn3/+GePGjeOUnpIwyBARqbjXr1/Dzc0NW7duRYcOHXDhwgXUq1dP2WWVOxkZGfj555/h4eGBrKwszJs3D7NmzULlyqp/l1xNxiBDRKTCzpw5g/Hjx+PVq1fYtGkTJkyYALGYqwLKkkwmw969e7Fw4UL89ddfGD9+PL777jtUq1ZN2aURuEaGiEglJScnY/To0ejZsydsbGxw584dTJo0iSGmDAmCgFOnTsHBwQGjR49Gy5YtERkZiV9++YUhRoXwJ4KISMUcO3YMtra2OHbsGHbs2IGzZ8+yhbeMBQYGwtnZGb1790bVqlURGBiI33//HfXr11d2afQfDDJERCrixYsXGDp0KPr37w9HR0dERkbi66+/VvgDBSl/UVFRGDx4MFq2bInk5GScPn0aly5dQosWLZRdGuWDQYaISMkEQcDBgwdhY2MDb29v7N+/H8ePH0fNmjWVXVq58ffff2Py5MmwsbFBYGAgdu3aheDgYPTo0YNBUsUxyBARKdFff/2FAQMGYOjQoXB2dkZkZCS++uorfnmWkdTUVCxatAiWlpbw8vLCqlWrEBUVhZEjR7K1XU2wa4mISAkEQcDu3bvx7bffQkdHB3/88QcGDhyo7LLKjczMTGzduhVLly5Famoqpk+fjrlz56JKlSrKLo2KiSMyRERlLCEhAT179sTo0aPxxRdfIDIykiGmjMjl8pxpvOnTp+OLL75AVFQUVq1axRCjphhkiIjKiCAI2Lp1K2xtbREeHo6TJ09i9+7dfCpyGcletDt06FDY2NggNDQU27dvh7m5ubJLoxJgkCEiKgOxsbHo0qULJkyYgKFDhyIiIgK9evVSdlnlQmhoKD7//HN07twZFSpUgK+vL06cOIFGjRopuzRSAAYZIqJSJJfLsWHDBtjZ2SEmJgYXLlzA1q1bYWRkpOzSNN6jR48wYsQINGnSBA8fPsThw4dx7do1tG/fXtmlkQIxyBARlZL79++jffv2mD59OlxdXXHnzh106dJF2WVpvKSkJMyaNQvW1tbw9vbG5s2bcefOHQwYMIDdYBqIXUtERAomlUqxbt06fPfdd6hduzZ8fX05ClAG0tPTsX79eqxatQqCIGDhwoWYMWMGDAwMlF0alSIGGSIiBbpz5w5cXV1x69YtzJw5E0uWLIG+vr6yy9JoUqkUnp6eWLRoEV68eIFJkybB3d0dn3zyibJLozLAqSUiIgXIysrCsmXL0LRpU7x58wbXrl3DDz/8wBBTigRBwPHjx2Fvb49x48ahQ4cOuHfvHtavX88QU44wyBARldDt27fh6OiIJUuWwM3NDcHBwXByclJ2WRrt2rVraNeuHfr164datWrh1q1b2L9/P+rWravs0qiMMcgQEX0kiUQCd3f3nAcKBgUFYcWKFdDV1VVyZZrr3r176N+/P9q0aYO0tDScO3cOFy5cQNOmTZVdGikJgwwR0UcIDAxEkyZNsHr1aixatAhBQUFo0qSJssvSWE+fPsX48eNha2uLkJAQ7N27F7du3UK3bt2UXRopGRf7EhEVQ3p6Or777jusW7cOzZo1w+3bt3ljtVKUkpKC1atXY926ddDX18ePP/6IiRMnctSLcjDIEBEV0ZUrVzBmzBgkJCRg1apVmDFjBrS1+TFaGiQSCTZv3ozly5cjPT0dM2fOhJubG28kSB/g1BIRUSHevHmDqVOnokOHDqhWrRpCQ0Ph5ubGEFMK5HI59u3bhwYNGmD27NkYOHAgHjx4gOXLlzPEUJ74U0hEVABvb2+MHTsWL168wPr16zF16lSIxfwdsDScP38ec+fORUhICPr164czZ86gQYMGyi6LVBx/GomI8pCSkoJx48aha9euqFu3LsLDwzFt2jSGmFJw69YtdO3aFd27d4eBgQH8/f1x9OhRhhgqEv5EEhH9x6lTp2Bra4uDBw/i119/xcWLF3l/klIQGxuLYcOGoXnz5njy5AmOHz8OPz8/tG7dWtmlkRphkCEi+kdSUhJGjBiB3r17w97eHhERERg/fjwfNKhgL168wLRp09CgQQP4+vrit99+Q1hYGPr06cO/ayo2rpEhIgJw+PBhTJ48GZmZmfD09MTIkSP5papgaWlp+PHHH/HDDz9ALBZj6dKlmDZtGh/jQCXCERkiKteePXuGwYMHY9CgQWjVqhUiIyMxatQohhgFysrKwpYtW2BpaYnly5dj3LhxiImJwbx58xhiqMQYZIioXBIEAfv374etrS0uX74MLy8vHD16FDVq1FB2aRpDEAQcPnwYjRo1wuTJk9G1a1fcv38fa9euhampqbLLIw3BIENE5c6TJ0/Qt29fDB8+HF27dkVkZCSGDBnCURgFyl60O2jQINStWxfBwcHYvXs36tSpo+zSSMMwyBBRuSEIAnbs2AFbW1sEBQXh6NGjOHDgAD755BNll6Yx7ty5gy+++ALt27dHVlYWLl68iDNnzqBx48bKLo00FIMMEZULcXFx6N69O8aMGYN+/fohIiIC/fr1U3ZZGiMhIQGurq5o3Lgx7t69Cy8vL9y4cQOdOnVSdmmk4di1REQaTS6X49dff8WcOXNgbGyM06dPo0ePHsouS2O8fPkSq1atwoYNG1C5cmVs2LAB48aNg46OjrJLo3KCQYaINNaDBw8wduxY+Pr6YsKECVi9ejUMDQ2VXZZGyMjIwMaNG+Hh4YHMzEzMmTMHs2fPRuXKlZVdGpUzDDJEpHFkMhk2bNiABQsWoHr16vD29kbnzp2VXZZGkMlk2Lt3LxYuXIinT59i/Pjx+O6771C9enVll0blFNfIEJFGuXv3Ltq2bYtZs2Zh3LhxCAsLY4hRAEEQcPr0aTRp0gSjR4+Gk5MTIiMjsWnTJoYYUioGGSLSCFKpFCtXroSDgwOSk5Nx5coVrF+/HpUqVVJ2aWrvxo0bcHZ2Rq9evWBiYoKAgAAcOnQIVlZWyi6NiEGGiNRfWFgYWrZsCXd3d3z77bcICQlB27ZtlV2W2ouOjsbgwYPh5OSEpKQknDp1Cj4+PnByclJ2aUQ5GGSISG1lZmZi8eLFaNasGTIyMhAQEIDvv/8eFStWVHZpau3Zs2eYPHkybGxsEBgYCE9PT4SEhKBnz568aSCpHC72JSK1dPPmTbi6uuLu3buYP38+5s+fD11dXWWXpdZSU1OxZs0arF27Fjo6Oli5ciWmTp0KPT09ZZdGlC8GGSJSKxkZGVi8eDF++OEHNG7cGEFBQXBwcFB2WWotMzMT27Ztw9KlS5GSkoLp06dj3rx5qFKlirJLIyoUgwwRqY1r167B1dUVDx8+xLJly+Dm5oYKFSoouyy1JZfLcejQISxYsACxsbEYPXo0lixZAnNzc2WXRlRkXCNDRCovLS0NM2bMQNu2bWFsbIzg4GDMnz+fIaYELl26BCcnJwwdOhQNGzZEWFgYduzYwRBDaodBhohUmo+PD+zt7bFlyxasWbMG/v7+sLGxUXZZais0NBQ9evRA586doaWlBV9fX/z5559o1KiRsksj+igMMkSkklJTUzFp0iR06tQJtWvXRlhYGGbOnAktLS1ll6aW4uLiMHLkSDRp0gSxsbH4448/cP36dbRv317ZpRGVCNfIEJHKOXfuHMaPH4+kpCRs3LgRkyZNgljM37s+RlJSEjw8PLBx40ZUqVIFmzZtwpgxYzgtRxqDnwxEpDJevnwJV1dXfP7557CyssKdO3cwZcoUhpiPkJ6ejlWrVqFevXrYunUr3N3d8eDBA0ycOJEhhjQKR2SISCWcOHECEydORFpaGn777Te4urry5msfQSqVYteuXVi0aBGeP3+OiRMnwt3dHWZmZsoujahU8NccIlKqxMREDBs2DH379kXTpk0RERGBMWPGMMQUkyAIOHHiBBo3boyxY8eiXbt2uHv3LjZs2MAQQxqNQYaIlEIQBBw6dAg2NjY4e/Ys9uzZgz///BO1a9dWdmlq59q1a2jfvj369u2LGjVq4ObNmzhw4ADq1aun7NKISh2DDBGVub///huDBg3Cl19+iXbt2iEyMhIuLi4chSmme/fuoX///mjTpg3evHmDc+fO4cKFC2jWrJmySyMqMwwyRFRmBEHAnj17YGNjAz8/Pxw6dAiHDx9G9erVlV2aWnn69CkmTJiARo0aISQkBHv37sWtW7fQrVs3hkEqdxhkiKhMPH78GL1798bIkSPRo0cPREZGYtCgQcouS62kpKTA3d0dlpaWOHz4MNasWYN79+5h+PDh7OyicotdS0RUqgRBwPbt2zFr1iwYGBjg+PHj6NOnj7LLUisSiQSbN2/G8uXLkZ6ejhkzZmDOnDkwMjJSdmlESscIT0Sl5uHDh+jatSvGjRuHQYMGITIykiGmGORyOfbt24cGDRpg1qxZ6N+/P6Kjo7FixQqGGKJ/MMgQkcLJ5XJs3LgRdnZ2iI6Oxrlz57B9+3YYGxsruzS1cf78eTRr1gwuLi5wcHDAnTt3sG3bNtSqVUvZpRGpFAYZIlKo6OhodOjQAd988w1GjhyJO3fuoFu3bsouS23cvn0bXbt2Rffu3aGvr4+rV6/i6NGjaNiwobJLI1JJDDJEpBAymQxr166Fvb09nj59Ch8fH2zatAmVK1dWdmlqITY2FsOGDUOzZs3w+PFjHDt2DFevXkWbNm2UXRqRSmOQIaISi4iIQOvWreHm5oZJkyYhLCwMHTt2VHZZauHFixeYPn06GjRoAF9fX2zbtg3h4eHo27cvW6mJioBdS0T00bKysrB69WosXboUdevWhb+/P1q1aqXsstRCWloa1q1bh9WrV0MkEmHJkiWYPn069PX1lV0akVphkCGijxISEoKvv/4a4eHhcHNzw6JFi6Cnp6fsslReVlYWduzYgcWLFyM5ORlTpkzB/PnzUbVqVWWXRqSWOLVERMUikUjw3XffwdHRETKZDAEBAVi5ciVDTCEEQcCRI0fQqFEjTJo0CV26dMH9+/fx448/MsQQlQCDDBEV2Y0bN9CsWTOsXLkS7u7uuHnzJpo3b67sslSen58fWrdujYEDB+Kzzz7D7du3sWfPHtSpU0fZpRGpPQYZIirU27dvMWfOHLRq1Qp6enq4desWFi1aBB0dHWWXptIiIiLQp08ftG/fHllZWfD29sbZs2fh4OCg7NKINAaDDBEV6OrVq2jcuDE2bNiAFStWICAgAPb29souS6U9fvwYrq6usLe3R0REBLy8vHDjxg107txZ2aURaRwGGSLK05s3bzBt2jS0b98eVatWRXBwMObNmwdtbfYI5Ofly5eYO3cu6tevjz///BM//fQT7t69iyFDhvChjkSlhJ9IRBoiTSLFo6Q0ZErl0NEWo46pAQx0P+5H/OLFixg7diyePXuGH3/8Ed988w20tLQUXLHmyMjIwMaNG+Hh4QGJRAI3NzfMnj0bhoaGyi6NSOMxyBCpsehnqdgXGA+f+88Rn5wOIdc2EQALE304W5thuJMF6lcr/A67KSkpmDNnDrZu3YoOHTrA29sb9erVK7X61Z1MJsO+ffuwcOFCPHnyBOPHj8d3332H6tWrK7s0onJDJAiCUNhOr1+/hpGREVJSUvgbBpEKSEhOx/yj4fB7kAgtsQgyef4/xtnb21lWhUd/O5ib5H3DtTNnzmD8+PF49eoVVq9ejQkTJnA6JB+CIODMmTOYN28ewsPDMWjQIKxYsQJWVlbKLo1IYxQ1e/BTikjNeAXFo8s6X1yLTQKAAkNM7u3XYpPQZZ0vvILi39uenJyMUaNGoWfPnrCxscGdO3cwadIkhph83LhxA506dUKvXr1QpUoVBAQE4NChQwwxRErCTyoiNbLRJxrzjoRDIpUXGmD+SyYXIJHKMe9IODb6RAMAjh49ChsbGxw/fhw7duzA2bNn8emnn5ZG6WovOjoaX375JZycnJCYmIiTJ0/i8uXLcHJyUnZpROUagwyRmvAKisea81EKOdea81FwHrsAAwYMQIsWLRAZGYmvv/6aDynMw7NnzzBlyhTY2Njg+vXr2LlzJ0JCQtCrVy/+fRGpAC72JVIDCcnpWHQiQnEnFATEVmmOjZ4HMHnkEH4h5yE1NRVr167FmjVrUKFCBXh4eGDq1KmoWLGisksjolwYZIjUwPyj4ZAWcyqpQCIRtCvoIEBaE1MYYt6TmZmJbdu2YenSpUhJScG0adMwb948mJiYKLs0IsoDgwyRiot+lgq/B4kF7pOREIGXF39D5otH0K5sCkOngZC9SUaK/wF8Ou9knsfIBMDvQSIePE+FpVnhrdmaThAEHDp0CPPnz0dsbCxGjRqFJUuWwMLCQtmlEVEBuEaGSMXtC4yHljj/UZPM54/w/OB3kKW/gnHbYTCw64JXV/chPep6oefWEouwNyC+0P00nY+PD1q0aIEhQ4agQYMGCA0Nxc6dOxliiNQAgwyRivO5/7zADqVXfnsBCKg+/HsYtRoM4zZDUf2rlchKLDygyOQCfKKeK7Ba9RIWFoYePXqgU6dOEIvFuHz5Mk6ePAk7Oztll0ZERcQgQ6TC3kikiE9Oz3e7IJch42EwKtZvCW0js5zXK1Q1R8W6TYt0jfikdKRJpCWuVZ3ExcVh5MiRcHBwQExMDA4dOoSAgAB06NBB2aURUTExyBCpsLikNBS0xFee/hqCVIIKVWp+sE3bpFaRriEAeJSU9nEFqpmkpCTMnj0bVlZWOH/+PH755RdERERg0KBB7NwiUlNc7EukwjKlco26jrK8ffsWGzZswMqVKyGTybBgwQLMnDkTlSpVUnZpRFRCDDJEKkxHu+BBU7G+IUTaush6+fSDbdLkJwq7jrqSSqXYtWsXFi1ahGfPnmHixIlYuHAhzMzMCj+YiNSCZn56EWmIOqYGKGjCQyTWgt5nTfA2OgDSlH8X7WYlJuBt7O0iXUP0z3U0iSAIOHHiBBo3boyxY8eibdu2uHfvHn7++WeGGCINwyBDpMIMdLVhkc/TqrMZtxsOAPh731ykBPyBlGsH8feB/6FC1aK1DluY6sNAV3MGZ69fv4727dujb9++qF69OoKCguDl5YV69eopuzQiKgUMMkQqztnarMD7yOiYfQazL5dCS98Ir/z24k3YBRi3HQ59q1aFn1yQw6qSFIKgwLsGFyBNIkXE0xQEx79ExNMUhXZL3b9/HwMGDEDr1q2RmpqKs2fPwtvbG82bN1fYNYhI9WjOr2FEGmq4kwU8rz8qcB89i0aoMfqn91575bev8JOLxPB0d0XAL8aYOHEiRowYAUNDw48vNg/Rz1KxLzAePvefIz45/b0uLBEACxN9OFubYbiTBepXK/4dhp8+fYolS5Zg+/btqF27Nvbs2YNhw4ZBLObvaUTlAX/SiVRcvU8MYGmQBS0FdwdriUVoa1kVZw96wsrKCtOnT0fNmjUxceJEhIaG5nmMIAi4f/9+kc6fkJyOEdsD0fWnK9gTGIe4/4QY4F3rd1xyOvYExqHrT1cwYnsgEgq4b05uKSkpcHd3h6WlJf744w/88MMPuHfvHlxcXBhiiMoR/rQTqbCEhAR07doVvmsmQlTgHWWKT1sswsr+dujcuTMOHz6MuLg4uLm54c8//4SDgwPatGmDvXv3IiMjI+eYXbt2oUGDBti8eXOB5/YKikeXdb64FpsEAAXemTj39muxSeiyzhdeQfnflVgikWD9+vWoV68e1q5di+nTpyMmJgYzZsyAnp5eUd8+EWkIBhkiFeXl5QV7e3tERUXh3JH9WN7fXqHnX9rHFua5FhLXqlULixYtwqNHj3D48GHo6+tjxIgRqF27NubOnYvY2FisX78eADBlyhScPJn3wyg3+kRj3pFwSKTyQgPMf8nkAiRSOeYdCcdGn+j3tsnlcuzfvx8NGzbEzJkz0b9/fzx48AArV66EsbFx8d48EWkMkVCEVX6vX7+GkZERUlJSFD5/TkTve/XqFaZMmYL9+/fjq6++wi+//IIqVaoAeBcS1pyPKvE13LpZY4qzZaH7RUVFYcuWLfD09MTLly9zXheJRNDV1YWfn997i2m9guIx70h4ievL9v0AOwxxtMCFCxcwd+5cBAcHo2/fvvDw8ICNjY3CrkNEqqeo2YNBhkiF+Pj4YNSoUXj9+jU2bdqEYcOGfbCPV1A8Fp2IgFQuFGvEQ0ssgrZYhKV9bDHEsXhPdU5PT0e3bt3g7++f85pIJIKxsTFu376NOnXqICE5HV3W+UKiwLsE64iBWqE7cfnUYbRu3Rrff/892rZtq7DzE5HqKmr24NQSkQqQSCSYPXs2OnfuDEtLS4SFheUZYgBgqKMFvGd0QOu6pgBQYGt27u2t65rCe0aHYoeY7Ppu3rz53muCIODly5ewt7dHWloa5h8Nh7SYU0mFXlcqQ1y11jh69CiuXr3KEENEH2D7NZGShYeHw8XFBffu3cMPP/yAGTNmFNp1Y26ijz1jnP5tbY56jvikPFqbTfXhbGUGl5YWsDQrfmtzNn9/f0gkkvdeq1SpErS1tVGhQgWExyfC70HiB8dlPn+Iv3Z8g08GLoR+fScAgOTvB/jb81voVKuHGl+vz9n32e+LIH+bihqjfvz3PYi1IDezRqPW7flQRyLKE4MMkZLI5XL89NNP+N///gcrKysEBQXB3r54C3rrV6uMxX1ssRi2SJNI8SgpDZlSOXS0xahjaqCwO/b27NkTt27dgoGBAUxNTVGlShVoaWnlbF98IgJaYtEHU10VPvkUYl0DSBLu/BtkEiIAkRiZzx9CLkmHWFcfgiCH5MldVG78+QfX1hKLsDcgHov72CrkvRCRZuHUEpESZLdVz5o1C1OnTv2oEPNfBrrasK1phCYWVWBb00ihjx0Qi8Vo2rQprK2tUbVq1fdCDAD43H+e53odkUgM3do2yEiIyHlNkhAB/fot3/37k7sAgKxnDyFI0qFr/mFYkckF+EQ9/+B1IiKAQYaozB04cCCnrfrixYtYu3atWt//5I1EivgCbmKna26LzGcxkGe+ux9NxuNI6NVrDp1qdXMCTsbjCAAi6NbOuxMpPildoY8zICLNwSBDVEZevnyJYcOGYdiwYejRowfCwsLQqVMnZZdVYnFJaQXeqk+3ti0gl0Hy9B6ykh5Dnv4Keua20DW3fTfNhHejNBWqmkOrYt7reAQAj5LSFF88Eak9rpEhKgOXLl3CqFGjkJqamnN/GE2RWUi7tW4NS4i0dSCJvwOp0ScQ6xujgkkt6NW2Rert0xCkWch4HFHoQy4Luw4RlU8ckSEqRRkZGZg1axY6d+6M+vXrIzw8XKNCDADoaBf8MSLSqgCdGlbIeBwBSUIE9MzfTR/pmtsCsiykRfhAnvYKeuaNSnQdIiqf+MlAVErCwsLQokULbNy4EWvXroW3tzfMzc2VXZbC1TE1QGGN0brmtsh8GoWM+PB3U00AtPSNUMHUHCmBh9/tUzv/riTRP9chIvovBhkiBZPL5Vi7di0cHR0BADdv3sTMmTM19onMBrrasMj1zKa86NW2gSCVQPb6xXudSbrmtpAmP4GWUTVoG1bN93gLU32FdmERkebQzE9WIiVJSEhAly5d4ObmhmnTpiEoKAh2dnbKLqvUOVubFXiHYd1aDQGRGCKditAx++zf1/8JNXr5dCsB7+4j42xlprhiiUij8FccIgXZv38/Jk+eDENDQ1y8eBHOzs7KLqnUCYKAy5cv49ymnyFrMibf/cS6+vh07okPXq9k64xKtgX/PcnkAlxaFv+xCkRUPnBEhqiEXr58ia+++grDhw9Hr169EBYWpvEhRhAEXLp0CR06dECnTp2QlRgPGxNRoc99Ki4tsQjtLKuW6PEKRKTZGGSISuDSpUuwt7fH2bNnceDAAezbtw/GxsbKLqvU5A4wnTt3xtu3b3Hy5EkEBQXh1zEdoa3gIKMtFsGjv+ZPzRHRx2OQIfoIGRkZmDlzJjp37gwrKyuEhYVh6NChyi6r1AiCgIsXL6J9+/bvBZgbN26gV69eEIlEMDfRxxIFPw9paR9bmBeykJiIyjcGGaJiCgsLg6OjIzZt2oQff/wRFy5c0Mi2auD9ANOlSxdIJBKcOnXqvQCT21BHC8zuZqWQa7t1s8YQR66NIaKCMcgQFZFcLseaNWvg6OgIsViMmzdvYsaMGRrZVi0IAry9vdGuXbv3AkxgYCB69uz5QYDJbapzfawaYAddbXGx18xoiUXQ1Rbj+wF2mOJsWdK3QUTlgOZ9AhOVgvj4eHTu3Blz5szB9OnTcePGDTRqVPCdaNVR7gDTtWtXZGZmFjnA5DbU0QLeMzqgdV1TACg00GRvb13XFN4zOnAkhoiKjO3XRIXI3VZ96dIldOzYUdklKVx2gFm8eDGuXbuGFi1a4PTp0/j888+LHF7+y9xEH3vGOCH6WSr2BcbDJ+o54pPS33vApAjvbnbnbGUGl5YW7E4iomJjkCHKx8uXLzF58mR4eXlh+PDh2Lhxo8Z1JJVGgPmv+tUqY3EfWyyGLdIkUjxKSkOmVA4dbTHqmBrwjr1EVCL8BCHKw8WLFzF69Gi8efMGXl5eGDJkiLJLUqj/BhgnJyecOXMG3bt3V1iAyYuBrjZsaxqV2vmJqPzhGhmiXLLbqrt06QIrKyuEh4drVIgRBAHnz59HmzZt0K1bN8hkMpw5cwbXr19X6CgMEVFZYZAh+kdoaOgHbdW1a9dWdlkKkTvAdO/eHXK5HGfPnmWAISK1xyBD5Z5MJsMPP/yAFi1aaFxbtSAIOHfuHFq3bo3u3btDEIScAFPa00hERGVB/T+piUogLi4OnTt3xty5czWqrTp3gPn8888BAGfPnsW1a9cYYIhIozDIULkkCAL27t0Le3t7PHz4ED4+Pli9ejV0dXWVXVqJZI+4tGrVKifAnDt3jgGGiDQWgwyVO8nJyRg6dChGjBiBPn36ICwsDB06dFB2WSWSO8D06NEDYrE4J8B069aNAYaINBaDDJUr3t7esLe3x4ULF3Dw4EHs2bMHRkbq2w4sCALOnDmDli1b5gSY8+fPw9/fnwGGiMoFBhkqFzIyMjBjxgx07doVDRs2RHh4OL788ktll/XRcgeYnj17QltbOyfAdO3alQGGiMoNBhnSeKGhoWjevDk2b96MdevW4dy5c6hVq5ayy/oogiDg9OnTcHJyygkwFy5cwNWrVxlgiKhcYpAhjSWTybB69Wo4OjpCW1sbN2/exLfffquWbdW5A0yvXr2go6OTE2C6dOnCAENE5Zb6faITFUFcXBw6deqEefPmYcaMGQgMDFTLtur8Aoyfnx8DDBERGGRIwwiCgD179sDe3h6PHj2Cj48Pvv/+e7VrqxYEAadOnUKLFi1yAoy3tzcDDBHRfzDIkMZITk7GkCFDMHLkSPTt21ct26pzB5jevXtDT08vJ8B07tyZAYaI6D8YZEgjeHt7w87ODt7e3vj999+xe/dutWqrFgQBJ0+efC/AXLx4EVeuXGGAISIqAIMMqbW3b9/i22+/RdeuXWFra4vw8HAMHjxY2WUVWXaAcXR0xBdffIGKFSvmBJhOnToxwBARFYJBhtRWSEgImjdvji1btmD9+vU4e/as2rRVC4KAP//8MyfA6Ovr49KlS/D19WWAISIqBgYZUjvZbdUtWrSAjo4Obt26hWnTpqlFW3V2gGnevDn69OkDAwODnADj7OzMAENEVEyq/8lPlEvutuqZM2ciICAAtra2yi6rUIIg4MSJEzkBplKlSrh06RIuX77MAENEVAIMMqQWcrdVx8XF4fLly1i1apXKt1VnB5hmzZqhb9++qFSpEnx8fDgCQ0SkIAwypPL+21YdGhqK9u3bK7usAv03wBgaGuYEmI4dOyq7PCIijaGt7AKICnLhwgWMHj0ab9++xe+//67yHUnZAWbJkiUIDg5Gx44d4ePjw/BCRFRKOCJDKunt27eYPn06unXrphZt1YIg4Pjx42jWrBn69esHIyMj+Pj4MMQQEZUyBhlSOcHBwWjevDm2bt2q8m3VgiDg2LFjaNq0Kfr16wdjY2NcvnyZAYaIqIwwyJDKkMlkWLVqFZycnFS+rTp3gOnfvz+qVKmCy5cv49KlS2r3WAQiInWmet8QVC49evQIzs7OmD9/PmbNmoXAwEDY2Ngou6wPyOVyHD16FE2aNGGAISJSAQwypFSCIGD37t2wt7dHfHw8fH19sXLlSujo6Ci7tPdkB5imTZtiwIABMDU1ha+vLwMMEZGSMciQ0iQlJeHLL7/EqFGjMGDAAISFhaFdu3bKLus9crkcR44cQZMmTd4LMBcvXlT5FnAiovKA7dekFOfPn8fo0aMhkUhw6NAhDBo0SNklvUcul+PYsWNYsmQJwsLC0LlzZ1y5ckXlghYRUXnHERkqU2/fvsW0adPQvXt3NGrUCOHh4SoVYnKPwAwcOBCffPIJrly5Am9vb4YYIiIVxCBDZeb27dto1qwZtm3bhg0bNuDs2bOoWbOmsssC8C7AHD58GA4ODhg4cCDMzMzg5+fHAENEpOIYZKjUyWQyrFy5Ei1btoSenh5u3bqFb775RiXaqnMHmEGDBqFatWrw8/PDhQsX0LZtW2WXR0REhVD+NwlptIcPH6Jjx45YsGABZs+ejYCAAJVoq5bL5fjjjz/QuHFjBhgiIjXGIEOlQhAE7Nq1C40bN8bjx49x5coVeHh4KL2tOneAGTx4MGrUqIGrV68ywBARqSkGGVK4pKQkDB48GKNHj8bAgQMRGhqq9JAgl8tx6NChDwLM+fPn0aZNG6XWRkREH49BhhTq3LlzsLOzg4+PD/744w/s3LkThoaGSqsnO8DY29vjyy+/RM2aNRlgiIg0CIMMKUR2W/Xnn38Oe3t7hIeHY+DAgUqrRy6X4/fff88JMLVq1YK/vz/OnTvHAENEpEEYZKjEcrdV//zzzzhz5ozS2qpzB5ghQ4agdu3auHbtGs6dO4fWrVsrpSYiIio9DDL00bLbqp2cnKCnp4fbt29j6tSpEIlESqnl4MGDsLOzey/AnD17Fq1atSrzeoiIqGwwyNBHyW6rdnd3h5ubGwICAtCwYcMyryM7wNjb22Po0KGwsLDA9evXGWCIiMoJBhkqFkEQ4OnpmdNW7evrq5S26vwCzJkzZ9CyZcsyrYWIiJSHQYaKLDExEYMGDcLXX3+ttLZqmUwGLy8v2NnZYejQofj0008REBDAAENEVE4xyFCRnD17FnZ2dvD19cXhw4fLvK06d4D56quvUKdOHQQEBOD06dNwcnIqszqIiEi1MMhQgdLT0zF16lT06NEDjRs3Rnh4OAYMGFBm15fJZDhw4AAaNWrEAENERB9gkKF8ZbdVb9++PaetukaNGmVy7dwBZtiwYahbty4CAwMZYIiI6D0MMvQBmUwGDw8PODk5QV9fv0zbqmUyGfbv3/9BgDl16hRatGhR6tcnIiL1wiBD73n48CE6dOiAhQsXYs6cObh+/XqZtFVnBxhbW1sMHz4c9erVY4AhIqJCMcgQgHdt1Tt37oS9vT2ePn2KK1euYMWKFaXeVi2TybBv376cAGNpaYkbN27g5MmTDDBERFQoBhlCYmIiBg4cCFdXVwwePBghISGl/jyi3AHGxcUF9evXzwkwjo6OpXptIiLSHNrKLoCU68yZM3B1dUVWVhYOHz5c6h1JUqkUXl5eWLZsGaKiotC7d2/s3bsXzZs3L9XrEhGRZuKITDmVnp6OKVOmoGfPnnBwcCj1tmqpVIq9e/fC1tYWI0aMgLW1NYKCgvDnn38yxBAR0UdjkCmHbt26haZNm2LHjh345ZdfcPr06VJrq84rwNy8eRMnTpxggCEiohJjkClHpFIpVqxYgZYtW6JSpUoIDg7G5MmTS6WtWiqVYs+ePbCxsfkgwDRr1kzh1yMiovKJQaaciI2NRYcOHfDdd99h7ty5uHbtGho0aKDw6+QOMCNHjkTDhg0ZYIiIqNQwyGi47Lbqxo0b46+//sKVK1ewfPlyhbdVS6VS7N69Gw0bNnwvwBw/fpwBhoiISg2DjAbL3Vb95ZdfIjQ0VOFt1bkDzKhRo2Bra4tbt24xwBARUZlg+7WGyt1WfeTIEfTv31+h55dKpdi3bx+WL1+OBw8eoG/fvjh48CCaNm2q0OsQEREVhCMyGiZ3W3WTJk0QHh6u0BAjlUqxa9cuNGjQAKNHj0ajRo1w+/ZtHDt2jCGGiIjKHEdkNMjNmzfh4uKC+Ph4/PLLL5g0aZLCOpKy26iXL1+OmJgY9OvXD4cOHUKTJk0Ucn4iIqKPwREZDSCVSrF8+XK0atVK4W3VUqkUnp6eaNCgAb7++mvY29sjODgYR48eZYghIiKlY5BRczExMWjfvj0WLVqEefPm4fr167C2ti7xebOysrBz505YW1u/F2COHDkCBweHkhdORESkAJxaUlOCIGDHjh349ttvYWZmBj8/P7Ru3brE583KysqZQoqNjcWAAQNw5MgRNG7cWAFVExERKRZHZNTQixcvMGDAAIwdOxZffvklQkJCShxiskdgGjRoAFdXVzg4OCAkJASHDx9miCEiIpXFERk1c/r0abi6ukImk+Ho0aPo169fic6XlZWFPXv2YPny5Xj48CFHYIiISK1wREZNpKenY/LkyejVqxeaNm2K8PDwEoWYrKws7NixA9bW1hgzZgyaNm2K0NBQjsAQEZFa4YiMGggKCoKLiwsSEhKwadMmTJw48aM7krKysrB7926sWLECDx8+xMCBA3Hs2DHY29sruGoiIqLSxxEZFSaVSrFs2TK0bt0ahoaGCA4O/uh7w2RlZWH79u2wsrLC2LFj0axZM4SGhuKPP/5giCEiIrXFERkVFRMTgxEjRiAwMBALFizAwoULUaFChWKfJysrC7t27cKKFSvw6NEjDBo0CCdOnICdnV0pVE1ERFS2GGRUjCAI2L59O7799ltUq1YNV69eRatWrYp9nszMzJwppEePHmHw4MEMMEREpHE4taRCXrx4gf79+2PcuHEYOnQoQkJCih1iMjMzsW3bNlhZWWHcuHFwdHREWFgYfv/9d4YYIiLSOByRURGnTp3CmDFjPrqtOjMzM2cKKT4+HoMHD8bJkyfRqFGj0imYiIhIBXBERsnS0tIwadIk9O7dG82aNSt2W3VmZia2bt2K+vXrY8KECXByckJYWBgOHjzIEENERBqPIzJKFBQUhOHDh+Px48fYvHkzJkyYUOSOpMzMTHh6emLFihVISEjAl19+idOnT8PW1raUqyYiIlIdHJFRguy26latWsHY2BghISFFvjdM7hGYiRMnolWrVggPD4eXlxdDDBERlTsckSljMTExcHFxwY0bN+Du7g53d/citVVnZmZi586d8PDw4AgMERHRPzgiU0YEQcBvv/2Gxo0b48WLF/D398eSJUsKDTGZmZn49ddfUb9+fUyaNAmtW7fGnTt3OAJDREQEBpky8fz5c/Tr1w/jxo3DV199hZCQELRs2bLAYyQSCbZs2QJLS8v3AsyBAwdgY2NTRpUTERGpNk4tlbJTp07B1dUVcrkcx44dQ9++fQvcXyKR5EwhPX78GEOHDoW7uzvDCxERUR44IlNK0tLSMHHiRPTu3RuOjo64c+dOgSFGIpFg8+bNsLS0xOTJk9G2bVtERERg//79DDFERET54IhMKbhx4wZcXFzw5MkTbNmyBePHj8+3I0kikWDHjh3w8PDAkydP8NVXX8Hd3R0NGzYs46qJiIjUD0dkFEgqlWLJkiVo3bo1jI2NERwcnO+9YSQSCTZt2gRLS0tMmTIF7du3R0REBPbt28cQQ0REVEQMMgoSHR2Ntm3bYtmyZViwYAH8/f1hZWX1wX65A8w333yDDh06IDIykgGGiIjoIzDIlJAgCNi2bRscHByQmJiIq1ev5tlWnZGRgV9++QX16tXLCTARERHYu3cvGjRooKTqiYiI1BuDTAlkt1WPHz8ew4cPz7OtOjvAWFpaYtq0aejYsSMDDBERkYJwse9HOnnyJMaMGQNBEHD8+HH06dPnve0ZGRnYvn07Vq5cib/++gvDhg2Du7s7rK2tlVQxERGR5uGITDGlpaVhwoQJ+OKLL+Do6Ijw8PD3QkxGRgY2btyIevXqYdq0aXB2dkZkZCT27NnDEENERKRgDDL5SExMxK1bt957LTAwEA4ODti7dy+2bNmCP//8E9WqVQPwfoCZPn06OnfujLt37zLAEBERlSIGmTwIgoBBgwahZcuWCA0NhVQqxeLFi9GmTRuYmJi811adkZGBn3/++YMAs3v37jy7loiIiEhxNHqNTJpEikdJaciUyqGjLUYdUwMY6Bb+ls+fPw9fX1+IRCL07dsXpqamCA0Nhbu7OxYsWIAKFSogIyMD27Ztw6pVq/D333/DxcUFCxYsYHghIiIqQxoXZKKfpWJfYDx87j9HfHI6hFzbRAAsTPThbG2G4U4WqF+t8gfHy+VyzJo1C2KxGHK5HHFxcXjy5An8/f3h5OSEt2/fYvPmzVi1ahWePXsGFxcXuLu7o379+mX2HomIiOgdjQkyCcnpmH80HH4PEqElFkEmFz7YRwAQl5yOPYFx8Lz+CO0sq8Kjvx3MTfRz9tm3bx8iIiLeO04qlcLPzw+BgYE5AWbEiBFYsGABAwwREZESiQRB+PAb/z9ev34NIyMjpKSkwNDQsCzqKhavoHgsOhEBqVzIM8DkR0ssgrZYhCV9bDHU0QIZGRmoVasWkpOT895fSytnCokBhoiIqPQUNXuo/YjMRp9orDkf9VHHyv4JPvOOhCPxjQSxf27ON8QA70ZrhgwZ8rGlEhERkYKpddeSV1D8R4eY/1pzPgq12w/GuHHjULnyh2tnxGIxtm7dqpBrERERkWKobZBJSE7HohMRhe9YDL/eegUtQzOkpqZ+sE0ul8PX1xfp6ekKvSYRERF9PLWdWpp/NBzSYqyHySbPzIBYRy/PbVK5gNcNeuPGjb6oWLHiB9urVKkCfX39PI4kIiIiZVDLIBP9LBV+DxIL3e+V3z6k+B9AjbGbkHLtIDJibkLLqBpqum7Ic3+ZXIB/TBKW9GkPS7MPp5eIiIhItajl1NK+wHhoiUVF3j/x2CoIWRIYdxiFyg7dC9xXSyzC3oD4kpZIREREZUAtR2R87j8vVpt1BbPP8EkftyLtK5ML8Il6jsWw/djyiIiIqIyo3YjMG4kU8cnFW3Bb2aFHsfaPT0pHmkRarGOIiIio7KldkIlLSkNxl/hqG1cr1v4CgEdJacW8ChEREZU1tQsymVJ5sY8RaeuUyXWIiIiobKldkNHRLpuSy+o6RERE9PHU7tu6jqkBit6v9HFE/1yHiIiIVJvaBRkDXW1YmJTuTeksTPVhoKuWDV1ERETlitoFGQBwtjYr1n1kikMEAa3rGJXKuYmIiEix1DLIDHeyKNJ9ZIzbDcen805CS7/owUSACFvdRmDp0qVISUkpSZlERERUytQyyNSvVhntLKsqfFRGSyxCC/PKGNG3Kzw8PFCnTh0sW7aMgYaIiEhFqWWQAQCP/nbQVnCQ0RaLsHZoc/z000+IjY3FyJEjsWLFCnz22WdYvnw5Xr9+rdDrERERUcmobZAxN9HHkj6KfYzA0j62MP9nIXHNmjWxfv16xMbGwsXFBcuXL0edOnWwYsUKBhoiIiIVobZBBgCGOlpgdjcrhZzLrZs1hjhafPB6zZo1sWHDBsTExGD48OFYunQpPvvsM3h4eCA1NVUh1yYiIqKPo9ZBBgCmOtfHqgF20NUWF3vNjJZYBF1tMb4fYIcpzpYF7lurVi38/PPPiImJwVdffYUlS5agTp06WLlyJQMNERGRkogEQSi0/ef169cwMjJCSkoKDA0Ny6KuYktITsf8o+Hwe5AILbGowK6m7O3tLKvCo79dznRScTx+/BgrV67Eb7/9hsqVK2P27NmYOnUqKlWqVJK3QURERCh69tCYIJMt+lkq9gXGwyfqOeKT0t97wKQI725252xlBpeWFrA0q1zi6yUkJOQEGiMjI7i5uWHy5MkMNERERCVQboNMbmkSKR4lpSFTKoeOthh1TA1K7Y698fHxWLlyJbZv3w4jIyPMmTMHkydPhoEBH3VARERUXAwyShIfHw8PDw/s2LEDxsbGmDNnDiZNmqTwQFOWIY2IiKisMcgoWVxcXE6gMTExyQk0+vr/rscJDQ2Fv78/Jk+eXKRz5kyb3X+O+OQ8ps1M9OFsbYbhThaoX63k02ZERETKwiCjIh49egQPDw/s3LkTJiYmmDt3LiZOnIiKFSuicePGCA8Ph6enJ0aNGpXvOcp6ITMREZGyMciomIcPH8LDwwOenp4wNTVFr169sGPHDgCAnp4ebt26BRsbmw+O8wqKx6ITEZDKhSI9XyqbllgEbbEIS/rYYmge98chIiJSZQwyKio2NhYrVqzICTEAoKWlBUtLS9y+ffu9qaeNPtFYcz6qxNec3c0KU53rl/g8qorrhYiINE9Rswc/7ctY3bp18cUXX7wXZGQyGaKiojBp0iTs2rULwLuRGEWEGABYcz4Kn1TSzfPOxeqK64WIiAjgiIxSNGnSBCEhIXluW7ZsGUZNnoku63whkcoVdk1dbTG8Z3RQ+zUzXC9ERFQ+cERGhbVr1w7GxsbIzpCCIODt27d4/PgxRCIR5h8Nh7QY62GKQioXMP9oOPaMcVLoectS7vVCAApdM5S9/VpsErqs8+V6ISIiDcQRGRUT/SwVXX+6ku/2xJPrkBEfjtqTd7z3+iu/fUjxP4BP550s8PzeM9or5I7GZY3rhYiIypeiZg+1f2ikptkXGF/sh18WlZZYhL0B8aVy7tJU2HqhjMd38cpvH+QZbwo915rzUTgYpH5/B0RElDcGGRXjc/95sdqsi0MmF+AT9TzPbYmJibhz506pXLckEpLTsehERIH7SJ7cRYr/Acgz0op0zu9ORCAhOV0R5RERkZIxyKiQNxIp4kv5CzY+KR1pEmnOn+/cuYOxY8eiVq1aaNWqVale+2OU5nohIiJSf1zsq0LiktJQOmMx/xIAPHzxBo9CrmLt2rW4fPkytLW1IZVKoaOjU8pXL57oZ6nwe5BY4D7Za4MA4MmWMTmv15q4HdrG1fI8RiYX4PcgEQ+ep6rleiEiIvoXg4wKySxKu7Uon/UzQtFbtdt1dMarmJCcP0ul70ZoBEHAihUrULlyZRgaGr73v//9dy0trSJf72NlrxcqaKpN37o1sl4+RXqkL6p0HgdxxXcLwsT6RgWeO3u90OI+tgqtmYiIyhaDjArR0S58pk+sZwC55MO1INKUvNe+5MXKsi5uxIRAJBIhd9NaZmYm1q9fj9TUVGRkZBR4Dn19/XyDTnFf09bO+z/DoqwX0jH7DDrV6iE90hf69VvmOwrzX9nrhRaDQYaISJ0xyKiQOqYGEAEFTi9VMK4BQZKGzOcPoWP2GQBA+iYZ6dEBRbqGCMCl4wcRG3UX06dPh4+PD8RiMeRyORo3boygoCAAQFZWFlJTU5GamorXr19/8O95vZaamoonT57g3r17772Wnl7wuh89Pb0Pgk712p8i3mJIkd7Tx8peL8THGRARqS9+gqsQA11tWJjoI66ABb/6Nu3x8rInXhxZgcrNvoAglSA1+AwqVKmJzGcxhV7DwlQfBrrasLOzw8WLF3Hq1ClMnz4dsbGxMDY2ztmvQoUKMDExgYmJSYnfl1QqxZs3b4oViN7qmZTJeqFHSWmwrVnwNBQREakuBhkV42xthj2BcflOqWhVNMQnAxbg5aXf8PLyTmgbVYdxh5GQJj8tNMhoiUVwtjLL+bNIJELv3r3RvXt37Ny5E5999plC30s2bW1tGBsbvxeUChMc/xL9N18rlXpyK9K6JCIiUlkMMipmuJMFPK8/KnCfip81QcUxv3zwunG74QUeJ5MLcGn54S36K1SogPHjxxerztJWlPVC2Upy+8DiXIeIiFQPP8VVTP1qldHOsqrC7+6rJRahnWVVtWk3zl4vVBQiHT0AyHMRdIHH/XMdIiJSXwwyKsijvx20FRxktMUiePS3U+g5S1P2eqGi0KluCQB4dWU33ty5hLRIX8gzC+66Av5dL0REROqLQUYFmZvoY4mC72+ytI8tzIsYDFSFs7VZkUamdGtYwaidCzKfP0TSqZ+QeOIHyNNTCjzmv+uFiIhIPfHXURU11NECiW8kCnnis1s3awxx/HBtjKorynqhbMZthsK4zdAinzu/9UJERKReOCKjwqY618eqAXbQ1RYXe82MllgEXW0xvh9ghynOlqVUYenieiEiIioMg4yKG+poAe8ZHdC6rikAFPqlnr29dV1TeM/ooJYjMblxvRARERWEU0tqwNxEH3vGOCH6WSr2BcbDJ+o54pPS37thnAjvFq86W5nBpaWFxow2ZK8XmndEcU+rVsf1QkRElDeRkPthO/l4/fo1jIyMkJKSAkNDw7KoiwqRJpHiUVIaMqVy6GiLUcfUQKM7cDb6RCtsvZC6TrUREZUnRc0emvvNp+EMdLXL1a31pzrXR9VKulh0IgJSuVDowyRz0xKLoC0WYWkfW7WfaiMiovdxjQypjfK+XoiIiD7EERlSK+V5vRAREX2Ia2RI7ZW39UJEROUB18hQuVHe1gsREdG/uEaGiIiI1BaDDBEREaktBhkiIiJSWwwyREREpLYYZIiIiEhtMcgQERGR2mKQISIiIrXFIENERERqi0GGiIiI1BaDDBEREaktBhkiIiJSWwwyREREpLYYZIiIiEhtMcgQERGR2tIuyk6CIAAAXr9+XarFEBEREQH/Zo7sDJKfIgWZ1NRUAIC5uXkJyyIiIiIqutTUVBgZGeW7XSQUFnUAyOVyPH36FJUrV4ZIJFJogURERET/JQgCUlNTUbNmTYjF+a+EKVKQISIiIlJFXOxLREREaotBhoiIiNQWgwwRERGpLQYZIiIiUlsMMkRERKS2GGSIiIhIbTHIEBERkdr6P78OHu014vZ7AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1 1 1 0 0 0]\n", + " [0 0 0 1 1 0 0]\n", + " [0 0 0 0 1 0 0]\n", + " [0 0 0 0 0 1 0]\n", + " [0 0 0 0 0 0 0]\n", + " [0 0 0 0 0 0 0]\n", + " [0 0 0 0 0 1 0]]\n" + ] + } + ], + "source": [ + "G2 = nx.DiGraph()\n", + "G2.add_edges_from([('q', 'w'), ('q', 'e'), ('q', 'r'), ('w', 'r'), ('w', 'y'), ('e', 'y'), ('r','u'), ('t', 'u')])\n", + "\n", + "plt.figure(figsize =(7, 10))\n", + "plt.subplot(212)\n", + "nx.draw_networkx(G2)\n", + "plt.show()\n", + "\n", + "a= nx.adjacency_matrix(G2) # список вершин, которые соединены попарно.\n", + "A=a.todense() # Формируем матрицу смежности\n", + "print(A)" + ] + }, + { + "cell_type": "markdown", + "id": "94a7923d", + "metadata": {}, + "source": [ + "
Теорема
\tГрафы изоморфны тогда и только тогда, когда их матрицы смежности получаются друг из друга одновременными перестановками строк и столбцов (т.е. одновременно с перестановкой $i$-й и $j$-й строк переставляются $i$-й и $j$-й столбцы)." + ] + }, + { + "cell_type": "markdown", + "id": "904e294c", + "metadata": {}, + "source": [ + "#### Матрица инцидености" + ] + }, + { + "cell_type": "markdown", + "id": "685333ab", + "metadata": {}, + "source": [ + "Матрицей инцидентности $B=(b_{ij})$ неориентированного графа G называется матрица размера $ |V|\\times|E|$ , в которой столбцы матрицы соответствуют ребрам, строки — вершинам. Ненулевое значение в ячейке матрицы указывает связь между вершиной и ребром определяемую следующим образом: \n", + "$$b_{ij}=\\begin{cases} 1, &если& e_{j} &инцидентна\\space вершине& a_i \\\\ 0, &иначе& \\end{cases} $$ \n", + "
\n", + "В случае наличия ориентированных дуг, начало и конец обозначаются противоположныти знаками\n", + "$$b_{ij}=\\begin{cases} 1, &если& e_{j} &исходит\\space из\\space вершины& a_i \\\\ -1, &если& e_{j} &заходит\\space в\\space вершину& a_i &и\\space не\\space является\\space петлей& \\\\0, &иначе& \\end{cases} $$\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "5d0d0824", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 1. 1. 0. 0. 0. 0. 0. 0.]\n", + " [0. 1. 0. 1. 0. 0. 0. 0. 0.]\n", + " [0. 0. 1. 0. 1. 1. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + " [0. 0. 0. 1. 0. 0. 0. 1. 0.]\n", + " [0. 0. 0. 0. 0. 1. 1. 0. 0.]\n", + " [1. 0. 0. 0. 1. 0. 0. 1. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1.]]\n" + ] + } + ], + "source": [ + "a= nx.incidence_matrix(G) # список вершин, которые соединены попарно.\n", + "A=a.todense() # Формируем матрицу инцидентности\n", + "print(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "afa251b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 1. 1. 0. 0. 0. 0. 0.]\n", + " [-1. 0. 0. 1. 1. 0. 0. 0.]\n", + " [ 0. -1. 0. 0. 0. 1. 0. 0.]\n", + " [ 0. 0. -1. -1. 0. 0. 1. 0.]\n", + " [ 0. 0. 0. 0. -1. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. -1. -1.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 1.]]\n" + ] + } + ], + "source": [ + "b= -nx.incidence_matrix(G2, oriented=True) # список вершин, которые соединены попарно.\n", + "B=b.todense() # Формируем матрицу инцидентности\n", + "print(B)" + ] + }, + { + "cell_type": "markdown", + "id": "d7a85452", + "metadata": {}, + "source": [ + "
Теорема
\tГрафы и изоморфны тогда и только тогда, когда их матрицы инцидентности получаются друг из друга некоторыми перестановками строк и столбцов." + ] + }, + { + "cell_type": "markdown", + "id": "d838ad99", + "metadata": {}, + "source": [ + "## Операции над графами" + ] + }, + { + "cell_type": "markdown", + "id": "dc315442", + "metadata": {}, + "source": [ + "В результате операции добавления к графу $G=\\langle V,E \\rangle$ вершины $a$ a образуется граф $G1=\\langle V\\cup \\{a\\},E \\rangle$ .
В результате операции добавления дуги $e$ к графу G образуется графа $G2=\\langle V,E\\cup \\{e\\} \\rangle$.
\n", + "Под операцией удаления дуги $e$ из графа $G$ понимается операция, заключающаяся в удалении пары $(a_i, a_j)$ из множества дуг $E$.
Операция удаления вершины a из графа $G$ заключается в удалении вершины a вместе с инцидентными ей дугами.
При замыкании двух вершин, эти вершины удаляются из графа и заменяются одной новой, при этом ребра, инцидентные исходным вершинам, теперь будут инцидентны новой вершине. В случае, когда отождествляемые вершины соединены дугой, операцию отождествления называют стягиванием дуги.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "85892ea0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "A=np.array([[1, 0, 1, 0], \n", + " [1, 1, 0, 0], \n", + " [0, 1, 1, 0], \n", + " [0, 1, 1, 1]])\n", + "G = nx.DiGraph(A)\n", + "plt.subplot(212)\n", + "nx.draw_networkx(G)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "059ef702", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Удаление ребра\n", + "G.remove_edge(3,1) \n", + "plt.subplot(212)\n", + "nx.draw_networkx(G)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "c17ab9ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Удаление вершины\n", + "G.remove_node(2) \n", + "plt.subplot(212)\n", + "nx.draw_networkx(G)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "2d012b55", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Дополнение графа\n", + "H = nx.complement(G)\n", + "plt.subplot(212)\n", + "nx.draw_networkx(H)" + ] + }, + { + "cell_type": "markdown", + "id": "fe9a389c", + "metadata": {}, + "source": [ + "Очевидно, имеем следующие утверждения:
\n", + "У всякого графа имеется пустой подграф.
\n", + "Всякий граф является подграфом полного графа.
\n", + "Если граф G является подграфом графа G1, а граф G2 – подграфом графа G1, то G2 – подграф графа G, (то есть отношение «быть\n", + "подграфом» транзитивно).\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a893bea", + "metadata": {}, + "source": [ + "## Задание" + ] + }, + { + "cell_type": "markdown", + "id": "f177290d", + "metadata": {}, + "source": [ + "**Задание 1.** Сгенерировать несколько ориентированных и несколько неориентированных графов различными способами (включая считывание из файла). Выполнить с ними все известные операции. Получить для них матрицы смежности и инцидентности. Вывести степени вершин, списки ребер и вершин." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "424ba7bc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Генерируем ориентированные и неориентированные графы\n", + "G_directed = nx.DiGraph()\n", + "G_undirected = nx.Graph()\n", + "\n", + "# Добавляем ребра в ориентированный граф\n", + "G_directed.add_edges_from([(1, 2), (2, 3), (3, 2), (4, 2)])\n", + "\n", + "# Добавляем ребра в неориентированный граф\n", + "G_undirected.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1)])\n", + "\n", + "# Считываем граф из файла\n", + "G_from_file = nx.read_edgelist('Задание_9_graph.txt', nodetype=int)\n", + "\n", + "# Визуализируем графы\n", + "nx.draw(G_directed, with_labels=True, font_weight='bold')\n", + "plt.title('Ориентированный Граф')\n", + "plt.show()\n", + "\n", + "nx.draw(G_undirected, with_labels=True, font_weight='bold')\n", + "plt.title('Неориентированный Граф')\n", + "plt.show()\n", + "\n", + "nx.draw(G_from_file, with_labels=True, font_weight='bold')\n", + "plt.title('Граф из файла')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "8eea3b07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Матрица смежности ориентированного графа:\n", + "[[0 1 0 0]\n", + " [0 0 1 0]\n", + " [0 1 0 0]\n", + " [0 1 0 0]]\n", + "Матрица смежности неориентированного графа:\n", + "[[0 1 0 1]\n", + " [1 0 1 0]\n", + " [0 1 0 1]\n", + " [1 0 1 0]]\n", + "Матрица инцидентности ориентированного графа:\n", + "[[1. 0. 0. 0.]\n", + " [1. 1. 1. 1.]\n", + " [0. 1. 1. 0.]\n", + " [0. 0. 0. 1.]]\n", + "Матрица инцидентности неориентированного графа:\n", + "[[1. 1. 0. 0.]\n", + " [1. 0. 1. 0.]\n", + " [0. 0. 1. 1.]\n", + " [0. 1. 0. 1.]]\n", + "Степени вершин ориентированного графа:\n", + "[(1, 0), (2, 3), (3, 1), (4, 0)]\n", + "Степени вершин неориентированного графа:\n", + "[(1, 2), (2, 2), (3, 2), (4, 2)]\n", + "Список ребер ориентированного графа:\n", + "[(1, 2), (2, 3), (3, 2), (4, 2)]\n", + "Список ребер неориентированного графа:\n", + "[(1, 2), (1, 4), (2, 3), (3, 4)]\n", + "Список вершин ориентированного графа:\n", + "[1, 2, 3, 4]\n", + "Список вершин неориентированного графа:\n", + "[1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "# Получаем матрицы смежности и инцидентности\n", + "print(\"Матрица смежности ориентированного графа:\")\n", + "print(nx.adjacency_matrix(G_directed).todense())\n", + "\n", + "print(\"Матрица смежности неориентированного графа:\")\n", + "print(nx.adjacency_matrix(G_undirected).todense())\n", + "\n", + "print(\"Матрица инцидентности ориентированного графа:\")\n", + "print(nx.incidence_matrix(G_directed).todense())\n", + "\n", + "print(\"Матрица инцидентности неориентированного графа:\")\n", + "print(nx.incidence_matrix(G_undirected).todense())\n", + "\n", + "# Выводим степени вершин каждого графа\n", + "print(\"Степени вершин ориентированного графа:\")\n", + "print(G_directed.in_degree())\n", + "\n", + "print(\"Степени вершин неориентированного графа:\")\n", + "print(G_undirected.degree())\n", + "\n", + "# Выводим списки ребер\n", + "print(\"Список ребер ориентированного графа:\")\n", + "print(G_directed.edges())\n", + "\n", + "print(\"Список ребер неориентированного графа:\")\n", + "print(G_undirected.edges())\n", + "\n", + "# Выводим списки вершин\n", + "print(\"Список вершин ориентированного графа:\")\n", + "print(G_directed.nodes())\n", + "\n", + "print(\"Список вершин неориентированного графа:\")\n", + "print(G_undirected.nodes())" + ] + }, + { + "cell_type": "markdown", + "id": "2087767b", + "metadata": {}, + "source": [ + "**Задание 2.** Проверить любой из графов из задания 1 на наличие Эйлерова цикла, эйлерова пути, гамильтонова цикла." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "0e8216f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Граф содержит Эйлеров цикл.\n", + "Граф содержит Эйлеров путь.\n", + "Граф содержит Гамильтонов цикл, цикл: (1, 2, 3, 4)\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "\n", + "# Проверка на наличие Эйлерова цикла\n", + "if nx.is_eulerian(G_undirected):\n", + " print(\"Граф содержит Эйлеров цикл.\")\n", + "else:\n", + " print(\"Граф не содержит Эйлеров цикл.\")\n", + "\n", + "# Проверка на наличие Эйлерова пути\n", + "if nx.has_eulerian_path(G_undirected):\n", + " print(\"Граф содержит Эйлеров путь.\")\n", + "else:\n", + " print(\"Граф не содержит Эйлеров путь.\")\n", + "\n", + "# Проверка на наличие Гамильтонова цикла\n", + "def is_hamiltonian(graph: any) -> None:\n", + " for p in itertools.permutations(list(graph.nodes())):\n", + " if all(p[i] in graph[p[i - 1]] for i in range(len(p))) and p[0] in graph[p[-1]]:\n", + " print(f\"Граф содержит Гамильтонов цикл, цикл: {p}\")\n", + " return\n", + "\n", + "is_hamiltonian(G_undirected)" + ] + }, + { + "cell_type": "markdown", + "id": "2e168a74", + "metadata": {}, + "source": [ + "**Задание 3.** Подсчитать количество циклов в любом из графов из задания 1." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "2ffaa940", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Количество циклов: 1\n" + ] + } + ], + "source": [ + "from networkx.algorithms import cycle_basis\n", + "\n", + "# Находим все циклы в графе\n", + "cycles = cycle_basis(G_undirected)\n", + "\n", + "# Подсчет количества циклов\n", + "number_of_cycles = len(cycles)\n", + "\n", + "# Выводим количество циклов\n", + "print(f'Количество циклов: {number_of_cycles}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Second term/Discrete math/Задание_9_graph.txt b/Second term/Discrete math/Задание_9_graph.txt new file mode 100755 index 0000000..28f0b1f --- /dev/null +++ b/Second term/Discrete math/Задание_9_graph.txt @@ -0,0 +1,4 @@ +1 2 {} +2 3 {} +3 4 {} +4 1 {} diff --git a/Second term/Familiarization practice/README.md b/Second term/Familiarization practice/README.md new file mode 100755 index 0000000..d73cf6b --- /dev/null +++ b/Second term/Familiarization practice/README.md @@ -0,0 +1,16 @@ +# Familiarization practice + +[Таблица с баллами](https://docs.google.com/spreadsheets/d/1qiqiL-id7CyFGKLNmv8CRBeGVKn7fBsgO3uZ6K-NkxU/edit#gid=1150347629) + +number | name | grade +:----: | ------------------------------------------------------------------------------------------------------ | :---: +1 | Настройка виртуальной машины для будущей операционной системы | 10/10 +2 | Работа в командной строке Astra Linux / Использование справочных ресурсов и библиотек | 10/10 +3 | Работа со справочными системами man и info / Работа с файлами и каталогами | 10/10 +4 | Операции с файлами / Изменение атрибутов файлов / Дополнительно | 10/10 +5 | Работа с потоками и перенаправление потоков / Работа с текстом в редакторе vim | 10/10 +6 | Изучение базы данных локальных учетных записей / Создание и управление учетными записями пользователей | 10/10 +7 | Изучение понятия процесса / Управление процессами | 10/10 +8 | Отчет | 10/10 + +[Back](/NKTKLN/mirea-projects) diff --git a/Second term/Familiarization practice/Задание №1.docx b/Second term/Familiarization practice/Задание №1.docx new file mode 100755 index 0000000..7b0a90f Binary files /dev/null and b/Second term/Familiarization practice/Задание №1.docx differ diff --git a/Second term/Familiarization practice/Задание №1.pdf b/Second term/Familiarization practice/Задание №1.pdf new file mode 100755 index 0000000..96c3695 Binary files /dev/null and b/Second term/Familiarization practice/Задание №1.pdf differ diff --git a/Second term/Familiarization practice/Задание №2.docx b/Second term/Familiarization practice/Задание №2.docx new file mode 100755 index 0000000..91ebe61 Binary files /dev/null and b/Second term/Familiarization practice/Задание №2.docx differ diff --git a/Second term/Familiarization practice/Задание №2.pdf b/Second term/Familiarization practice/Задание №2.pdf new file mode 100755 index 0000000..f930233 Binary files /dev/null and b/Second term/Familiarization practice/Задание №2.pdf differ diff --git a/Second term/Familiarization practice/Задание №3.docx b/Second term/Familiarization practice/Задание №3.docx new file mode 100755 index 0000000..2f7068a Binary files /dev/null and b/Second term/Familiarization practice/Задание №3.docx differ diff --git a/Second term/Familiarization practice/Задание №3.pdf b/Second term/Familiarization practice/Задание №3.pdf new file mode 100755 index 0000000..e5912ad Binary files /dev/null and b/Second term/Familiarization practice/Задание №3.pdf differ diff --git a/Second term/Familiarization practice/Задание №4.docx b/Second term/Familiarization practice/Задание №4.docx new file mode 100755 index 0000000..efd26fa Binary files /dev/null and b/Second term/Familiarization practice/Задание №4.docx differ diff --git a/Second term/Familiarization practice/Задание №4.pdf b/Second term/Familiarization practice/Задание №4.pdf new file mode 100755 index 0000000..151c5c9 Binary files /dev/null and b/Second term/Familiarization practice/Задание №4.pdf differ diff --git a/Second term/Familiarization practice/Задание №5.docx b/Second term/Familiarization practice/Задание №5.docx new file mode 100755 index 0000000..e3a6d01 Binary files /dev/null and b/Second term/Familiarization practice/Задание №5.docx differ diff --git a/Second term/Familiarization practice/Задание №5.pdf b/Second term/Familiarization practice/Задание №5.pdf new file mode 100755 index 0000000..f96943a Binary files /dev/null and b/Second term/Familiarization practice/Задание №5.pdf differ diff --git a/Second term/Familiarization practice/Задание №6.docx b/Second term/Familiarization practice/Задание №6.docx new file mode 100755 index 0000000..ab5121b Binary files /dev/null and b/Second term/Familiarization practice/Задание №6.docx differ diff --git a/Second term/Familiarization practice/Задание №6.pdf b/Second term/Familiarization practice/Задание №6.pdf new file mode 100755 index 0000000..93c148c Binary files /dev/null and b/Second term/Familiarization practice/Задание №6.pdf differ diff --git a/Second term/Familiarization practice/Задание №7.docx b/Second term/Familiarization practice/Задание №7.docx new file mode 100755 index 0000000..85250d5 Binary files /dev/null and b/Second term/Familiarization practice/Задание №7.docx differ diff --git a/Second term/Familiarization practice/Задание №7.pdf b/Second term/Familiarization practice/Задание №7.pdf new file mode 100755 index 0000000..75f4b68 Binary files /dev/null and b/Second term/Familiarization practice/Задание №7.pdf differ diff --git a/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf b/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf new file mode 100755 index 0000000..47f54c0 Binary files /dev/null and b/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf differ diff --git a/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Отчет.pdf b/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Отчет.pdf new file mode 100755 index 0000000..7011baf Binary files /dev/null and b/Second term/Familiarization practice/ОП_ЭФБО-09-23_Калинин Н.В._Отчет.pdf differ diff --git a/Second term/Familiarization practice/Отчет.docx b/Second term/Familiarization practice/Отчет.docx new file mode 100755 index 0000000..45fe271 Binary files /dev/null and b/Second term/Familiarization practice/Отчет.docx differ diff --git a/Second term/Industrial programming technologies/1/1.cpp b/Second term/Industrial programming technologies/1/1.cpp new file mode 100755 index 0000000..c044870 --- /dev/null +++ b/Second term/Industrial programming technologies/1/1.cpp @@ -0,0 +1,38 @@ +#include +#include + +using namespace std; + +class Triangle { +public: + double a, b, c; + + bool exst_tr(); + void set(double a1, double b1, double c1); + void show(); + double perimetr(); + double square(); +}; + +bool Triangle::exst_tr() { + return Triangle::perimetr() - max(max(this->a, this->b), this->c) * 2 > 0; +} + +void Triangle::set(double a1, double b1, double c1) { + this->a = a1; + this->b = b1; + this->c = c1; +} + +void Triangle::show() { + cout << "A = " << this->a << ", B = " << this->b << ", C = " << this->c << endl; +} + +double Triangle::perimetr() { + return this->a + this->b + this->c; +} + +double Triangle::square() { + double p = Triangle::perimetr() / 2; + return sqrt(p * (p - this->a) * (p - this->b) * (p - this->c)); +} diff --git a/Second term/Industrial programming technologies/1/2.cpp b/Second term/Industrial programming technologies/1/2.cpp new file mode 100755 index 0000000..0a0b242 --- /dev/null +++ b/Second term/Industrial programming technologies/1/2.cpp @@ -0,0 +1,38 @@ +#include +#include + +using namespace std; + +class Triangle { +public: + double a, b, c; + Triangle(double an, double bn, double cn) : a(an), b(bn), c(cn) { + if (!Triangle::exst_tr()) { + this->a = 3; + this->b = 4; + this->c = 5; + } + } + + bool exst_tr(); + void show(); + double perimetr(); + double square(); +}; + +bool Triangle::exst_tr() { + return Triangle::perimetr() - max(max(this->a, this->b), this->c) * 2 > 0; +} + +void Triangle::show() { + cout << "A = " << this->a << ", B = " << this->b << ", C = " << this->c << endl; +} + +double Triangle::perimetr() { + return this->a + this->b + this->c; +} + +double Triangle::square() { + double p = Triangle::perimetr() / 2; + return sqrt(p * (p - this->a) * (p - this->b) * (p - this->c)); +} diff --git a/Second term/Industrial programming technologies/1/3.cpp b/Second term/Industrial programming technologies/1/3.cpp new file mode 100755 index 0000000..8658d8b --- /dev/null +++ b/Second term/Industrial programming technologies/1/3.cpp @@ -0,0 +1,49 @@ +#include +#include + +using namespace std; + +class Triangle { +public: + double a, b, c; + Triangle(double an, double bn, double cn) : a(an), b(bn), c(cn) { + if (!Triangle::exst_tr()) { + this->a = 3; + this->b = 4; + this->c = 5; + } + } + + bool exst_tr(); + void show(); + double perimetr(); + double square(); + bool is_similar(Triangle & t2); +}; + +bool Triangle::exst_tr() { + return Triangle::perimetr() - max(max(this->a, this->b), this->c) * 2 > 0; +} + +void Triangle::show() { + cout << "A = " << this->a << ", B = " << this->b << ", C = " << this->c << endl; +} + +double Triangle::perimetr() { + return this->a + this->b + this->c; +} + +double Triangle::square() { + double p = Triangle::perimetr() / 2; + return sqrt(p * (p - this->a) * (p - this->b) * (p - this->c)); +} + +bool Triangle::is_similar(Triangle & t2) { + double max_t1 = max(max(this->a, this->b), this->c); + double max_t2 = max(max(t2.a, t2.b), t2.c); + double min_t1 = min(min(this->a, this->b), this->c); + double min_t2 = min(min(t2.a, t2.b), t2.c); + double mid_t1 = Triangle::perimetr() - max_t1 - min_t1; + double mid_t2 = t2.perimetr() - max_t2 - min_t2; + return max_t1 / max_t2 == min_t1 / min_t2 && max_t1 / max_t2 == mid_t1 / mid_t2; +} diff --git a/Second term/Industrial programming technologies/1/4.cpp b/Second term/Industrial programming technologies/1/4.cpp new file mode 100755 index 0000000..99f5b5a --- /dev/null +++ b/Second term/Industrial programming technologies/1/4.cpp @@ -0,0 +1,100 @@ +#include +#include + +using namespace std; + +class Triangle { +public: + double a, b, c; + Triangle(double an, double bn, double cn) : a(an), b(bn), c(cn) { + if (!Triangle::exst_tr()) { + this->a = 3; + this->b = 4; + this->c = 5; + } + } + + bool exst_tr(); + void show(); + double perimetr(); + double square(); + bool is_similar(Triangle & t2); + double get_a(); + double get_b(); + double get_c(); +}; + +bool Triangle::exst_tr() { + return Triangle::perimetr() - max(max(this->a, this->b), this->c) * 2 > 0; +} + +void Triangle::show() { + cout << "A = " << this->a << ", B = " << this->b << ", C = " << this->c << endl; +} + +double Triangle::perimetr() { + return this->a + this->b + this->c; +} + +double Triangle::square() { + double p = Triangle::perimetr() / 2; + return sqrt(p * (p - this->a) * (p - this->b) * (p - this->c)); +} + +bool Triangle::is_similar(Triangle & t2) { + double max_t1 = max(max(this->a, this->b), this->c); + double max_t2 = max(max(t2.a, t2.b), t2.c); + double min_t1 = min(min(this->a, this->b), this->c); + double min_t2 = min(min(t2.a, t2.b), t2.c); + double mid_t1 = Triangle::perimetr() - max_t1 - min_t1; + double mid_t2 = t2.perimetr() - max_t2 - min_t2; + return max_t1 / max_t2 == min_t1 / min_t2 && max_t1 / max_t2 == mid_t1 / mid_t2; +} + +double Triangle::get_a() { + return this->a; +} + +double Triangle::get_b() { + return this->b; +} + +double Triangle::get_c() { + return this->c; +} + +class Circle { +public: + float r; + float x, y; + Circle(float rn, float xn, float yn) : r(rn), x(xn), y(yn) {}; + + void set_circle(float r, float x, float y); + float square(); + bool triangle_around(Triangle & t); + bool triangle_in(Triangle & t); + bool check_circle(Circle & c); +}; + +void Circle::set_circle(float r, float x, float y) { + this->r = r; + this->x = x; + this->y = y; +} + +float Circle::square() { + return 3.14 * pow(r, 2); +} + +bool Circle::triangle_around(Triangle & t) { + return t.square() == (t.a * t.b * t.c) / (4 * this->r); +} + +bool Circle::triangle_in(Triangle & t) { + return t.square() == t.perimetr() / (2 * this->r); +} + +bool Circle::check_circle(Circle & c) { + float center_distance = sqrt(pow(abs(this->x - c.x), 2) + pow(abs(this->y - c.y), 2)); + return center_distance < (c.r + this->r) && center_distance > abs(c.r - this->r); +} diff --git a/Second term/Industrial programming technologies/1/5.cpp b/Second term/Industrial programming technologies/1/5.cpp new file mode 100755 index 0000000..bba3022 --- /dev/null +++ b/Second term/Industrial programming technologies/1/5.cpp @@ -0,0 +1,37 @@ +#include + +using namespace std; + +class MyStack { +private: + int lastIndex = -1; + int numbers[100] = {}; +public: + void push(int n); + void pop(); + void back(); + void size(); + void clear(); +}; + +void MyStack::push(int n) { + this->numbers[++this->lastIndex] = n; +} + +void MyStack::pop() { + if (lastIndex < 0) return; + MyStack::back(); + this->lastIndex--; +} + +void MyStack::back() { + cout << this->numbers[this->lastIndex] << endl; +} + +void MyStack::size() { + cout << this->lastIndex+1 << endl; +} + +void MyStack::clear() { + this->lastIndex = -1; +} diff --git a/Second term/Industrial programming technologies/2/1.cpp b/Second term/Industrial programming technologies/2/1.cpp new file mode 100755 index 0000000..3e0ce40 --- /dev/null +++ b/Second term/Industrial programming technologies/2/1.cpp @@ -0,0 +1,59 @@ +#include +#include + +using namespace std; + +class Figure { +public: + virtual double square() = 0; +}; + +class Triangle: public Figure { +private: + double a, b, c; +public: + Triangle(double a, double b, double c); + double square(); +}; + +class Rectangle: public Figure { +private: + double a, b; +public: + Rectangle(double a, double b); + double square(); +}; + +class Trapezoid: public Figure { +private: + double a, b, h; +public: + Trapezoid(double a, double b, double h); + double square(); +}; + +Triangle::Triangle(double a, double b, double c) { + this->a = a; + this->b = b; + this->c = c; +} + +double Triangle::square() { + double p = (this->a + this->b + this->c)/ 2; + return sqrt(p * (p - this->a) * (p - this->b) * (p - this->c)); +} + +Rectangle::Rectangle(double a, double b) { + this->a = a; + this->b = b; +} + +double Rectangle::square() { return this->a * this->b; } + +Trapezoid::Trapezoid(double a, double b, double h) { + this->a = a; + this->b = b; + this->h = h; +} + +double Trapezoid::square() { return (this->a + this->b) / 2 * this->h; } diff --git a/Second term/Industrial programming technologies/2/2.cpp b/Second term/Industrial programming technologies/2/2.cpp new file mode 100755 index 0000000..3ee94e8 --- /dev/null +++ b/Second term/Industrial programming technologies/2/2.cpp @@ -0,0 +1,41 @@ +#include +#include + +using namespace std; + +class NotifierBase { +public: + virtual void notify(const string& message) = 0; +}; + +class BKNotifier : public NotifierBase { +private: + string id; +public: + BKNotifier(string id); + void notify(const string& message); +}; + +class TelegraphNotifier: public NotifierBase { +private: + string login; +public: + TelegraphNotifier(string id); + void notify(const string& message); +}; + +void SendBK(const string& id, const string& message) { + cout << "Send '" << message << "' to BK user " << id << endl; +} + +void SendTelegraph(const string& login, const string& message) { + cout << "Send '" << message << "' to Telegraph user " << login << endl; +} + +void BKNotifier::notify(const string& message) { SendBK(this->id, message); } + +void TelegraphNotifier::notify(const string& message) { SendTelegraph(this->login, message); } + +BKNotifier::BKNotifier(string id) { this->id = id; } + +TelegraphNotifier::TelegraphNotifier(string login) { this->login = login; } diff --git a/Second term/Industrial programming technologies/3/1.cpp b/Second term/Industrial programming technologies/3/1.cpp new file mode 100755 index 0000000..1d5e6d7 --- /dev/null +++ b/Second term/Industrial programming technologies/3/1.cpp @@ -0,0 +1,75 @@ +#include +#include +#include + +using namespace std; + +class Fraction { +public: + int a, b; + + Fraction(); + Fraction(int a, int b); + void print(); +}; + +Fraction::Fraction() { + this->a = 0; + this->b = 1; +} + +Fraction::Fraction(int a, int b) { + this->a = a; + this->b = b; + + if (this->a == 0 && this->b == 0) return; + if (this->a >= this->b) this->a %= this->b; + if (this->a == 0) this->b = 1; + + int divisor = gcd(this->a, this->b); + this->a /= divisor; + this->b /= divisor; +} + +void Fraction::print() { cout << this->a << "/" << this->b << endl; } + +class SetOfFractions { +private: + vector data; +public: + bool isEmpty(); + void append(Fraction fraction); + void exclude(Fraction fraction); + Fraction sum(); +}; + +bool SetOfFractions::isEmpty() { return this->data.size() == 0; } + +void SetOfFractions::append(Fraction fraction) { + for (int index = 0; index < this->data.size(); index++) + if (this->data[index].a == fraction.a && this->data[index].b == fraction.b) return; + + this->data.push_back(fraction); +} + +void SetOfFractions::exclude(Fraction fraction) { + for (int index = 0; index < this->data.size(); index++) { + if (this->data[index].a == fraction.a && this->data[index].b == fraction.b) { + this->data.erase(this->data.begin() + index); + break; + } + } +} + +Fraction SetOfFractions::sum() { + if (isEmpty()) return Fraction(0, 0); + + int numerator = 0; + int denominator = 1; + for (int index = 0; index < this->data.size(); index++) { + numerator = numerator * this->data[index].b + this->data[index].a * denominator; + denominator *= this->data[index].b; + } + + return Fraction(numerator, denominator); +} diff --git a/Second term/Industrial programming technologies/3/2.cpp b/Second term/Industrial programming technologies/3/2.cpp new file mode 100755 index 0000000..b58c0c6 --- /dev/null +++ b/Second term/Industrial programming technologies/3/2.cpp @@ -0,0 +1,45 @@ +#include +#include +#include + +using namespace std; + +class Fraction { +public: + int a, b; + + Fraction(); + Fraction(int a, int b); + void print(); + + Fraction operator+(const Fraction &fraction) { + return Fraction(this->a * fraction.b + this->b * fraction.a, this->b * fraction.b); + } + + Fraction operator*(const Fraction &fraction) { + return Fraction(this->a * fraction.a, this->b * fraction.b); + } + Fraction operator/(const Fraction &fraction) { + return Fraction(this->a * fraction.b, this->b * fraction.a); + } +}; + +Fraction::Fraction() { + this->a = 0; + this->b = 1; +} + +Fraction::Fraction(int a, int b) { + this->a = a; + this->b = b; + + if (this->a == 0 && this->b == 0) return; + if (this->a >= this->b) this->a %= this->b; + if (this->a == 0) this->b = 1; + + int divisor = gcd(this->a, this->b); + this->a /= divisor; + this->b /= divisor; +} + +void Fraction::print() { cout << this->a << "/" << this->b << endl; } diff --git a/Second term/Industrial programming technologies/3/3.cpp b/Second term/Industrial programming technologies/3/3.cpp new file mode 100755 index 0000000..e0f7a26 --- /dev/null +++ b/Second term/Industrial programming technologies/3/3.cpp @@ -0,0 +1,52 @@ +#include +#include +#include + +using namespace std; + +class Fraction { +public: + int a, b; + + Fraction(); + Fraction(int a, int b); + void print(); + + Fraction operator+(const Fraction &fraction) { + return Fraction(this->a * fraction.b + this->b * fraction.a, this->b * fraction.b); + } +}; + +Fraction::Fraction() { + this->a = 0; + this->b = 1; +} + +Fraction::Fraction(int a, int b) { + this->a = a; + this->b = b; + + if (this->a == 0 && this->b == 0) return; + if (this->a >= this->b) this->a %= this->b; + if (this->a == 0) this->b = 1; + + int divisor = gcd(this->a, this->b); + this->a /= divisor; + this->b /= divisor; +} + +void Fraction::print() { cout << this->a << "/" << this->b << endl; } + +template +T superSum(T a, T b) { return a + b; } + +template +T superSum(T (&a)[N]) { + T sum = 0; + int count = sizeof(a) / sizeof(a[0]); + + for (int index = 0; index < count; index++) + sum = superSum(sum, a[index]); + + return sum; +} diff --git a/Second term/Industrial programming technologies/3/4.cpp b/Second term/Industrial programming technologies/3/4.cpp new file mode 100755 index 0000000..c30b65d --- /dev/null +++ b/Second term/Industrial programming technologies/3/4.cpp @@ -0,0 +1,84 @@ +#include +#include +#include + +using namespace std; + +template +class SuperFraction { +public: + int a, b; + + SuperFraction(); + SuperFraction(T a, T b); + void print(); +}; + +template +SuperFraction::SuperFraction() { + this->a = 0; + this->b = 1; +} + +template +SuperFraction::SuperFraction(T a, T b) { + this->a = a; + this->b = b; + + if (this->a == 0 && this->b == 0) return; + if (this->a >= this->b) this->a %= this->b; + if (this->a == 0) this->b = 1; + + int divisor = gcd(this->a, this->b); + this->a /= divisor; + this->b /= divisor; +} + +template +void SuperFraction::print() { cout << this->a << "/" << this->b << endl; } + +template +class SuperExtraMegaWowOfFractions { +private: + vector> data; +public: + bool isEmpty(); + void append(SuperFraction fraction); + void exclude(SuperFraction fraction); + SuperFraction sum(); +}; + +template +bool SuperExtraMegaWowOfFractions::isEmpty() { return this->data.size() == 0; } + +template +void SuperExtraMegaWowOfFractions::append(SuperFraction fraction) { + for (int index = 0; index < this->data.size(); index++) + if (this->data[index].a == fraction.a && this->data[index].b == fraction.b) return; + + this->data.push_back(fraction); +} + +template +void SuperExtraMegaWowOfFractions::exclude(SuperFraction fraction) { + for (int index = 0; index < this->data.size(); index++) { + if (this->data[index].a == fraction.a && this->data[index].b == fraction.b) { + this->data.erase(this->data.begin() + index); + break; + } + } +} + +template +SuperFraction SuperExtraMegaWowOfFractions::sum() { + if (isEmpty()) return SuperFraction(0, 0); + + int numerator = 0; + int denominator = 1; + for (int index = 0; index < this->data.size(); index++) { + numerator = numerator * this->data[index].b + this->data[index].a * denominator; + denominator *= this->data[index].b; + } + + return SuperFraction(numerator, denominator); +} diff --git a/Second term/Industrial programming technologies/3/5.cpp b/Second term/Industrial programming technologies/3/5.cpp new file mode 100755 index 0000000..d6ab083 --- /dev/null +++ b/Second term/Industrial programming technologies/3/5.cpp @@ -0,0 +1,183 @@ +#include + +using namespace std; + +class Person { +public: + string sex; + string name; + string date; + int signIndex; + string surname; + + Person(string sex, string date, string name, string surname); + virtual void find() = 0; + void goAway(); +protected: + int getSign(); +}; + +Person *peoples[10]; + +class MilkHunter : public Person { +public: + MilkHunter(string sex, string date, string name, string surname) : Person(sex, date, name, surname) {}; + void find(); +}; + +class Skuf : public Person { +public: + Skuf(string sex, string date, string name, string surname) : Person(sex, date, name, surname) {}; + void find(); +}; + +class Altushka : public Person { +public: + Altushka(string sex, string date, string name, string surname) : Person(sex, date, name, surname) {}; + void find(); +}; + +class Extended : public Person { +public: + Extended(string sex, string date, string name, string surname) : Person(sex, date, name, surname) {}; + void find(); +}; + +Person::Person(string _sex, string _date, string _name, string _surname) : + sex(_sex), date(_date), name(_name), surname(_surname) { + this->signIndex = getSign(); +} + +void Person::goAway() { + int personIndex = 0; + while (personIndex < 10 && peoples[personIndex] != this) + personIndex++; + + for (int index = personIndex; index < 9; index++) + peoples[index] = peoples[index + 1]; + + peoples[9] = nullptr; +} + +int Person::getSign() { + int day, month, year; + sscanf(this->date.c_str(), "%d.%d.%d", &day, &month, &year); + + if ((day >= 21 && month == 1) || (day <= 19 && month == 2)) return 1; + if ((day >= 20 && month == 2) || (day <= 20 && month == 3)) return 2; + if ((day >= 21 && month == 3) || (day <= 20 && month == 4)) return 3; + if ((day >= 21 && month == 4) || (day <= 21 && month == 5)) return 4; + if ((day >= 22 && month == 5) || (day <= 21 && month == 6)) return 5; + if ((day >= 22 && month == 6) || (day <= 22 && month == 7)) return 6; + if ((day >= 23 && month == 7) || (day <= 22 && month == 8)) return 7; + if ((day >= 22 && month == 8) || (day <= 23 && month == 9)) return 8; + if ((day >= 24 && month == 9) || (day <= 23 && month == 10)) return 9; + if ((day >= 24 && month == 10) || (day <= 22 && month == 11)) return 10; + if ((day >= 23 && month == 11) || (day <= 21 && month == 12)) return 11; + if ((day >= 23 && month == 12) || (day <= 20 && month == 1)) return 12; + return 0; +} + +void MilkHunter::find() { + Person* person = nullptr; + + for (int index = 0; index < 10; index++) { + Extended *personPtr = dynamic_cast(peoples[index]); + if (personPtr == nullptr) continue; + if (person == nullptr || person->date < personPtr->date) + person = personPtr; + } + + if (person == nullptr) { + cout << "oops" << endl; + return; + } + + cout << person->name << endl + << person->surname << endl + << person->date << endl; +} + +void Skuf::find() { + Person* person = nullptr; + + for (int index = 0; index < 10; index++) { + Altushka *personPtr = dynamic_cast(peoples[index]); + if (personPtr == nullptr) continue; + if (person == nullptr || person->date > personPtr->date) + person = personPtr; + } + + if (person == nullptr) { + cout << "oops" << endl; + return; + } + + cout << person->name << endl + << person->surname << endl + << person->date << endl; +} + +void Altushka::find() { + Person* person = nullptr; + + for (int index = 0; index < 10; index++) { + Skuf *personPtr = dynamic_cast(peoples[index]); + if (personPtr == nullptr) continue; + if (person == nullptr || (personPtr->signIndex == this->signIndex && person->date < personPtr->date)) + person = personPtr; + } + + if (person == nullptr) { + cout << "oops" << endl; + return; + } + + cout << person->name << endl + << person->surname << endl + << person->date << endl; +} + +void Extended::find() { + Person* person = nullptr; + + for (int index = 0; index < 10; index++) { + MilkHunter *personPtr = dynamic_cast(peoples[index]); + if (personPtr == nullptr) continue; + if (person == nullptr || (personPtr->signIndex == (this->signIndex + 6) % 12 && person->date > personPtr->date)) + person = personPtr; + } + + if (person == nullptr) { + cout << "oops" << endl; + return; + } + + cout << person->name << endl + << person->surname << endl + << person->date << endl; +} + +Person *goIn() { + string sex; + string name; + string surname; + string date; + int day, month, year; + + cin >> surname >> name >> sex >> date; + sscanf(date.c_str(), "%d.%d.%d", &day, &month, &year); + + int age = 2024 - year; + if ((month > 1) || (month == 1 && day > 1)) age--; + + if (sex == "m" && age >= 25) + return new Skuf(sex, date, name, surname); + else if (sex == "m" && age < 25) + return new MilkHunter(sex, date, name, surname); + else if (sex == "f" && age >= 25) + return new Extended(sex, date, name, surname); + else if (sex == "f" && age < 25) + return new Altushka(sex, date, name, surname); + return nullptr; +} diff --git a/Second term/Industrial programming technologies/4/1.cpp b/Second term/Industrial programming technologies/4/1.cpp new file mode 100755 index 0000000..56cec07 --- /dev/null +++ b/Second term/Industrial programming technologies/4/1.cpp @@ -0,0 +1,29 @@ +#include +#include + +using namespace std; + +class Triangle { + public: + class WrongTriangleSideException {}; + double a, b, c; + Triangle(double an, double bn, double cn) : a(an), b(bn), c(cn) { + if (!exst_tr()) throw WrongTriangleSideException(); + } + + bool exst_tr(); + void show(); + double perimetr(); + double square(); +}; + +bool Triangle::exst_tr() { return perimetr() - max(max(a, b), c) * 2 > 0; } + +void Triangle::show() { cout << "A = " << a << ", B = " << b << ", C = " << c << endl; } + +double Triangle::perimetr() { return a + b + c; } + +double Triangle::square() { + double p = perimetr() / 2; + return sqrt(p * (p - a) * (p - b) * (p - c)); +} diff --git a/Second term/Industrial programming technologies/5/1.cpp b/Second term/Industrial programming technologies/5/1.cpp new file mode 100755 index 0000000..74cf20a --- /dev/null +++ b/Second term/Industrial programming technologies/5/1.cpp @@ -0,0 +1,14 @@ +#include +#include + +using namespace std; + +int main() { + double num; + cin >> num; + + unique_ptr ptr = make_unique(num); + cout << *ptr << endl; + + return 0; +} diff --git a/Second term/Industrial programming technologies/5/2.cpp b/Second term/Industrial programming technologies/5/2.cpp new file mode 100755 index 0000000..374b27b --- /dev/null +++ b/Second term/Industrial programming technologies/5/2.cpp @@ -0,0 +1,19 @@ +#include +#include +#include + +using namespace std; + +int main() { + int size; + cin >> size; + + unique_ptr arr(new double[size]); + for(int index = 0; index < size; index++) + arr[index] = index + 1; + + double sum = accumulate(arr.get(), arr.get()+size, 0.0); + cout << sum << endl; + + return 0; +} diff --git a/Second term/Industrial programming technologies/5/3.cpp b/Second term/Industrial programming technologies/5/3.cpp new file mode 100755 index 0000000..ecf3763 --- /dev/null +++ b/Second term/Industrial programming technologies/5/3.cpp @@ -0,0 +1,19 @@ +#include +#include + +using namespace std; + +int main() { + int A, B, C; + cin >> A >> B >> C; + + vector bibo(C); + bibo[0] = A; + bibo[1] = B; + for(int index = 2; index < C; index++) + bibo[index] = bibo[index-1] * bibo[index-2]; + + cout << bibo[C-1] << endl; + + return 0; +} diff --git a/Second term/Industrial programming technologies/5/4.cpp b/Second term/Industrial programming technologies/5/4.cpp new file mode 100755 index 0000000..6eeccde --- /dev/null +++ b/Second term/Industrial programming technologies/5/4.cpp @@ -0,0 +1,94 @@ +#include +#include +#include + +using namespace std; + +class MyExpression { +public: + virtual int Calculate() const = 0; + virtual string InLine() const = 0; + virtual ~MyExpression() {} +}; + +using MyExpressionPtr = shared_ptr; + +class MyConstClass : public MyExpression { +public: + int value; + + MyConstClass(int value); + int Calculate() const override; + string InLine() const override; +}; + +class MySumClass : public MyExpression { +public: + MyExpressionPtr leftValue; + MyExpressionPtr rightValue; + + MySumClass(MyExpressionPtr _leftValue, MyExpressionPtr _rightValue); + int Calculate() const override; + string InLine() const override; +}; + +class MyProductClass : public MyExpression { +public: + MyExpressionPtr leftValue; + MyExpressionPtr rightValue; + + MyProductClass(MyExpressionPtr _leftValue, MyExpressionPtr _rightValue); + int Calculate() const override; + string InLine() const override; +}; + + + +MyConstClass::MyConstClass(int _value) : value(_value) {} + +int MyConstClass::Calculate() const { return value; } + +string MyConstClass::InLine() const { return to_string(value); } + +MySumClass::MySumClass(MyExpressionPtr _leftValue, MyExpressionPtr _rightValue) : + leftValue(move(_leftValue)), rightValue(move(_rightValue)) {} + +int MySumClass::Calculate() const { return leftValue->Calculate() + rightValue->Calculate(); } + +string MySumClass::InLine() const { return leftValue->InLine() + " + " + rightValue->InLine(); } + +MyProductClass::MyProductClass(MyExpressionPtr _leftValue, MyExpressionPtr _rightValue) : + leftValue(move(_leftValue)), rightValue(move(_rightValue)) {} + +int MyProductClass::Calculate() const { return leftValue->Calculate() * rightValue->Calculate(); } + +string MyProductClass::InLine() const { + string right = rightValue->InLine(); + if (dynamic_cast(rightValue.get())) { + right = "(" + rightValue->InLine() + ")"; + } + + return leftValue->InLine() + " * " + right; +} + +MyExpressionPtr MyConst(int value) { + return make_shared(value); +} + +MyExpressionPtr MyProduct(MyExpressionPtr left, MyExpressionPtr right) { + return make_shared(move(left), move(right)); +} + +MyExpressionPtr MySum(MyExpressionPtr left, MyExpressionPtr right) { + return make_shared(move(left), move(right)); +} + +int main() { + MyExpressionPtr myEx1 = MySum(MyProduct(MyConst(3), MyConst(4)), MyConst(5)); + cout << myEx1->InLine() << "\n"; // 3 * 4 + 5 + cout << myEx1->Calculate() << "\n"; // 17 + + MyExpressionPtr myEx2 = MyProduct(MyConst(6), myEx1); + cout << myEx2->InLine() << "\n"; // 6 * (3 * 4 + 5) + cout << myEx2->Calculate() << "\n"; // 102 +} diff --git a/Second term/Industrial programming technologies/5/5.cpp b/Second term/Industrial programming technologies/5/5.cpp new file mode 100755 index 0000000..bb3cadf --- /dev/null +++ b/Second term/Industrial programming technologies/5/5.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +#include + +using namespace std; + +class Verdict { +public: + virtual string Article() const { return "You're free for now, but be careful from now on"; } + virtual ~Verdict() { } +}; + +class Voprosik: public Verdict { + string Article() const override { return "Vam chelovechek na cifri naberet"; } +}; + +class Temka: public Verdict { + string Article() const override { return "Poidem poshurshim, otskochim potreskochem"; } +}; + +class Business: public Verdict { + string Article() const override { return "Molodoi chelovek, proidemte"; } +}; + +using CriminalCase = vector>; + +CriminalCase createCriminalCase() { + CriminalCase cc; + string word; + while (cin >> word) { + if (word == "Voprosik") cc.push_back(make_unique()); + else if (word == "Temka") cc.push_back(make_unique()); + else if (word == "Business") cc.push_back(make_unique()); + else break; + } + return cc; +} + +void RedHanded(const CriminalCase& criminalCase) { + for (const auto& verdict: criminalCase) { + if (&verdict != &criminalCase.back()) cout << verdict->Article() << endl; + else cout << verdict->Article(); + } +} diff --git a/Second term/Industrial programming technologies/README.md b/Second term/Industrial programming technologies/README.md new file mode 100755 index 0000000..ce6229e --- /dev/null +++ b/Second term/Industrial programming technologies/README.md @@ -0,0 +1,26 @@ +# Industrial programming technologies + +[Таблица с баллами](https://docs.google.com/spreadsheets/d/1PdT3H56oPCPtWOCngtZWXntaI6bHLJq1mVZGKhwGs94/edit?usp=sharing) + +number | name | grade +:----: | ---------------------------------------------------------- | :---: +1.1 | Задача, чтобы набрать классы | ✅ +1.2 | Треугольник побольше | ✅ +1.3 | Треугольник большой вообще жесть | ✅ +1.4 | Задача, чтобы набрать классы | ✅ +1.5 | Наслаждайся стеком | ✅ +2.1 | Опять геометрия | ✅ +2.2 | Теперь алгебра (?) | ✅ +3.1 | Множество дробей | ✅ +3.2 | Перегрузка дробей | ✅ +3.3 | Шаблоны | ✅ +3.4 | Шаблоны классов | ✅ +3.5 | Гопуслуги | ✅ +4.1 | Снова треугольники | ✅ +5.1 | Не забудь снова добавить название | ✅ +5.2 | Случайности не случайны снова | ✅ +5.3 | Числа Бибоначчи снова | ✅ +5.4 | Задачу своровали | ✅ +5.5 | Человечки | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/README.md b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/README.md new file mode 100755 index 0000000..5fa1aed --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/README.md @@ -0,0 +1,7 @@ +# Курсовая работа на тему «Разработка программного продукта для моделирования информационно-управляющей системы автоматизации участка конвейерного производства» + +[Таблица с баллами](https://docs.google.com/spreadsheets/d/e/2PACX-1vRgOqfWFR8LkEXuK-Js5RsrZ9FaHayty0lAtURc9A8uXcqdWB_D9u2hgyBawvZIY1QczBO7h_43oJFV/pubhtml?gid=410989513&single=true) + +[Таблица с баллами №2](https://docs.google.com/spreadsheets/d/1Hw_KSd1EosDXJSxlOPvrz2Vf19kcJhIePvIgcTbfkfQ/edit#gid=388351660) + +[Back](/NKTKLN/mirea-projects) diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/CMakeLists.txt b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/CMakeLists.txt new file mode 100755 index 0000000..de00d7c --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/CMakeLists.txt @@ -0,0 +1,46 @@ +cmake_minimum_required (VERSION 3.11) + +# --- Dependencies ------------------------------------------------------------- +include(FetchContent) + +FetchContent_Declare(ftxui + GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui + GIT_TAG v5.0.0 + GIT_PROGRESS TRUE + GIT_SHALLOW FALSE +) +FetchContent_MakeAvailable(ftxui) + +FetchContent_Declare(fmt + GIT_REPOSITORY https://github.com/fmtlib/fmt + GIT_TAG master +) +FetchContent_MakeAvailable(fmt) +# ------------------------------------------------------------------------------ + +project(factory-emulator + LANGUAGES CXX + VERSION 1.0.0 +) + +add_executable(factory-emulator + src/main.cpp + src/models.cpp + src/models.h + src/system.cpp + src/system.h + src/interface.cpp + src/interface.h + src/environment.h +) + +target_include_directories(factory-emulator PRIVATE src) + +target_compile_features(factory-emulator PRIVATE cxx_std_20) + +target_link_libraries(factory-emulator + PRIVATE ftxui::screen + PRIVATE ftxui::dom + PRIVATE ftxui::component + PRIVATE fmt::fmt +) diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/README.md b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/README.md new file mode 100755 index 0000000..b009aab --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/README.md @@ -0,0 +1,8 @@ +# Main + +```bash +mkdir build && cd build +cmake .. +make +./factory-emulator +``` diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/environment.h b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/environment.h new file mode 100755 index 0000000..11690c9 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/environment.h @@ -0,0 +1,11 @@ +#ifndef environment +#define environment + +#include + +using namespace std; + +const string projectCreator = "NKTKLN"; +const string projectCodename = "Gamma"; + +#endif diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.cpp b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.cpp new file mode 100755 index 0000000..6e5cb02 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.cpp @@ -0,0 +1,260 @@ +#include +#include + +#include + +#include "ftxui/dom/elements.hpp" +#include "ftxui/screen/color.hpp" +#include "ftxui/screen/terminal.hpp" +#include "ftxui/component/component.hpp" +#include "ftxui/component/captured_mouse.hpp" +#include "ftxui/component/component_options.hpp" +#include "ftxui/component/screen_interactive.hpp" + +#include "models.h" +#include "system.h" +#include "interface.h" +#include "environment.h" + +using namespace std; +using namespace fmt; +using namespace ftxui; + +UserInterface::UserInterface() : selectedLanguageIndex(0) { + settings.containerMaxValue = 20; + settings.firstContainerValue = 20; + settings.secondContainerValue = 0; + settings.thirdContainerValue = 0; + settings.language = languages[selectedLanguageIndex]; +} + +void UserInterface::mainScreen() { + if (Terminal::Size().dimy < 23 || Terminal::Size().dimx < 80) { + Element document = color(Color::Red, hbox({ + text("Terminal window size is less than "), + text("80x23") | underlined, + text(" characters!"), + })) | bold; + Screen screen = Screen::Create(Dimension::Full(), Dimension::Fit(document)); + Render(screen, document); + screen.Print(); + return; + } + + ScreenInteractive screen = ScreenInteractive::Fullscreen(); + + int selected = 0; + MenuOption option = MenuOption(); + option.on_enter = [&] { + switch (selected) { + case 0: systemScreen(); break; + case 1: settingsScreen(); break; + case 2: aboutScreen(); break; + case 3: screen.Exit(); break; + } + }; + Component menu = Menu(&settings.language.mainMenuEntries, &selected, option); + Component renderer = Renderer(menu, [&] { + return vbox({ + text(settings.language.mainMenuTitle) | center | bold, + separator(), + menu->Render() | size(WIDTH, EQUAL, 20), + }) | border | center; + }); + + screen.Loop(renderer); +} + +void UserInterface::systemScreen() { + ScreenInteractive screen = ScreenInteractive::Fullscreen(); + atomic refresh_ui_continue = true; + thread refresh_ui([&] { + while (refresh_ui_continue) { + this_thread::sleep_for(0.05s); + screen.Post(Event::Custom); + } + }); + + System *mainSystem = new System(settings); + Conveyor *conveyor = mainSystem->firstConveyor; + + Component exitButton = Button(&settings.language.exit, [&] { screen.Exit(); }, + ButtonOption::Ascii()); + + bool isSystemStarted = false; + string systemButtonLable = settings.language.systemMenuStartButton; + Component systemButton = Button(&systemButtonLable, + [&] { + if (!isSystemStarted) { + mainSystem->start(); + systemButtonLable = settings.language.systemMenuStopButton; + } + else mainSystem->stop(); + isSystemStarted = !isSystemStarted; + }, ButtonOption::Ascii()); + + string conveyorButtonLable = settings.language.systemMenuConveyorStartButton; + Component conveyorButton = Button(&conveyorButtonLable, + [&] { + if (conveyor->status) conveyor->stop(); + else conveyor->start(); + }, ButtonOption::Ascii()); + + int tabSelected = 0; + Component tabToggle = Toggle(&settings.language.systemMenuTabs, &tabSelected); + + Component buttons = Container::Horizontal({ + systemButton | flex, + Renderer([&] { return separator(); }), + conveyorButton | flex, + Renderer([&] { return separator(); }), + exitButton | flex + }); + + Component container = Container::Vertical({ + tabToggle, + buttons + }); + Component renderer = Renderer(container, [&] { + switch (tabSelected) { + case 0: conveyor = mainSystem->firstConveyor; break; + case 1: conveyor = mainSystem->secondConveyor; break; + case 2: conveyor = mainSystem->thirdConveyor; break; + } + + if (!mainSystem->firstConveyor->status || + !mainSystem->secondConveyor->status || + !mainSystem->thirdConveyor->status) { + isSystemStarted = false; + systemButtonLable = settings.language.systemMenuStartButton; + } + else { + isSystemStarted = true; + systemButtonLable = settings.language.systemMenuStopButton; + } + + conveyorButtonLable = conveyor->status ? settings.language.systemMenuConveyorStopButton : + settings.language.systemMenuConveyorStartButton; + + // Сonveyor animation builder + Component conveyorContainer = Container::Vertical({}); + ConveyorStatuses statuses = conveyor->getStatuses(); + int beltIndex = statuses.detailXCords >= 0 ? statuses.detailXCords % 3 : 0; + for (int index = 0; index < 13; index++) { + string line = vformat(conveyorTemplate[index], + make_format_args( + containerStates[0][statuses.topContainer], + containerStates[1][statuses.topContainer], + statuses.topContainerValue, + containerStates[0][statuses.bottomContainer], + containerStates[1][statuses.bottomContainer], + statuses.bottomContainerValue, + beltStates[2 - beltIndex], + beltStates[beltIndex], + detectorStates[statuses.firstDetector], + detectorStates[statuses.secondDetector] + )); + + if (index >= 6 && index <= 7 && statuses.detailType >= 0) { + string detail = vformat(boxTypes[statuses.detailType][index - 6], + make_format_args(statuses.detailData)); + for (int pixelCord = 0; pixelCord < detail.size(); pixelCord++) + line[7 + pixelCord + statuses.detailXCords] = detail[pixelCord]; + } + + if (index >= 5 && index <= 7) { + string printer = (index - 5) == statuses.printer ? printerStates[1] : printerStates[0]; + if (statuses.printer == 0 && index != 5 || (index - 5) > statuses.printer) printer = ""; + for (int pixelCord = 0; pixelCord < printer.length(); pixelCord++) + line[32 + pixelCord] = printer[pixelCord]; + } + + conveyorContainer->Add(Renderer([line] { return text(line); })); + } + + return vbox({ + text(settings.language.systemMenuTitle) | bold | center, + separator(), + tabToggle->Render(), + separator(), + conveyorContainer->Render() | center, + separator(), + text(settings.language.systemErrors[statuses.errorIndex]) | color(Color::Red), + separator(), + buttons->Render(), + }) | size(WIDTH, EQUAL, 78) | border | center; + }); + screen.Loop(renderer); + refresh_ui_continue = false; + refresh_ui.join(); + delete mainSystem; +} + +void UserInterface::settingsScreen() { + ScreenInteractive screen = ScreenInteractive::Fullscreen(); + + RadioboxOption option = RadioboxOption(); + option.focused_entry = selectedLanguageIndex; + option.on_change = [&] { settings.language = languages[selectedLanguageIndex]; }; + Component languageRadiobox = Radiobox(&settings.language.settingsMenuLanguageEntries, + &selectedLanguageIndex, option); + Component exitButton = Button(&settings.language.exit, [&] { screen.Exit(); }, + ButtonOption::Ascii()); + Component firstContainerValueSlider = Slider("", &settings.firstContainerValue, + 0, settings.containerMaxValue, 1); + Component secondContainerValueSlider = Slider("", &settings.secondContainerValue, + 0, settings.containerMaxValue, 1); + Component thirdContainerValueSlider = Slider("", &settings.thirdContainerValue, + 0, settings.containerMaxValue, 1); + + Component container = ftxui::Container::Vertical({ + languageRadiobox, + firstContainerValueSlider, + secondContainerValueSlider, + thirdContainerValueSlider, + exitButton, + }); + Component renderer = Renderer(container, [&] { + return vbox({ + text(settings.language.settingsMenuTitle) | bold | center, + separator(), + text(settings.language.settingsMenuLanguage), + separator(), + languageRadiobox->Render(), + separator(), + text(settings.language.settingsMenuConatinerValue), + separator(), + hbox(text(settings.language.settingsMenuFirstConatiner), + text(": " + to_string(settings.firstContainerValue))), + firstContainerValueSlider->Render(), + hbox(text(settings.language.settingsMenuSecondConatiner), + text(": " + to_string(settings.secondContainerValue))), + secondContainerValueSlider->Render(), + hbox(text(settings.language.settingsMenuThirdConatiner), + text(": " + to_string(settings.thirdContainerValue))), + thirdContainerValueSlider->Render(), + separator(), + exitButton->Render(), + }) | size(WIDTH, EQUAL, 50) | border | center; + }); + screen.Loop(renderer); +} + +void UserInterface::aboutScreen() { + ScreenInteractive screen = ScreenInteractive::Fullscreen(); + Component exitButton = Button(settings.language.exit, [&] { screen.Exit(); }, + ButtonOption::Ascii()); + auto renderer = Renderer(exitButton, [&] { + return vbox({ + text(settings.language.aboutMenuTitle) | bold | center, + separator(), + hbox(text(settings.language.aboutMenuCodename + ": "), + color(Color::Green, text(projectCodename))), + hbox(text(settings.language.aboutMenuCreator + ": "), + color(Color::Cyan, text(projectCreator))), + separator(), + exitButton->Render(), + }) | size(WIDTH, EQUAL, 20) | border | center; + }); + screen.Loop(renderer); +} diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.h b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.h new file mode 100755 index 0000000..0812956 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/interface.h @@ -0,0 +1,20 @@ +#ifndef interface +#define interface + +#include "models.h" + +class UserInterface { +private: + Settings settings; + int selectedLanguageIndex; + +public: + UserInterface(); + + void mainScreen(); + void systemScreen(); + void settingsScreen(); + void aboutScreen(); +}; + +#endif diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/main.cpp b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/main.cpp new file mode 100755 index 0000000..42246f9 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/main.cpp @@ -0,0 +1,7 @@ +#include "interface.h" + +int main() { + UserInterface ui = UserInterface(); + ui.mainScreen(); + return 0; +} diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.cpp b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.cpp new file mode 100755 index 0000000..7fd3f33 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.cpp @@ -0,0 +1,219 @@ +#include + +#include "models.h" + +using namespace std; + +// Interface language templates +Language English() { + Language lang; + + lang.exit = "Exit"; + + lang.mainMenuTitle = "Factory emulator"; + lang.mainMenuEntries = { + "Start", + "Settings", + "About", + lang.exit + }; + + lang.systemMenuTitle = "System"; + lang.systemMenuStopButton = "Stop system"; + lang.systemMenuStartButton = "Start system"; + lang.systemMenuConveyorStopButton = "Stop conveyor"; + lang.systemMenuConveyorStartButton = "Start conveyor"; + lang.systemErrors = { + "", + "The container ran out of details", + "The maximum level of details in the container has been exceeded", + }; + lang.systemMenuTabs = { + "First conveyor", + "Second conveyor", + "Third conveyor" + }; + + lang.settingsMenuTitle = "Settings"; + lang.settingsMenuLanguage = "Language"; + lang.settingsMenuConatinerValue = "Container start value"; + lang.settingsMenuFirstConatiner = "First container"; + lang.settingsMenuSecondConatiner = "Second container"; + lang.settingsMenuThirdConatiner = "Third container"; + lang.settingsMenuLanguageEntries = { + "English", + "Russian", + "Chinese" + }; + + lang.aboutMenuTitle = "About"; + lang.aboutMenuCodename = "Codename"; + lang.aboutMenuCreator = "Creator"; + + return lang; +} + +Language Russian() { + Language lang; + + lang.exit = "Выход"; + + lang.mainMenuTitle = "Эмулятор фабрики"; + lang.mainMenuEntries = { + "Запуск", + "Настройки", + "О программе", + lang.exit + }; + + lang.systemMenuTitle = "Система"; + lang.systemMenuStopButton = "Остановить систему"; + lang.systemMenuStartButton = "Запустить систему"; + lang.systemMenuConveyorStopButton = "Остановить конвейер"; + lang.systemMenuConveyorStartButton = "Запустить конвейер"; + lang.systemErrors = { + "", + "В корнейтене закончились детали", + "Достигнут максимальный уровень деталей в контейнере", + }; + lang.systemMenuTabs = { + "Первый конвейер", + "Второй конвейер", + "Третий конвейер" + }; + + lang.settingsMenuTitle = "Настройки"; + lang.settingsMenuLanguage = "Язык"; + lang.settingsMenuConatinerValue = "Начальное значение контейнера"; + lang.settingsMenuFirstConatiner = "Первый контейнер"; + lang.settingsMenuSecondConatiner = "Второй контейнер"; + lang.settingsMenuThirdConatiner = "Третий контейнер"; + lang.settingsMenuLanguageEntries = { + "Английский", + "Русский", + "Китайский" + }; + + lang.aboutMenuTitle = "О программе"; + lang.aboutMenuCodename = "Кодовое имя"; + lang.aboutMenuCreator = "Создатель"; + + return lang; +} + +Language Chinese() { + Language lang; + + lang.exit = "退出"; + + lang.mainMenuTitle = "工厂模拟器"; + lang.systemMenuStopButton = "停止系统"; + lang.systemMenuStartButton = "启动系统"; + lang.systemMenuConveyorStopButton = "停止传送带"; + lang.systemMenuConveyorStartButton = "启动传送带"; + lang.mainMenuEntries = { + "启动", + "设置", + "关于", + lang.exit + }; + + lang.systemMenuTitle = "系统"; + lang.systemMenuTabs = { + "第一传送带", + "第二传送带", + "第三传送带" + }; + + lang.settingsMenuTitle = "设置"; + lang.settingsMenuLanguage = "语言"; + lang.settingsMenuConatinerValue = "容器初始值"; + lang.settingsMenuFirstConatiner = "第一容器"; + lang.settingsMenuSecondConatiner = "第二容器"; + lang.settingsMenuThirdConatiner = "第三容器"; + lang.systemErrors = { + "", + "没有关于集装箱的更多细节", + "已超出容器中详细信息的最大级别", + }; + lang.settingsMenuLanguageEntries = { + "英语", + "俄语", + "汉语" + }; + + lang.aboutMenuTitle = "关于"; + lang.aboutMenuCodename = "代号"; + lang.aboutMenuCreator = "创建者"; + + return lang; +} + +extern const vector languages = {English(), Russian(), Chinese()}; + +// Conveyor screen templates + +/* +0 - top box close +1 - top box open +2 - top box number +3 - second box close +4 - second box open +5 - second box number +6 - belt top +7 - belt bottom +8 - first detector +9 - second detector +*/ +extern const string conveyorTemplate[13] = { + "+--------+ ", + "|==[{2:02}]==| +---+ +----+ +---+ ", + "|========| |{8} {8}| |][][| |{9} {9}| ", + "0{0}+ | - | |][][| | - | ", + " {1} +---+ +----+ +---+ ", + " {1} : : ", + " {1} : : {4} ", + " : : {4} ", + " .{6}. {4} ", + "( 0 0 ) +{3}0", + " '{7}' |==[{5:02}]==|", + " |========|", + " +--------+" +}; + +extern const string containerStates[2][2] = { + {"--------", " "}, + {" ", "\\"} +}; + +extern const string detectorStates[2] = {"-", "0"}; + +extern const string printerStates[2] = { + " || ", + "/====\\" +}; + +extern const string boxTypes[4][2] = { + { + "", + "----" + }, + { + "*i^o", + "----" + }, + { + " __ ", + "[##]" + }, + { + " __ ", + "[{}]" + }, +}; + +extern const string beltStates[3] = { + "-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-", + "==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-=", + "=-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==" +}; diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.h b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.h new file mode 100755 index 0000000..2a3948e --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/models.h @@ -0,0 +1,67 @@ +#ifndef models +#define models + +#include +#include + +using namespace std; + +struct ConveyorStatuses { + int printer; + int detailType; + string detailData; + int detailXCords; + bool firstDetector; + bool secondDetector; + bool topContainer; + bool bottomContainer; + int topContainerValue; + int bottomContainerValue; + int errorIndex; +}; + +struct Language { + string exit; + + string mainMenuTitle; + vector mainMenuEntries; + + string systemMenuTitle; + string systemMenuStopButton; + string systemMenuStartButton; + string systemMenuConveyorStopButton; + string systemMenuConveyorStartButton; + vector systemErrors; + vector systemMenuTabs; + + string settingsMenuTitle; + string settingsMenuLanguage; + string settingsMenuConatinerValue; + string settingsMenuFirstConatiner; + string settingsMenuSecondConatiner; + string settingsMenuThirdConatiner; + vector settingsMenuLanguageEntries; + + string aboutMenuTitle; + string aboutMenuCodename; + string aboutMenuCreator; +}; + +struct Settings { + int containerMaxValue; + int firstContainerValue; + int secondContainerValue; + int thirdContainerValue; + Language language; +}; + +extern const vector languages; + +extern const string conveyorTemplate[13]; +extern const string containerStates[2][2]; +extern const string detectorStates[2]; +extern const string printerStates[2]; +extern const string boxTypes[4][2]; +extern const string beltStates[3]; + +#endif diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.cpp b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.cpp new file mode 100755 index 0000000..393b384 --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.cpp @@ -0,0 +1,391 @@ +#include +#include +#include +#include + +#include "models.h" +#include "system.h" + +#define DETAIL_SIZE 4 +#define PRINTER_CORDS 25 +#define MAX_DETAIL_CORDS 47 +#define FIRST_DETECTOR_CORDS 13 +#define SECOND_DETECTOR_CORDS 42 +#define STOREHOUSE_MAX_VALUE 999 + +using namespace std; + +// TickGenerator class functions +void TickGenerator::run() { + while (status) { + this_thread::sleep_for(0.3s); + currentTick++; + } +} + +TickGenerator::TickGenerator() : currentTick(0), status(true) { + mainThread = thread(&TickGenerator::run, this); +} + +TickGenerator::~TickGenerator() { + if (!status) return; + + status = false; + mainThread.join(); +} + +void TickGenerator::delay(int ticks) { + int endTick = currentTick + ticks; + while (endTick > currentTick) {} +} + +// Detail class functions +Detail::Detail(int _typeIndex) : typeIndex(_typeIndex) {} + +// Container class functions +DetailContainer::DetailContainer(int _maxNumberOfDetails) : + maxNumberOfDetails(_maxNumberOfDetails), topDriverStatus(false), + bottomDriverStatus(false) {} + +DetailContainer::DetailContainer(int _maxNumberOfDetails, int numberOfDetails, int detailTypeIndex) : + maxNumberOfDetails(_maxNumberOfDetails), topDriverStatus(true), bottomDriverStatus(false) { + fillWithDetails(numberOfDetails, detailTypeIndex); + topDriverStatus = false; +} + +DetailContainer::~DetailContainer() { + for (int index = 0; index < details.size(); index++) + delete details[index]; + details.clear(); +} + +Detail *DetailContainer::getDatail() { + if (details.empty()) + throw underflow_error("The container ran out of details."); + + if (!bottomDriverStatus) + throw logic_error("The container lid is closed."); + + Detail *tmp = details.back(); + details.pop_back(); + + return tmp; +} + +void DetailContainer::addDetail(Detail *detail) { + if (details.size() + 1 > maxNumberOfDetails) + throw out_of_range("The maximum level of details in the container has been exceeded."); + + if (!topDriverStatus) + throw logic_error("The container lid is closed."); + + details.push_back(detail); +} + +void DetailContainer::fillWithDetails(int numberOfDetails, int detailTypeIndex) { + if (numberOfDetails + details.size() > maxNumberOfDetails) + throw out_of_range("The maximum level of details in the container has been exceeded."); + + for (int index = 0; index < numberOfDetails; index++) + addDetail(new Detail(detailTypeIndex)); +} + +int DetailContainer::getNumberOfDetails() { return details.size(); } + +int DetailContainer::getMaxNumberOfDetails() { return maxNumberOfDetails; } + +// Belt class functions +void Belt::run() { + if (!detail) { + status = false; + throw logic_error("There are no details on the conveyor belt."); + } + + while (status && detailXCords < MAX_DETAIL_CORDS) { + tickGenerator->delay(1); + detailXCords++; + } +} + +Belt::Belt(TickGenerator *_tickGenerator) : + status(false), detailXCords(0), detail(nullptr), tickGenerator(_tickGenerator) {} + +Belt::~Belt() { stop(); } + +void Belt::stop() { + if (!status) return; + + status = false; + mainThread.join(); +} + +void Belt::start() { + if (status) return; + + status = true; + mainThread = thread(&Belt::run, this); +} + +int Belt::getDetailCords() { + if (!detail) + throw underflow_error("There is no detail on the belt."); + + return detailXCords; +} + +Detail *Belt::getDetail() { + if (!detail) + throw underflow_error("There is no detail on the belt."); + + return detail; +} + +Detail *Belt::pickUpDetail() { + if (!detail) + throw underflow_error("There is no detail on the belt."); + + if (detailXCords < MAX_DETAIL_CORDS) + throw logic_error("The detal didn't go all the way through."); + + Detail *tmpDetail = detail; + detail = nullptr; + stop(); + + return tmpDetail; +} + +void Belt::putDetail(Detail *newDetail) { + if (!newDetail) + throw overflow_error("There's already a detail on the belt."); + + detail = newDetail; + detailXCords = 0; +} + +// Printer class functions +Printer::Printer(Belt *_belt, TickGenerator *_tickGenerator, void (*_printFunction)(Detail *)) : + printerStatus(0), status(true), belt(_belt), tickGenerator(_tickGenerator), + printFunction(_printFunction) {}; + +void Printer::print() { + for (; (printerStatus < 2) && status; printerStatus++) + tickGenerator->delay(1); + + if (!status) return; + printFunction(belt->getDetail()); + + for (; (printerStatus > 0) && status; printerStatus--) + tickGenerator->delay(1); +} + +void Printer::stop() { status = false; } + +void Printer::start() { + status = true; + for (; (printerStatus > 0) && status; printerStatus--) + tickGenerator->delay(1); +} + +int Printer::getPrinterStatus() { return printerStatus; } + +// Detector class functions +Detector::Detector(Belt *_belt, int _detectableCords) : + belt(_belt), detectableCords(_detectableCords) {}; + +bool Detector::getStatus() { + try { + return belt->getDetailCords() >= detectableCords && + belt->getDetailCords() < detectableCords + DETAIL_SIZE; + } + catch (const underflow_error& error) { return false; } +} + +// Conveyor class functions +void Conveyor::run() { + /* + \ /\ + ) ( ') + ( / ) + \(__)| + + I'm a little kitten who's tired of writing code. + Please do not pick on the crutches written below, meow :3 + */ + + try { + int detailCords = belt->getDetailCords(); + if ((detailCords > 0 && detailCords < 25) || + (detailCords > 26 && detailCords < MAX_DETAIL_CORDS)) belt->start(); + } + catch (const underflow_error& error) {} + + while (status) { + int detailCords; + try { detailCords = belt->getDetailCords(); } + catch (const underflow_error& error) { detailCords = -1; } + + if (detailCords == -1 && !topContainer->bottomDriverStatus) { + if (topContainer->getNumberOfDetails() <= 0) { + errorIndex = 1; // The container ran out of details. + break; + } + + topContainer->bottomDriverStatus = true; + } + else if (detailCords == -1 && topContainer->bottomDriverStatus) + belt->putDetail(topContainer->getDatail()); + else if (detailCords == 0 && topContainer->bottomDriverStatus) + topContainer->bottomDriverStatus = false; + else if (detailCords == 0 && !topContainer->bottomDriverStatus) + belt->start(); + else if (detailCords == PRINTER_CORDS) { + belt->stop(); + tickGenerator->delay(1); + if (!status) break; + printer->print(); + tickGenerator->delay(1); + if (!status) break; + belt->start(); + } + else if (secondDetector->getStatus()) + bottomContainer->topDriverStatus = true; + else if (detailCords == MAX_DETAIL_CORDS) { + if (bottomContainer->getMaxNumberOfDetails() < bottomContainer->getNumberOfDetails() + 1) { + errorIndex = 2; // The maximum level of details in the container has been exceeded. + break; + } + + bottomContainer->addDetail(belt->pickUpDetail()); + tickGenerator->delay(1); + if (!status) break; + bottomContainer->topDriverStatus = false; + + if (bottomContainer->getMaxNumberOfDetails() <= bottomContainer->getNumberOfDetails()) { + errorIndex = 2; // The maximum level of details in the container has been exceeded. + break; + } + } + tickGenerator->delay(1); + } + + status = false; + belt->stop(); + printer->stop(); +} + +Conveyor::Conveyor(DetailContainer *_topContainer, DetailContainer *_bottomContainer, + TickGenerator *_tickGenerator, void (*printFunction)(Detail *)) : topContainer(_topContainer), + bottomContainer(_bottomContainer), tickGenerator(_tickGenerator), status(false), errorIndex(0) { + belt = new Belt(tickGenerator); + printer = new Printer(belt, tickGenerator, printFunction); + firstDetector = new Detector(belt, FIRST_DETECTOR_CORDS); + secondDetector = new Detector(belt, SECOND_DETECTOR_CORDS); +} + +Conveyor::~Conveyor() { + belt->stop(); + printer->stop(); + try { mainThread.join(); } + catch (const exception& e){} + + delete belt; + delete printer; + delete firstDetector; + delete secondDetector; +} + +void Conveyor::stop() { + if (!status) return; + + status = false; + belt->stop(); + printer->stop(); + mainThread.join(); +} + +void Conveyor::start() { + if (status) return; + + try { mainThread.join(); } + catch (const exception& e){} + + status = true; + errorIndex = 0; + printer->start(); + mainThread = thread(&Conveyor::run, this); +} + +ConveyorStatuses Conveyor::getStatuses() { + ConveyorStatuses statuses; + + try { + Detail *tmpDetail = belt->getDetail(); + statuses.detailXCords = belt->getDetailCords(); + statuses.detailType = tmpDetail->typeIndex; + statuses.detailData = tmpDetail->data; + } + catch (const underflow_error& error) { + statuses.detailXCords = -1; + statuses.detailType = -1; + statuses.detailData = ""; + } + + statuses.errorIndex = errorIndex; + statuses.printer = printer->getPrinterStatus(); + statuses.firstDetector = firstDetector->getStatus(); + statuses.secondDetector = secondDetector->getStatus(); + statuses.topContainer = topContainer->bottomDriverStatus; + statuses.bottomContainer = bottomContainer->topDriverStatus; + statuses.topContainerValue = topContainer->getNumberOfDetails(); + statuses.bottomContainerValue = bottomContainer->getNumberOfDetails(); + + return statuses; +} + +// System class functions +void System::stop() { + firstConveyor->stop(); + secondConveyor->stop(); + thirdConveyor->stop(); +} + +void System::start() { + firstConveyor->start(); + secondConveyor->start(); + thirdConveyor->start(); +} + +System::System(const Settings settings) { + tickGenerator = new TickGenerator(); + + firstContainer = new DetailContainer(settings.containerMaxValue, settings.firstContainerValue, 0); + secondContainer = new DetailContainer(settings.containerMaxValue, settings.secondContainerValue, 1); + thirdContainer = new DetailContainer(settings.containerMaxValue, settings.thirdContainerValue, 2); + storehouseContainer = new DetailContainer(STOREHOUSE_MAX_VALUE); + + firstConveyor = new Conveyor(firstContainer, secondContainer, tickGenerator, + [](Detail* detail){ detail->typeIndex = 1; }); + secondConveyor = new Conveyor(secondContainer, thirdContainer, tickGenerator, + [](Detail* detail){ detail->typeIndex = 2; }); + thirdConveyor = new Conveyor(thirdContainer, storehouseContainer, tickGenerator, + [](Detail* detail){ + srand(time(0)); + detail->typeIndex = 3; + detail->data = char(65 + rand() % 26) + to_string(rand() % 10); + }); +} + +System::~System() { + stop(); + + delete tickGenerator; + + delete firstContainer; + delete secondContainer; + delete thirdContainer; + delete storehouseContainer; + + delete firstConveyor; + delete secondConveyor; + delete thirdConveyor; +} diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.h b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.h new file mode 100755 index 0000000..1afe48f --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/app/src/system.h @@ -0,0 +1,160 @@ +#ifndef system +#define system + +#include +#include +#include + +#include "models.h" + +class TickGenerator { +private: + bool status; + int currentTick; + thread mainThread; + + void run(); + +public: + TickGenerator(); + ~TickGenerator(); + + void delay(int ticks); +}; + +class Detail { +public: + string data; + int typeIndex; + + Detail(int _typeIndex); +}; + +class DetailContainer { +private: + int maxNumberOfDetails; + vector details; + +public: + bool topDriverStatus; + bool bottomDriverStatus; + + DetailContainer(int _maxNumberOfDetails); + DetailContainer(int _maxNumberOfDetails, int numberOfDetails, int detailTypeIndex); + ~DetailContainer(); + + int getNumberOfDetails(); + int getMaxNumberOfDetails(); + Detail *getDatail(); + + void addDetail(Detail *detail); + void fillWithDetails(int numberOfDetails, int detailTypeIndex); +}; + +class Belt { +private: + bool status; + int detailXCords; + thread mainThread; + + Detail *detail; + TickGenerator *tickGenerator; + + void run(); + +public: + Belt(TickGenerator *_tickGenerator); + ~Belt(); + + void stop(); + void start(); + + int getDetailCords(); + Detail *getDetail(); + Detail *pickUpDetail(); + + void putDetail(Detail *detail); +}; + +class Printer { +private: + int status; + int printerStatus; + + Belt *belt; + TickGenerator *tickGenerator; + void (*printFunction)(Detail *); + +public: + Printer(Belt *_belt, TickGenerator *_tickGenerator, void (*_printFunction)(Detail *)); + + void stop(); + void start(); + + void print(); + + int getPrinterStatus(); +}; + +class Detector { +private: + int detectableCords; + + Belt *belt; + +public: + Detector(Belt *_belt, int _detectableCords); + + bool getStatus(); +}; + +class Conveyor { +private: + thread mainThread; + int errorIndex; + + Belt *belt; + Printer *printer; + Detector *firstDetector; + Detector *secondDetector; + DetailContainer *topContainer; + DetailContainer *bottomContainer; + TickGenerator *tickGenerator; + + void run(); + +public: + bool status; + + Conveyor(DetailContainer *_topContainer, DetailContainer *_bottomContainer, + TickGenerator *_tickGenerator, void (*printFunction)(Detail *)); + ~Conveyor(); + + void stop(); + void start(); + + ConveyorStatuses getStatuses(); +}; + +class System { +private: + TickGenerator *tickGenerator; + + DetailContainer *firstContainer; + DetailContainer *secondContainer; + DetailContainer *thirdContainer; + DetailContainer *storehouseContainer; + +public: + Conveyor *firstConveyor; + Conveyor *secondConveyor; + Conveyor *thirdConveyor; + + System(const Settings settings); + ~System(); + + void stop(); + void start(); +}; + +#endif diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/диаграмма_классов_системы.drawio b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/диаграмма_классов_системы.drawio new file mode 100755 index 0000000..d339eed --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/диаграмма_классов_системы.drawio @@ -0,0 +1,229 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/схематическое_изображение_установки.drawio b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/схематическое_изображение_установки.drawio new file mode 100755 index 0000000..fc0c40a --- /dev/null +++ b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/drawio/схематическое_изображение_установки.drawio @@ -0,0 +1,142 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/font/Montserrat.zip b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/font/Montserrat.zip new file mode 100755 index 0000000..0670956 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/font/Montserrat.zip differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/main_menu.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/main_menu.png new file mode 100755 index 0000000..fad7bab Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/main_menu.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_chinese.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_chinese.png new file mode 100755 index 0000000..70ccee1 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_chinese.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_english.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_english.png new file mode 100755 index 0000000..c9ea826 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_english.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_russian.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_russian.png new file mode 100755 index 0000000..f20aefc Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/settings_menu_russian.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu.png new file mode 100755 index 0000000..b5d1218 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_error.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_error.png new file mode 100755 index 0000000..a980831 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_error.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_linux.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_linux.png new file mode 100755 index 0000000..3d3033e Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_linux.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_windows.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_windows.png new file mode 100755 index 0000000..5fa7959 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/system_menu_windows.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/диаграмма_классов_системы.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/диаграмма_классов_системы.png new file mode 100755 index 0000000..fe3d6b6 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/диаграмма_классов_системы.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/схематическое_изображение_установки.png b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/схематическое_изображение_установки.png new file mode 100755 index 0000000..008ca21 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/images/схематическое_изображение_установки.png differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf new file mode 100755 index 0000000..8db0846 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Лист задания.pdf differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Отчет.pdf b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Отчет.pdf new file mode 100755 index 0000000..9fa178c Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Отчет.pdf differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Презентация.pdf b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Презентация.pdf new file mode 100755 index 0000000..f988a86 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/pdf/ТИП_2_КР_ЭФБО-09-23_Калинин Н.В._Презентация.pdf differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Доклад.docx b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Доклад.docx new file mode 100755 index 0000000..ca8456f Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Доклад.docx differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Отчет.docx b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Отчет.docx new file mode 100755 index 0000000..c7b4f56 Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Отчет.docx differ diff --git a/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Презентация.pptx b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Презентация.pptx new file mode 100755 index 0000000..4ccbe1d Binary files /dev/null and b/Term papers/ЭФБО-09-23 Калинин Никита Викторович Курсовая работа по индустреальному программированию продвинутый уровень 2 семестр/Презентация.pptx differ diff --git a/Third term/Artificial intelligence systems and big data/1.ipynb b/Third term/Artificial intelligence systems and big data/1.ipynb new file mode 100755 index 0000000..cf4e76a --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/1.ipynb @@ -0,0 +1,636 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "93d8c208-e950-4681-b4fe-1c78fc1b2a21", + "metadata": {}, + "source": [ + "# Рабочая тетрадь No 1" + ] + }, + { + "cell_type": "markdown", + "id": "362b66a9", + "metadata": {}, + "source": [ + "1.3 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b9a69252-6f4f-496f-bb22-6bbbed2cdcac", + "metadata": {}, + "outputs": [], + "source": [ + "x = 5 >= 2\n", + "A = {1,3,7,8}\n", + "B = {2,4,5,10,'apple'}\n", + "C = A & B\n", + "df = 'Антонова Антонина', 34, 'ж'\n", + "z = 'type'\n", + "D = [1, 'title', 2, 'content']" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "553ba58d-ca06-49fb-a652-cede2cc33559", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True | \n", + " {8, 1, 3, 7} | \n", + " {2, 4, 5, 'apple', 10} | \n", + " set() | \n", + " ('Антонова Антонина', 34, 'ж') | \n", + " type | \n", + " [1, 'title', 2, 'content'] | \n" + ] + } + ], + "source": [ + "print(x, '|', type(x), '\\n', A, '|', type(A), '\\n', B, '|', type(B),\n", + " '\\n', C, '|', type(C), '\\n', df, '|', type(df), '\\n',\n", + " z, '|', type(z),'\\n', D, '|', type(D),)" + ] + }, + { + "cell_type": "markdown", + "id": "2ee18350-697a-4d9a-a22a-4362b7870a7f", + "metadata": {}, + "source": [ + "2.3 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "092547e5-a728-4b08-9640-8acc2537285c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "х принадлежит (5, +infinity)\n" + ] + } + ], + "source": [ + "x = 10\n", + "\n", + "if x < -5:\n", + " print(\"x принадлежит (-infinity, -5)\")\n", + "elif x >= -5 and x <= 5:\n", + " print(\"x принадлежит [-5;5]\")\n", + "else:\n", + " print(\"х принадлежит (5, +infinity)\")" + ] + }, + { + "cell_type": "markdown", + "id": "b157c155-7cd1-485d-9dbd-63075743a3a3", + "metadata": {}, + "source": [ + "Задание 3.3.1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "638e3938-cdbe-48b5-a089-f47a1b7317f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "7\n", + "4\n", + "1\n" + ] + } + ], + "source": [ + "x = 10\n", + "while x > 0:\n", + " print(x)\n", + " x -= 3" + ] + }, + { + "cell_type": "markdown", + "id": "c64c1c7a-d9ec-491c-8b2f-4d0e3ac33d64", + "metadata": {}, + "source": [ + "Задание 3.3.2." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f6d05bd4-277e-4420-9368-3d3eb457e521", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Пол\n", + "Возраст\n", + "Группа крови\n" + ] + } + ], + "source": [ + "list_of_human_characters = [\"Пол\", \"Возраст\", \"Группа крови\"]\n", + "\n", + "for character in list_of_human_characters:\n", + " print(character)" + ] + }, + { + "cell_type": "markdown", + "id": "f31280d8-374d-443e-8578-530748ea61aa", + "metadata": {}, + "source": [ + "Задание 3.3.3." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0a5413ba-1e73-473a-9940-326b75d2cb68", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n" + ] + } + ], + "source": [ + "list_of_numbers = range(2, 16)\n", + "\n", + "print(list(list_of_numbers))" + ] + }, + { + "cell_type": "markdown", + "id": "1a8bf4ca-ec68-4224-b3cb-a57e7bfda81b", + "metadata": {}, + "source": [ + "Задание 3.3.4." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bc3e295f-1fa1-4822-96ec-87b128e97ec2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "105\n", + "80\n", + "55\n", + "30\n", + "5\n" + ] + } + ], + "source": [ + "for i in range(105, 4, -25):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "id": "c7cfb41f-d1dd-4e64-b524-6061eec4377a", + "metadata": {}, + "source": [ + "Задание 3.3.5." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "071fff6c-ef63-40ea-bb59-b3c740cdd667", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[8, 1, 6, 3, 4, 5, 2, 7, 0, 9]\n" + ] + } + ], + "source": [ + "x = [0,1,2,3,4,5,6,7,8,9]\n", + "x[::2] = x[::2][::-1]\n", + "\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "id": "0f07122f-4736-43ae-b784-9f809eb15867", + "metadata": {}, + "source": [ + "4.3.1 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "c0d364bc-976e-4e92-b23c-f0612d4d116e", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from statistics import median\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "a0e5ad2a-4f64-4dd1-a23e-f094834a1883", + "metadata": {}, + "outputs": [], + "source": [ + "count = 1000\n", + "\n", + "x_values = np.concatenate([np.random.random(count)])\n", + "y_values = list(range(count))" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "90791a47-6edf-4d72-9ffc-2a859a9b5b2f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.48475484828462484\n", + "0.4998818822942002\n" + ] + } + ], + "source": [ + "avg_value = sum(x_values) / len(x_values)\n", + "median_value = median(x_values)\n", + "\n", + "print(avg_value)\n", + "print(median_value)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "892aab6d-5ce0-4d66-b45a-e4ba218aff39", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(x_values, y_values)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5320fef5-cf42-4dd4-a09c-2705a93864c2", + "metadata": {}, + "source": [ + "4.3.2 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "d9b6bc90-8c75-4a0b-a3d9-739e12c1769b", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "7dc99ddf-fcbe-4a91-9ee3-f102f5c525c7", + "metadata": {}, + "outputs": [], + "source": [ + "def function(x):\n", + " return (np.sqrt(1 + np.e ** np.sqrt(x) + np.cos(x ** 2)) / abs(1 - np.sin(x) ** 3)) + np.log(2 * x)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "d1bf7069-4c70-4ca5-852c-5c0481c9ee23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjr0lEQVR4nO3de3Bb53nn8e/Du0iClqgLIUuyJdkyKNtN65hrK3GbSHVTu2k29nQmO+q0HU02M5qdzaRup01it7OT2e566ky6bbK7bXfV3NQ2G9V1vLE3bZ26slmnru3EtnyVSFmWbJkSL7JuBCmJNzz7BwASoHhEEjggbr/PjAbAwSHw8iX1w+F73vM+5u6IiEhlqSl2A0REJHwKdxGRCqRwFxGpQAp3EZEKpHAXEalAdcVuAMCqVat848aNxW5GXkZHR2lpaSl2M0qG+iOb+mOG+iJbPv3x0ksvve/uq+d6riTCfePGjbz44ovFbkZeuru72b59e7GbUTLUH9nUHzPUF9ny6Q8zezfoOQ3LiIhUIIW7iEgFmjfczeybZjZkZm/M8dzvmpmb2aqMbQ+Y2REz6zWzu8JusIiIzG8hR+7fBu6evdHMNgAfA45nbLsR2AnclPqaPzOz2lBaKiIiCzZvuLv7M8CZOZ76E+ALQObiNPcA+9x9zN2PAUeA28JoqIiILFxOY+5m9knghLu/OuupdcB7GY/7UttERGQJLXoqpJk1A78P/OJcT8+xbc5lJ81sN7AboKOjg+7u7sU2paSMjIyU/fcQJvVHNvXHDPVFtkL1Ry7z3K8DNgGvmhnAeuBlM7uN5JH6hox91wMn53oRd98D7AHo6urycp/3qrm72dQf2dQfSUPDl9j79//C5z+xvdhNKRmF+t1Y9LCMu7/u7mvcfaO7byQZ6B909wHgcWCnmTWa2SZgC/DjUFssImXrG88e409fGePM6Hixm1LxFjIV8rvAc0DMzPrM7DNB+7r7m8DDwEHgCeCz7j4VVmNFpLwd6o8D0DMwXOSWVL55h2Xc/VfneX7jrMcPAg/m1ywRqUS9qVDvHYjz4etWzbO35ENXqIrIkjh3YZzB4TEgGe5SWAp3EVkSPalAr6uZuS+Fo3AXkSWRPlr/mdW1HB6Mk0jMOUtaQqJwF5El0TMwzPLmem5eVcuF8Sn6zl4sdpMqmsJdRJZEz0CcWEeEDZGa1GPNmCkkhbuIFFwi4RweiNMZjbCuNRk7OqlaWAp3ESm4E+cuMjo+RSzaRlOdcU17s06qFpjCXUQKLh3ksWhk+lbDMoWlcBeRgktfvJQO985ohHdOX+DShC5gLxSFu4gU3KGBOBval9HamLwoPhaNMJVwjgyNFLlllUvhLiIF1zsQJ9bRNv24M3UEr5OqhaNwF5GCGpuc4tj7o9OBDrBxZQsNdTX0DircC0XhLiIFdWRohKmET4+3A9TV1rBlTatmzBSQwl1ECio99LJ1bSRreywamT7RKuFTuItIQfUMxGmoq2Hjypas7Z3RCIPDY5xV4Y6CULiLSEH1DMS5fnUrdbXZcROLtk0/L+FTuItIQfUODGedTE2bmTGjoZlCULiLSMGkC3TE5gj3NZFGljfXa8ZMgSjcRaRgZi87kMnMiHVENCxTIAp3ESmYnv7kkMvWtW1zPt8ZjXB4QIU7CkHhLiIF0zsYZ3lzPWsijXM+37m2jdHxKU6cU+GOsM0b7mb2TTMbMrM3MrZ9xcx6zOw1M/u/ZrY847kHzOyImfWa2V0FareIlIF0gQ4zm/P59HCNhmbCt5Aj928Dd8/a9iRws7t/ADgMPABgZjcCO4GbUl/zZ2ZWG1prRaRsZBboCHJDh2bMFMq84e7uzwBnZm37R3efTD18Hlifun8PsM/dx9z9GHAEuC3E9opImcgs0BGktbGODe3LOKQj99DVhfAa/x74m9T9dSTDPq0vte0yZrYb2A3Q0dFBd3d3CE0pnpGRkbL/HsKk/shWjf1xYCh5/Heh/y26u49Ob5/dF6vqxjnw9kDV9U9aoX438gp3M/t9YBL4TnrTHLvNeRrc3fcAewC6urp8+/bt+TSl6Lq7uyn37yFM6o9s1dgfr+9/CzjMzl/66PQ67nB5X7w41suf//PbfOhnf47GuuobxS3U70bOs2XMbBfwCeDX3D0d4H3Ahozd1gMnc2+eiJSrnsHsAh1BVLijMHIKdzO7G/gi8El3v5Dx1OPATjNrNLNNwBbgx/k3U0TKzewCHUFUuKMwFjIV8rvAc0DMzPrM7DPA/wQiwJNm9oqZ/S8Ad38TeBg4CDwBfNbdVSRRpMrMVaAjyKZVLTTU1ijcQzbvmLu7/+ocm79xhf0fBB7Mp1EiUt7SBTo6184f7nW1NVyvwh2h0xWqIhK6nv5kUC/kyD29n47cw6VwF5HQ9Q7OXaAjSCwaYWD4EucuqHBHWBTuIhK6oAIdQbQMQfgU7iISuqACHUE6U1examgmPAp3EQnV2dHgAh1BOtoauWpZvY7cQ6RwF5FQpQO6M2AN97mYGbFoRAuIhUjhLiKhSgf0YoZlALZGIxweHGHmgnfJh8JdREI1X4GOILFoGyNjk/SdVeGOMCjcRSRU8xXoCBLTMgShUriLSGgWUqAjyMx0SI27h0HhLiKhSRfoWMzJ1LTWxjrWr1imGTMhUbiLSGgO9SePuhczDTKTliEIj8JdREKTDuZ0bdTFikUjHH1/lLFJLSabL4W7iIRmoQU6gsSibUwlnLeHRkNuWfVRuItIaBZaoCPI1vSMmUGdVM2Xwl1EQnFpIlmgY+sC1nAPsjFVuEMnVfOncBeRUKQLdOR6MhWgvraG69a06qRqCBTuIhKKdCDnMsc9U2c0Ml3sQ3KncBeRUCy2QEeQdOGO8xcmQmpZdVK4i0goFlugI4iuVA3HvD8FM/ummQ2Z2RsZ29rN7Ekzeyt1uyLjuQfM7IiZ9ZrZXYVquIiUlsUW6AjSOT1jRkMz+VjIR+y3gbtnbbsf2O/uW4D9qceY2Y3ATuCm1Nf8mZnVhtZaESlJ6QIdnXnMlEmLtjXR1lSnGTN5mjfc3f0Z4MyszfcAe1P39wL3Zmzf5+5j7n4MOALcFk5TRaRUpYM4Fs19jnuamdG5tk0zZvKU6+BYh7v3A6Ru16S2rwPey9ivL7VNRCpYrgU6gnRGIxweiKtwRx5yu0Y42FwLOM/50zGz3cBugI6ODrq7u0NuytIaGRkp++8hTOqPbJXeH0+/MUZLPRx86TkOzbOO+0L6ws5PEB+b5HtPPM2qZZU976NQvxu5hvugma11934zWwsMpbb3ARsy9lsPnJzrBdx9D7AHoKury7dv355jU0pDd3c35f49hEn9ka3S++NrB5/l5vU17NjxoXn3XUhfRN49w96Dz7H82pvYfmNHSK0sTYX63cj1I/FxYFfq/i7gsYztO82s0cw2AVuAH+fXRBEpZekCHVtzWMM9SHpVSc2Yyd28R+5m9l1gO7DKzPqALwEPAQ+b2WeA48CnANz9TTN7GDgITAKfdXet3SlSwfrOJgt05LPswGyRpnrWLVfhjnzMG+7u/qsBT90ZsP+DwIP5NEpEykf6YqMwwx3ShTt0IVOuKvtMhYgUXL4FOoLEohGOnhplfDIR6utWC4W7iOQl3wIdQWLRCJMJ5+1TI6G+brVQuItIXvIt0BEkfYJWFzPlRuEuIjkLo0BHkE2rWqivNZ1UzZHCXURyFkaBjiD1tTVct7pVq0PmSOEuIjkLq0BHkOSMGR2550LhLiI5C6tAR5BYtI3+8yrckQuFu4jkLKwCHUG0tnvuFO4ikrOe/uFQ1nAPkh7L18VMi6dwF5GcnB0dZyg+VrDxdoC1VzURUeGOnCjcRSQnYRboCGJmbI2qcEcuFO4ikpOwC3QEiaVmzKhwx+Io3EUkJ72DcZY317Mm0ljQ94lFI8THJjlx7mJB36fSKNxFJCc9A3E6oxFsnspL+ZqeMaOhmUVRuIvIoiUSTu9AnM4Cjren3ZAKd51UXRyFu4gsWt/Zi1wIuUBHkLZU4Q4duS+Owl1EFq1QBTqCxLQMwaIp3EVk0QpVoCNILBrh7VMjKtyxCAp3EVm0QhXoCNKZKtxx9H0V7lgohbuILFpP//CSnExNS7+XhmYWTuEuIotyaWKKd05fKPjFS5k2r04W7jjUr3BfqLzC3cx+28zeNLM3zOy7ZtZkZu1m9qSZvZW6XRFWY0Wk+ApZoCNIunCHFhBbuJzD3czWAb8JdLn7zUAtsBO4H9jv7luA/anHIlIhCl2gI4hmzCxOvsMydcAyM6sDmoGTwD3A3tTze4F783wPESkhhS7QESQWjXDy/CXOX1ThjoWwfBbjMbP7gAeBi8A/uvuvmdk5d1+esc9Zd79saMbMdgO7ATo6Om7dt29fzu0oBSMjI7S2tha7GSVD/ZGtkvrjj35yifiE858/vCynr8+1L14ZmuSrL4/xe7c3ccOK2pzeuxTl87uxY8eOl9y9a84n3T2nf8AK4ClgNVAPfB/4deDcrP3Ozvdat956q5e7p59+uthNKCnqj2yV1B//5r8+6b/9Nwdy/vpc+6Lv7AW/9os/8L987p2c37sU5fO7AbzoAbmaz7DMLwDH3P2Uu08AjwIfBgbNbC1A6nYoj/cQkRKyFAU6glydKtyhk6oLk0+4Hwe2mVmzJZeFuxM4BDwO7Ertswt4LL8mikipWIoCHUHMjE6dVF2wnC8vc/cXzOwR4GVgEjgA7AFagYfN7DMkPwA+FUZDRaT4lqpAR5BYNMJjr5zE3Qu+1HC5y+vaYXf/EvClWZvHSB7Fi0iF6RmIs2IJCnQEiUXbiF86zsnzl1i3PLcTutVCV6iKyIL1DMSJLUGBjiAzhTs07j4fhbuILEgi4RweXJoCHUHSq1CqcMf8FO4isiBLWaAjyFXL6rn6qiadVF0AhbuILMhSF+gIomUIFkbhLiILstQFOoJ0rm3j7VMjTEypcMeVKNxFZEF6BuJc0968ZAU6gnRGI0xMOUdPjRa1HaVO4S4iC9IzMFz0IRmYGRbq0YyZK1K4i8i8ilGgI8jmVa3U1ZhmzMxD4S4i8ypGgY4gDXXpwh0K9ytRuIvIvIpVoCOIZszMT+EuIvPqGRguSoGOILFohBPnLjJ8SYU7gijcRWRePQNxtqxppa62NCIj/RfEYR29ByqNn5SIlLTe1JoypaJzbXIJBJ1UDaZwF5ErKmaBjiAzhTsU7kEU7iJyRcUs0BHEzIh1RDTX/QoU7iJyRekA3VpCR+6QPKnaMxBP12qWWRTuInJFvakCHauLVKAjSGc0QvzSJP3nLxW7KSVJ4S4iV1TsAh1B0sNEGnefm8JdRAKVQoGOIDEV7rgihbuIBCqFAh1BrmquZ+1VTSq5FyCvcDez5Wb2iJn1mNkhM/uQmbWb2ZNm9lbqdkVYjRWRpVUqBTqCdKZOqsrl8j1y/xrwhLt3Aj8NHALuB/a7+xZgf+qxiJSh6WmQRS7QESQWVeGOIDmHu5m1AR8BvgHg7uPufg64B9ib2m0vcG9+TRSRYulNFehoKXKBjiAq3BHMcp0jamY/A+wBDpI8an8JuA844e7LM/Y76+6XDc2Y2W5gN0BHR8et+/bty6kdpWJkZITW1tZiN6NkqD+ylWt/PPCjC0Rbarjvg02hvWaYffFePMF/evYi/+EDjWy7ujQ/gOaTT3/s2LHjJXfvmvNJd8/pH9AFTAK3px5/DfgvwLlZ+52d77VuvfVWL3dPP/10sZtQUtQf2cqxPy6OT/rmB/7O/+iHPaG+bph9MTYx5dc98Hf+5X84FNprLrV8+gN40QNyNZ8x9z6gz91fSD1+BPggMGhmawFSt0N5vIeIFEkpFegI0lBXw+bVLZrrPoecw93dB4D3zCyW2nQnySGax4FdqW27gMfyaqGIFEXPdIGO0pvjnikWbdOMmTnkO0j1OeA7ZtYAHAU+TfID42Ez+wxwHPhUnu8hIkXQO12go7nYTbmizmiE//fqSeKXJog01Re7OSUjr3B391dIjr3Pdmc+rysixVdqBTqCpKdpHh6Mc+u17UVuTeko7Z+aiBRNqRXoCNK5VssQzEXhLiKXOVOCBTqCrFu+jEhjHT39CvdMCncRuUx62YFSP5kKycIdN0QjmjEzi8JdRC7TOz1TpvSP3CFduGNYhTsyKNxF5DKlWqAjSGc0wvClSQaGVbgjTeEuIpcp1QIdQbS2++UU7iKSpZQLdATpVFWmyyjcRSRLKRfoCHJVcz3RtiaFewaFu4hkOTQ9U6Z8wh2S8901LDND4S4iWdJHvzeUaIGOILFohLeHVLgjTeEuIllKvUBHkM5ohPGpBMfeV+EOULiLyCw9A8NlNd6eFutInlTV0EySwl1Epl2amOLY+6NlN94OcN2aFmprjN7UOYNqp3AXkWlHhkZIeHksOzBbY10tm1epcEeawl1EpqWHNMpxWAbSyxAo3EHhLiIZyqVAR5DOaIS+sxcZGZssdlOKTuEuItPKpUBHEF2pOqM8f4IiUhDlUqAjSLrtCneFu4ikpAt0bC3Dk6lp61cso7Wxbno9+mqmcBcRYKZARzkfuZsZN3S06qQqCncRSSm3Ah1BYtE2egfiVV+4I+9wN7NaMztgZj9IPW43syfN7K3U7Yr8mykihVZuBTqCdEYjnL84weDwWLGbUlRhHLnfBxzKeHw/sN/dtwD7U49FpMSVW4GOIOlhpWofd88r3M1sPfDLwNczNt8D7E3d3wvcm897iEjhlWOBjiCdmjEDQL7Lvn0V+AKQOUjX4e79AO7eb2Zr5vpCM9sN7Abo6Oigu7s7z6YU18jISNl/D2FSf2Qr9f4YupDgwvgUdv4k3d2nCvpeS9EXKxqNf371CDF/r6DvE4ZC9UfO4W5mnwCG3P0lM9u+2K939z3AHoCuri7fvn3RL1FSuru7KffvIUzqj2yl3h8/fHMAeIlPfrSLW64p7GmypeiLDxz9MafiY2zf/nMFfZ8wFKo/8jlyvwP4pJl9HGgC2szsr4FBM1ubOmpfCwyF0VARKZxyLdARpDMa4bm3TzMxlaC+TK+2zVfO37W7P+Du6919I7ATeMrdfx14HNiV2m0X8FjerRSRgirXAh1BYqnCHe9UceGOQnykPQR8zMzeAj6WeiwiJaxcC3QEmZkxU70nVUMJd3fvdvdPpO6fdvc73X1L6vZMGO8hIoWRLtCxtYLC/fo1ranCHQp3EalS6QIdsQqYBpnWWFfLplUtOnIXkepV7gU6gsSiEXoHq/dCJoW7SJUr9wIdQbZGI7x3pnoLdyjcRapcuRfoCJIeZjo8WJ1DM5X10xSRResZqIxlB2ZLL0PQ069wF5Eqc2Z0nFPxsbJf5ncu65Yvo6Whlt4qXUBM4S5SxSqhQEeQmhrjhmikamfMKNxFqlilFOgI0hmN0DtYnYU7FO4iVaxSCnQEiXVEOHdhgqF49RXuULiLVLFKKdARJD1jphqHZhTuIlWqkgp0BJkp3FF9J1UV7iJV6r2zF7gwPlWx4+0AK1oa6Ghr1JG7iFSPSl12YLZYtK0q57or3EWqVKUV6AjSGY1w5NQIk1OJYjdlSSncRapUpRXoCBLriDA+meCd09VVuEPhLlKlDg0MV/R4e1q1Fu5QuItUoUsTU7zz/mhVhHu1Fu5QuItUoUos0BGkqb6WjSubdeQuIpWvWmbKpHWubdORu4hUvkot0BGksyPC8TMXGK2iwh05h7uZbTCzp83skJm9aWb3pba3m9mTZvZW6nZFeM0VkTD0DMS5oaPyCnQESf+F0ltFhTvy+clOAr/j7luBbcBnzexG4H5gv7tvAfanHotICekZiBPrqPzx9rT0EgvVNDSTc7i7e7+7v5y6HwcOAeuAe4C9qd32Avfm2UYRCVElF+gIsn7FMpobaqsq3C2MdY7NbCPwDHAzcNzdl2c8d9bdLxuaMbPdwG6Ajo6OW/ft25d3O4ppZGSE1tbWYjejZKg/spVSfxw6PcWXf3KJ3+1q5OZVS38BU7H64g+eu0hDLdx/27Ilf+8ryac/duzY8ZK7d831XN4/WTNrBb4H/Ja7Dy906VB33wPsAejq6vLt27fn25Si6u7upty/hzCpP7KVUn8ce/YYcJB/94s/y5q2piV//2L1xROnX+OHbw7w0Y9+tKSWOC5Uf+R1NsXM6kkG+3fc/dHU5kEzW5t6fi0wlF8TRSRMlV6gI0gsGuHshQlOVUnhjnxmyxjwDeCQu/9xxlOPA7tS93cBj+XePBEJ26GB5BrupXT0uhSqbRmCfI7c7wB+A/h5M3sl9e/jwEPAx8zsLeBjqcciUgISCeetwXjVXLyUqdpmzOQ85u7u/wIEffTfmevrikjhVEOBjiDtLQ2siTRyqEqqMlXHFQwiAlTfsgOzxaKRqjlyV7iLVJFqKdARpDMa4a2h6ijcoXAXqSI9A8Ncu7LyC3QEiUXbUoU7LhS7KQWncBepIsllB6rzqB2YPtdQDUMzCneRKlFNBTqCXL+mlRpLropZ6RTuIlWimgp0BGmqr2XjqpaqmOuucM/T9w+c4I6HnuL1E+e546Gn+P6BE8Vuksicqn2mTNrWaFtVLP2rcM/D9w+c4IFHX+fEuYsAnDh3kQcefV0BLyWpp3+Yxioq0BEkFo3w7unKL9yhcM/Dl5/o4eLEFAD/Opi8nuvixBRf+WFvMZslMqfewThbqqhAR5D0Xy6HK/zovTrnQy3S5FRy6lTvQJyegWEO9cfpHRym//yl6X2eG6qdvn/i3EX+8O8Pcfvmdro2ttPWVF+MZotk6RmI85Etq4vdjKLLnDFzyzWVWyhO4T7L+yNj9A7EOdQ/TM9AnN6BOIcH44xNJi96qDHYvLqVD6xfzvkLEwxfSv5p97kbJ/kfB5Pd2VBbwzefPcb/fuYoNQY3XX0V2za3s23zSro2tnPVMoW9LK1qLNARZMOKZpobaiv+pGrVhvuliSmODI3QMxCnp3+Y3sE4h/rjvD8ysxzoqtZGOqMRfmPbtXSubaMzGuH6Na001SeP0tNj7hcnpmhIHbgvq6/lD3/lp7jrpigHjp/l+WNneP7oafb+67v8xY+OYQY3Xd3G7ZtWsm3zSm7b2M5VzQp7yV0i4Zy7mFzK9lR8jKH4pYz7yduT55Pnhar9ZCpATY2xpSPCkwcHGZtM0FhXQ32tUV9bQ0NdDfW1NaltNRnbbI5tmfsZDXU1NGQ8l95erNU3yzrcv3/gBF/5YS8nz13k6uXL+PxdMe69ZV3WPu5O39mLM0MqqaPxY++PMpVIVqFqrKvhho4I22Or6YxG2Lq2jVg0wqrWK693nX6v5Bh7nHWz2vDh61fx4etXAckPkwPHz/H80dO8cOw0f/X8u3zjX5JhvzXaxu2pI/vbNrazoqUh5J6ScnRpYiojoC8P7FMjydv3R8aYmLq8otqy+lrWtDWyurWRm65u4+6bo9y+ub0I30npufdnruYvnjnKkwcHmZhKMD6ZYGIqwWQi/8p0szVkhH/6g6Eh40NiY+M4hahdUrbhnnnUDMlx7vu/9xpHT42wuq0peTSeCvJ4xlnxDe3LiHW08Us3R+mMJkN848rmnE8y3XvLOu69ZR3d3d187te2B+7XVF/Lh65byYeuWwkk/+O++t45nj96hheOneb/vHCcbz37DpAcE9y2eSXbNrdz26aVtCvsK0Yi4Zy5MJ4d0rOPuEfGODU8lvV7m1ZjsLI1Gdhr2hqJdURYHWlkdaSRNZGm6furI420VukSAwvx6Ts28ek7Nl22PZFwxqcSGYHvTEwlGJtMZH0IjGc8f/m2mX3HM56f2Za5n9OYKMxSCGX70//KD3ungz3t0mSC//7UEQAiTXVsjbZx7y3r6FwboTPaxg0drURK5ORmU30tt29eye2bVwJbGJuc4tX3zvPC0dM8f+w0+35ynG//6zsAxDoiM0f2m9rn/YtClo67M3xxkjMXxjkzOsaZ0QnOjI5xenScs6PjnB4d58zoOMf6L3Lx2X/i9Oj49F+MmVob66ZDeevaNj6yJR3YjVmBvbKlkdqa6iqysZRqaoymmtrpodel0N3dXZDXLdtwP5maWz6XZ+//ea6+qqmsKs001tVy26Z2btvUzufYwvhkgtf6zvFCasz+b1/s4y+fexeALWta2bZ5Jbdvbuf2TStZHWlc0BDVUki3Y+eGOL//0FNFb8di+2N8MsHZC+OcHhlP3maE9NlUUKf/nR4d59yF8cA/5ZfV19Le0kB7SwPLG41t165JBnZqqCQztJsbyva/opSosv2Nunr5sumLhzKtW76MdctLq7p5LhrqaujamJxK+dkd1zMxleC1vvO8cOw0zx89w/de7uOvnk+G/ZpIY9YR4YlzF/ni917jzOg4d98cpbbGMINaM2rS/2qgxmz6uRozai15P9cPxayhsg0zF3UBSxrwcw3ZffGR13jz5Hm2dESmQzoruC+Mc2ZkfM6hEAAzWL6snhUtDaxsaWDjqmY+eO1y2lsaWNHcwMrWBtpbGmlvbqC9tYH25gaWNcwc/SWLIH9gSb5/ESjjcP/8XbGs/8CQPFL6/F2xIraqcOpra7j12hXceu0K/uN2mJhK8MaJ87xw7Ax/8uThy/7UH5tM8Ac/OMgf/ODgot+rJhX2WR8CqeCvqUnfN2prsvc7ee7SdDu+dTgZbBcnpvidv32Vr/7TYRIOjuNO6p/jpO7jyecdSO2TyHzeU1/HzNclMraRsf9cwx5jUwn+4kfHph831NWwMiOYr13ZnLzf0jAd4O0Z/5Y3N2g4RMpK2YZ75kyVYg9FFEN9bQ23XLOCW65ZwZf/oSdwv4d+5adIOEy54+5MJdIhOnM/4U4idX/e/VL/phJctt+jZ2aWXVjV5JwZS4bhVML56Q3LMZJ/FUzfGqn7yQ+J5B8M6b8kwMjcJ30/4/nUa5HantwGf/r024H98aMv7KC9pYHmhtqyGrYTWayyDXeYmalS7a40RLXztmuWrB0vHDsz3Y5/e02C//Z6zXQ7vrbzliVrx/cPnAzsjw3t1b2uilSP6l5kokJ8/q4Yy2ad3S/GEJXaIVI6CnbkbmZ3A18DaoGvu/tDhXqvalcqQ1TzXdRVjHZU45CdCBQo3M2sFvhT4GNAH/ATM3vc3Rd/dk8WpFSGqBZ6UddStUOkWhVqWOY24Ii7H3X3cWAfcE+B3ktERGYp1LDMOuC9jMd9wO2ZO5jZbmA3QEdHR8Gu0loqIyMjZf89hEn9kU39MUN9ka1Q/VGocJ9rjlnW5GN33wPsAejq6vLthVg5ZwklL1LZXuxmlAz1Rzb1xwz1RbZC9UehhmX6gA0Zj9cDJwv0XiIiMkuhwv0nwBYz22RmDcBO4PECvZeIiMxi7uGvXwxgZh8HvkpyKuQ33f3BK+x7Cni3IA1ZOquA94vdiBKi/sim/pihvsiWT39c6+5z1k4sWLhXGzN70d27it2OUqH+yKb+mKG+yFao/tAVqiIiFUjhLiJSgRTu4dlT7AaUGPVHNvXHDPVFtoL0h8bcRUQqkI7cRUQqkMJdRKQCKdzzZGYbzOxpMztkZm+a2X3FblOxmVmtmR0wsx8Uuy3FZmbLzewRM+tJ/Y58qNhtKiYz++3U/5M3zOy7ZtZU7DYtJTP7ppkNmdkbGdvazexJM3srdbsijPdSuOdvEvgdd98KbAM+a2Y3FrlNxXYfcKjYjSgRXwOecPdO4Kep4n4xs3XAbwJd7n4zyQscdxa3VUvu28Dds7bdD+x39y3A/tTjvCnc8+Tu/e7+cup+nOR/3qpdSNzM1gO/DHy92G0pNjNrAz4CfAPA3cfd/VxRG1V8dcAyM6sDmqmyNafc/RngzKzN9wB7U/f3AveG8V4K9xCZ2UbgFuCFIjelmL4KfAFIFLkdpWAzcAr4VmqY6utm1lLsRhWLu58A/gg4DvQD5939H4vbqpLQ4e79kDxYBNaE8aIK95CYWSvwPeC33H242O0pBjP7BDDk7i8Vuy0log74IPDn7n4LMEpIf3KXo9RY8j3AJuBqoMXMfr24rapcCvcQmFk9yWD/jrs/Wuz2FNEdwCfN7B2S1bd+3sz+urhNKqo+oM/d03/JPUIy7KvVLwDH3P2Uu08AjwIfLnKbSsGgma0FSN0OhfGiCvc8mZmRHFM95O5/XOz2FJO7P+Du6919I8kTZU+5e9Uembn7APCemcVSm+4EqrmO8HFgm5k1p/7f3EkVn2DO8DiwK3V/F/BYGC9aqEpM1eQO4DeA183sldS233P3vy9ek6SEfA74TqquwVHg00VuT9G4+wtm9gjwMslZZgeosqUIzOy7wHZglZn1AV8CHgIeNrPPkPwA/FQo76XlB0REKo+GZUREKpDCXUSkAincRUQqkMJdRKQCKdxFRCqQwl1EpAIp3EVEKtD/B+n5ZoM1FXlZAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(1, 11, 1)\n", + "y = function(x)\n", + "\n", + "plt.grid()\n", + "plt.plot(x, y)\n", + "plt.scatter(x[:len(x)//2], y[:len(x)//2])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3abb52c1", + "metadata": {}, + "source": [ + "4.3.3 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b4763e0b-af25-4f52-b6f0-6f8461eeb686", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numpy import trapz" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0e8d1e51-9c2c-495d-bb97-0462401e6c36", + "metadata": {}, + "outputs": [], + "source": [ + "def funtion2(x):\n", + " return abs(np.cos(x * np.e ** (np.cos(x) + np.log(x + 1))))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "55b31fe0", + "metadata": {}, + "outputs": [], + "source": [ + "x = np.arange(0, 11, 1)\n", + "y = funtion2(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "898021c3-9fd5-4328-bbe1-d23c3cc004dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.grid()\n", + "plt.plot(x, y)\n", + "plt.fill_between(x, y)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "7a18f9fa-0283-4c42-a7f4-9724ea606def", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.748183214657723\n" + ] + } + ], + "source": [ + "area = trapz(y)\n", + "print(area)" + ] + }, + { + "cell_type": "markdown", + "id": "984e6926", + "metadata": {}, + "source": [ + "4.3.4 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c5227063-0e66-4e3d-a867-65b7a939ad2f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numpy import trapz" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "06b78197-20da-49e8-a625-059bfa571add", + "metadata": {}, + "outputs": [], + "source": [ + "apple_share = [132, 135, 145, 147, 124, 139, 149, 151, 141, 149, 148, 177]\n", + "google_share = [1727, 1783, 2000, 2242, 2360, 2427, 2597, 2750, 2794, 2761, 2901, 2934]\n", + "microsoft_share = [217, 239, 236, 242, 251, 247, 271, 284, 301, 289, 329, 330] " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "afdf47d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(1, 13, 1)\n", + "\n", + "plt.grid()\n", + "plt.plot(x, apple_share, label=\"apple\")\n", + "plt.plot(x, microsoft_share, label=\"microsoft\")\n", + "plt.plot(x, google_share, label=\"google\")\n", + "plt.title(\"График цен акций\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2b385688", + "metadata": {}, + "source": [ + "4.3.5 Задание" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0e1778ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Чтобы выйти из программы введите exit\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Введите (+, -, *, /, **, e, sin, cos): exit\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Программа завершена\n" + ] + } + ], + "source": [ + "import math as m\n", + "\n", + "print(\"Чтобы выйти из программы введите exit\")\n", + "\n", + "while True:\n", + " user_input = input(\"Введите (+, -, *, /, **, e, sin, cos): \")\n", + " if user_input == \"exit\":\n", + " break \n", + " elif user_input in ['+', '-', '*', '/', '**', 'e', 'sin', 'cos']:\n", + " x = float(input(\"x = \"))\n", + " y = float(input(\"y = \"))\n", + " \n", + " if user_input == 'e':\n", + " print(\"e ** (x + y) = \", m.e**(x + y))\n", + " elif user_input == 'sin':\n", + " print(\"sin(x + y) =\", m.sin(x + y))\n", + " elif user_input == 'cos':\n", + " print(\"cos(x + y) =\", m.cos(x + y))\n", + " else:\n", + " formula = f\"{x} {user_input} {y}\"\n", + " print(formula, \"=\", eval(formula))\n", + " else:\n", + " print(\"Неверный знак операции!\")\n", + "\n", + "print(\"Программа завершена\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fda3145", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "vscode": { + "interpreter": { + "hash": "c8e7b8a5fb18722c706c80178f617ac0f7a16c4b5a7c63b4b737eecf7a54cfec" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Third term/Artificial intelligence systems and big data/2.ipynb b/Third term/Artificial intelligence systems and big data/2.ipynb new file mode 100644 index 0000000..972482f --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/2.ipynb @@ -0,0 +1,1389 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Рабочая тетрадь № 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd \n", + "from sklearn.preprocessing import MinMaxScaler, StandardScaler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.1 Задание \n", + "\n", + "Создать 8x8 матрицу и заполнить её в шахматном порядке нулями и \n", + "единицами." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 0, 1, 0, 1, 0, 1],\n", + " [1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1],\n", + " [1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1],\n", + " [1, 0, 1, 0, 1, 0, 1, 0],\n", + " [0, 1, 0, 1, 0, 1, 0, 1],\n", + " [1, 0, 1, 0, 1, 0, 1, 0]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([[(x + y) % 2 for x in range(8)] for y in range(8)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.2 Задание\n", + "\n", + "Создать 5x5 матрицу со значениями в строках от 0 до 4. Для создания \n", + "необходимо использовать функцию arrange. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([np.arange(0, 5) for _ in range(5)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.3 Задание\n", + "\n", + "Создать массив 3x3x3 со случайными значениями. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.34392799, 0.718808 , 0.49594499],\n", + " [0.12167775, 0.56056024, 0.59003049],\n", + " [0.12481231, 0.79707319, 0.66605017]],\n", + "\n", + " [[0.11550937, 0.29438156, 0.69728858],\n", + " [0.3432886 , 0.35701781, 0.72659151],\n", + " [0.73779222, 0.09585279, 0.40705831]],\n", + "\n", + " [[0.23874481, 0.80360945, 0.53127737],\n", + " [0.85959837, 0.16119215, 0.78824553],\n", + " [0.53977056, 0.71800074, 0.93729907]]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.random((3, 3, 3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.4 Задание\n", + "\n", + "Создать матрицу с 0 внутри, и 1 на границах." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 1, 1, 1, 1, 1, 1, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0, 0, 1],\n", + " [1, 1, 1, 1, 1, 1, 1, 1]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([[int((x in [0, 7]) or (y in [0, 7])) for x in range(8)] for y in range(8)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.5 Задание\n", + "\n", + "Создайте массив и отсортируйте его по убыванию. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr = np.arange(0, 10)\n", + "np.sort(arr)[::-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.6 Задание\n", + "\n", + "Создайте матрицу, выведите ее форму, размер и размерность." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(8, 10) 2 80\n" + ] + } + ], + "source": [ + "arr = np.array([np.arange(0, 10) for _ in range(8)])\n", + "\n", + "print(arr.shape, arr.ndim, arr.size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.1 Задание\n", + "\n", + "Найди евклидово расстояние между двумя Series (точками) a и b, не \n", + "используя встроенную формулу." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1622776601683795\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "\n", + "first_dot = pd.Series([1, 3])\n", + "second_dot = pd.Series([4, 2])\n", + "\n", + "s = 0\n", + "for dim in range(first_dot.size):\n", + " s += (first_dot.array[dim] - second_dot.array[dim]) ** 2\n", + "\n", + "print(sqrt(s))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.2 Задание \n", + "\n", + "Найдите в Интернете ссылку на любой csv файл и сформируйте из него \n", + "фрейм данных (например, коллекцию фреймов данных можно найти \n", + "здесь: https://github.com/akmand/datasets)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightAirportFromAirportToDayOfWeekTimeLengthDelay
0CO269SFOIAH3152051
1US1558PHXCLT3152221
2AA2400LAXDFW3201651
3AA2466SFODFW3201951
4AS108ANCSEA3302020
...........................
539378CO178OGGSNA514393260
539379FL398SEAATL514393050
539380FL609SFOMKE514392550
539381UA78HNLSFO514393131
539382US1442LAXPHL514393011
\n", + "

539383 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " Airline Flight AirportFrom AirportTo DayOfWeek Time Length Delay\n", + "0 CO 269 SFO IAH 3 15 205 1\n", + "1 US 1558 PHX CLT 3 15 222 1\n", + "2 AA 2400 LAX DFW 3 20 165 1\n", + "3 AA 2466 SFO DFW 3 20 195 1\n", + "4 AS 108 ANC SEA 3 30 202 0\n", + "... ... ... ... ... ... ... ... ...\n", + "539378 CO 178 OGG SNA 5 1439 326 0\n", + "539379 FL 398 SEA ATL 5 1439 305 0\n", + "539380 FL 609 SFO MKE 5 1439 255 0\n", + "539381 UA 78 HNL SFO 5 1439 313 1\n", + "539382 US 1442 LAX PHL 5 1439 301 1\n", + "\n", + "[539383 rows x 8 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/akmand/datasets/refs/heads/main/airlines.csv'\n", + "\n", + "df = pd.read_csv(url)\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.3 Задание\n", + "\n", + "Проделайте с получившемся из предыдущего задания фреймом данных \n", + "те же действия, что и в примерах 2.2.5-2.2.7. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.5\n", + "\n", + "Пронализировать характеристики фрейма данных." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightAirportFromAirportToDayOfWeekTimeLengthDelay
0CO269SFOIAH3152051
1US1558PHXCLT3152221
\n", + "
" + ], + "text/plain": [ + " Airline Flight AirportFrom AirportTo DayOfWeek Time Length Delay\n", + "0 CO 269 SFO IAH 3 15 205 1\n", + "1 US 1558 PHX CLT 3 15 222 1" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightAirportFromAirportToDayOfWeekTimeLengthDelay
539380FL609SFOMKE514392550
539381UA78HNLSFO514393131
539382US1442LAXPHL514393011
\n", + "
" + ], + "text/plain": [ + " Airline Flight AirportFrom AirportTo DayOfWeek Time Length Delay\n", + "539380 FL 609 SFO MKE 5 1439 255 0\n", + "539381 UA 78 HNL SFO 5 1439 313 1\n", + "539382 US 1442 LAX PHL 5 1439 301 1" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(539383, 8)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FlightDayOfWeekTimeLengthDelay
count539383.000000539383.000000539383.000000539383.000000539383.000000
mean2427.9286303.929668802.728963132.2020070.445442
std2067.4298371.914664278.04591170.1170160.497015
min1.0000001.00000010.0000000.0000000.000000
25%712.0000002.000000565.00000081.0000000.000000
50%1809.0000004.000000795.000000115.0000000.000000
75%3745.0000005.0000001035.000000162.0000001.000000
max7814.0000007.0000001439.000000655.0000001.000000
\n", + "
" + ], + "text/plain": [ + " Flight DayOfWeek Time Length \n", + "count 539383.000000 539383.000000 539383.000000 539383.000000 \\\n", + "mean 2427.928630 3.929668 802.728963 132.202007 \n", + "std 2067.429837 1.914664 278.045911 70.117016 \n", + "min 1.000000 1.000000 10.000000 0.000000 \n", + "25% 712.000000 2.000000 565.000000 81.000000 \n", + "50% 1809.000000 4.000000 795.000000 115.000000 \n", + "75% 3745.000000 5.000000 1035.000000 162.000000 \n", + "max 7814.000000 7.000000 1439.000000 655.000000 \n", + "\n", + " Delay \n", + "count 539383.000000 \n", + "mean 0.445442 \n", + "std 0.497015 \n", + "min 0.000000 \n", + "25% 0.000000 \n", + "50% 0.000000 \n", + "75% 1.000000 \n", + "max 1.000000 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.6\n", + "\n", + "Выберите индивидуальные данные или срезы фрейма данных." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightAirportFromAirportToDayOfWeekTimeLengthDelay
1US1558PHXCLT3152221
2AA2400LAXDFW3201651
3AA2466SFODFW3201951
\n", + "
" + ], + "text/plain": [ + " Airline Flight AirportFrom AirportTo DayOfWeek Time Length Delay\n", + "1 US 1558 PHX CLT 3 15 222 1\n", + "2 AA 2400 LAX DFW 3 20 165 1\n", + "3 AA 2466 SFO DFW 3 20 195 1" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.iloc[1:4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.7\n", + "\n", + "Требуется отобрать строки фрейма данных на основе некоторого \n", + "условия." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightAirportFromAirportToDayOfWeekTimeLengthDelay
1US1558PHXCLT3152221
15US498DENCLT3551790
\n", + "
" + ], + "text/plain": [ + " Airline Flight AirportFrom AirportTo DayOfWeek Time Length Delay\n", + "1 US 1558 PHX CLT 3 15 222 1\n", + "15 US 498 DEN CLT 3 55 179 0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['Airline'] == 'US'].head(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3.2 Задание\n", + "\n", + "Загрузить фрейм данных по ссылке: \n", + "https://raw.githubusercontent.com/akmand/datasets/master/iris.csv. \n", + "Необходимо выполнить нормализацию первого числового признака \n", + "(sepal_length_cm) с использованием минимаксного преобразования, а \n", + "второго (sepal_width_cm) с задействованием z-масштабирования. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_length_cmsepal_width_cmpetal_length_cmpetal_width_cmspecies
05.13.51.40.2setosa
14.93.01.40.2setosa
24.73.21.30.2setosa
34.63.11.50.2setosa
45.03.61.40.2setosa
..................
1456.73.05.22.3virginica
1466.32.55.01.9virginica
1476.53.05.22.0virginica
1486.23.45.42.3virginica
1495.93.05.11.8virginica
\n", + "

150 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " sepal_length_cm sepal_width_cm petal_length_cm petal_width_cm \n", + "0 5.1 3.5 1.4 0.2 \\\n", + "1 4.9 3.0 1.4 0.2 \n", + "2 4.7 3.2 1.3 0.2 \n", + "3 4.6 3.1 1.5 0.2 \n", + "4 5.0 3.6 1.4 0.2 \n", + ".. ... ... ... ... \n", + "145 6.7 3.0 5.2 2.3 \n", + "146 6.3 2.5 5.0 1.9 \n", + "147 6.5 3.0 5.2 2.0 \n", + "148 6.2 3.4 5.4 2.3 \n", + "149 5.9 3.0 5.1 1.8 \n", + "\n", + " species \n", + "0 setosa \n", + "1 setosa \n", + "2 setosa \n", + "3 setosa \n", + "4 setosa \n", + ".. ... \n", + "145 virginica \n", + "146 virginica \n", + "147 virginica \n", + "148 virginica \n", + "149 virginica \n", + "\n", + "[150 rows x 5 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/akmand/datasets/master/iris.csv'\n", + "\n", + "iris_df = pd.read_csv(url)\n", + "\n", + "iris_df" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "length_feature = np.array(iris_df['sepal_length_cm']).reshape(-1,1)\n", + "\n", + "minmax_scale = MinMaxScaler(feature_range = (0, 1))\n", + "scaled_sepal_length = minmax_scale.fit_transform(length_feature)\n", + "iris_df['sepal_length_cm'] = scaled_sepal_length;" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "width_feature = np.array(iris_df['sepal_width_cm']).reshape(-1,1)\n", + "\n", + "z_scale = StandardScaler()\n", + "scaled_sepal_width = z_scale.fit_transform(width_feature)\n", + "iris_df['sepal_width_cm'] = scaled_sepal_width" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_length_cmsepal_width_cmpetal_length_cmpetal_width_cmspecies
00.2222221.0320571.40.2setosa
10.166667-0.1249581.40.2setosa
20.1111110.3378481.30.2setosa
30.0833330.1064451.50.2setosa
40.1944441.2634601.40.2setosa
..................
1450.666667-0.1249585.22.3virginica
1460.555556-1.2819725.01.9virginica
1470.611111-0.1249585.22.0virginica
1480.5277780.8006545.42.3virginica
1490.444444-0.1249585.11.8virginica
\n", + "

150 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " sepal_length_cm sepal_width_cm petal_length_cm petal_width_cm \n", + "0 0.222222 1.032057 1.4 0.2 \\\n", + "1 0.166667 -0.124958 1.4 0.2 \n", + "2 0.111111 0.337848 1.3 0.2 \n", + "3 0.083333 0.106445 1.5 0.2 \n", + "4 0.194444 1.263460 1.4 0.2 \n", + ".. ... ... ... ... \n", + "145 0.666667 -0.124958 5.2 2.3 \n", + "146 0.555556 -1.281972 5.0 1.9 \n", + "147 0.611111 -0.124958 5.2 2.0 \n", + "148 0.527778 0.800654 5.4 2.3 \n", + "149 0.444444 -0.124958 5.1 1.8 \n", + "\n", + " species \n", + "0 setosa \n", + "1 setosa \n", + "2 setosa \n", + "3 setosa \n", + "4 setosa \n", + ".. ... \n", + "145 virginica \n", + "146 virginica \n", + "147 virginica \n", + "148 virginica \n", + "149 virginica \n", + "\n", + "[150 rows x 5 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iris_df" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Third term/Artificial intelligence systems and big data/3.ipynb b/Third term/Artificial intelligence systems and big data/3.ipynb new file mode 100644 index 0000000..a53c7c3 --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/3.ipynb @@ -0,0 +1,964 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Рабочая тетрадь No 3" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.feature_extraction import DictVectorizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.1 Задание\n", + "\n", + "Задайте 4 точки в трехмерном пространстве, рассчитайте между ними \n", + "расстояния по описанным в примере выше метрикам. Отобразите точки \n", + "в трехмерном пространстве." + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "first_dot = np.array([np.random.randint(10) for _ in range(3)])\n", + "second_dot = np.array([np.random.randint(10) for _ in range(3)])\n", + "third_dot = np.array([np.random.randint(10) for _ in range(3)])\n", + "fourth_dot = np.array([np.random.randint(10) for _ in range(3)])\n", + "\n", + "dots = [first_dot, second_dot, third_dot, fourth_dot]" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6 9 3] [2 3 5]\n", + "Расстояние Евклида 7.483314773547883\n", + "Квадрат Евклидова расстояния 56.0\n", + "Расстояние Чебышева 6.0\n", + "Расстояние Хемминга 12.0\n", + "\n", + "[6 9 3] [5 7 5]\n", + "Расстояние Евклида 3.0\n", + "Квадрат Евклидова расстояния 9.0\n", + "Расстояние Чебышева 2.0\n", + "Расстояние Хемминга 5.0\n", + "\n", + "[6 9 3] [3 7 5]\n", + "Расстояние Евклида 4.123105625617661\n", + "Квадрат Евклидова расстояния 17.0\n", + "Расстояние Чебышева 3.0\n", + "Расстояние Хемминга 7.0\n", + "\n", + "[2 3 5] [6 9 3]\n", + "Расстояние Евклида 7.483314773547883\n", + "Квадрат Евклидова расстояния 56.0\n", + "Расстояние Чебышева 6.0\n", + "Расстояние Хемминга 12.0\n", + "\n", + "[2 3 5] [5 7 5]\n", + "Расстояние Евклида 5.0\n", + "Квадрат Евклидова расстояния 25.0\n", + "Расстояние Чебышева 4.0\n", + "Расстояние Хемминга 7.0\n", + "\n", + "[2 3 5] [3 7 5]\n", + "Расстояние Евклида 4.123105625617661\n", + "Квадрат Евклидова расстояния 17.0\n", + "Расстояние Чебышева 4.0\n", + "Расстояние Хемминга 5.0\n", + "\n", + "[5 7 5] [6 9 3]\n", + "Расстояние Евклида 3.0\n", + "Квадрат Евклидова расстояния 9.0\n", + "Расстояние Чебышева 2.0\n", + "Расстояние Хемминга 5.0\n", + "\n", + "[5 7 5] [2 3 5]\n", + "Расстояние Евклида 5.0\n", + "Квадрат Евклидова расстояния 25.0\n", + "Расстояние Чебышева 4.0\n", + "Расстояние Хемминга 7.0\n", + "\n", + "[5 7 5] [3 7 5]\n", + "Расстояние Евклида 2.0\n", + "Квадрат Евклидова расстояния 4.0\n", + "Расстояние Чебышева 2.0\n", + "Расстояние Хемминга 2.0\n", + "\n", + "[3 7 5] [6 9 3]\n", + "Расстояние Евклида 4.123105625617661\n", + "Квадрат Евклидова расстояния 17.0\n", + "Расстояние Чебышева 3.0\n", + "Расстояние Хемминга 7.0\n", + "\n", + "[3 7 5] [2 3 5]\n", + "Расстояние Евклида 4.123105625617661\n", + "Квадрат Евклидова расстояния 17.0\n", + "Расстояние Чебышева 4.0\n", + "Расстояние Хемминга 5.0\n", + "\n", + "[3 7 5] [5 7 5]\n", + "Расстояние Евклида 2.0\n", + "Квадрат Евклидова расстояния 4.0\n", + "Расстояние Чебышева 2.0\n", + "Расстояние Хемминга 2.0\n", + "\n" + ] + } + ], + "source": [ + "for first in dots:\n", + " for second in dots:\n", + " if (first == second).all():\n", + " continue\n", + "\n", + " print(first, second)\n", + " print('Расстояние Евклида', np.linalg.norm(first-second))\n", + " print('Квадрат Евклидова расстояния', np.linalg.norm(first-second) ** 2)\n", + " print('Расстояние Чебышева', np.linalg.norm(first-second, ord=np.inf))\n", + " print('Расстояние Хемминга', np.linalg.norm(first-second, ord=1))\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "for dot in dots:\n", + " ax.scatter(*dot)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.2 Задание\n", + "\n", + "Создать 5x5 матрицу со значениями в строках от 0 до 4. Для создания \n", + "необходимо использовать функцию arange." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4],\n", + " [0, 1, 2, 3, 4]])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([np.arange(0, 5) for _ in range(5)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3.1 Задание\n", + "\n", + "Для предыдущего примера поэкспериментируйте с параметрами классификатора: \n", + "1. Установите другое количество ближайших соседей (k = 1, 5, 10). \n", + "2. Установите размер тестовой выборки 15% от всего датасета. \n", + "3. Постройте графики и оцените качество моделей, проанализируйте результаты. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.1\n", + "\n", + "В примере показано создание 2d-массива со значениями x и y. Список \n", + "target содержит возможные выходные классы (часто называемые \n", + "метками). Далее происходит обучене классификатора k-ближайших \n", + "соседей по исходным данным. Далее производится прогноз \n", + "принадлежности к классам для двух точек данных." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KNeighborsClassifier(n_neighbors=3)\n", + "(-2,-2) is class [0]\n", + "(1,3) is class [1]\n" + ] + } + ], + "source": [ + "# данные\n", + "X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])\n", + "target = [0, 0, 0, 1, 1, 1]\n", + "\n", + "# обучаем модель k-ближайших соседей к данным\n", + "K = 3\n", + "model = KNeighborsClassifier(n_neighbors=K)\n", + "model.fit(X, target)\n", + "print(model)\n", + "\n", + "# делаем прогноз\n", + "print('(-2,-2) is class', model.predict([[-2, -2]]))\n", + "print('(1,3) is class', model.predict([[1, 3]]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.2\n", + "\n", + "Далее приведем более наглядный пример. Будет построена граница \n", + "решения для каждого класса. В качестве данных будем использовать уже \n", + "знакомый нам и встроенный в библиотеку sklearn набор данных ирисов \n", + "Фишера. Этот набор данных стал уже классическим, и часто используется \n", + "в литературе для иллюстрации работы различных статистических \n", + "алгоритмов. Датасет содержит наблюдения за 150 разными цветками \n", + "ирисов, данные по каждому цветку расположены в строках. В стобцах \n", + "записаны длина и ширина чашелистика, длина и ширина лепестка, вид \n", + "ириса. " + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_length_cmsepal_width_cmpetal_length_cmpetal_width_cmspecies
05.13.51.40.2setosa
14.93.01.40.2setosa
24.73.21.30.2setosa
34.63.11.50.2setosa
45.03.61.40.2setosa
..................
1456.73.05.22.3virginica
1466.32.55.01.9virginica
1476.53.05.22.0virginica
1486.23.45.42.3virginica
1495.93.05.11.8virginica
\n", + "

150 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " sepal_length_cm sepal_width_cm petal_length_cm petal_width_cm \n", + "0 5.1 3.5 1.4 0.2 \\\n", + "1 4.9 3.0 1.4 0.2 \n", + "2 4.7 3.2 1.3 0.2 \n", + "3 4.6 3.1 1.5 0.2 \n", + "4 5.0 3.6 1.4 0.2 \n", + ".. ... ... ... ... \n", + "145 6.7 3.0 5.2 2.3 \n", + "146 6.3 2.5 5.0 1.9 \n", + "147 6.5 3.0 5.2 2.0 \n", + "148 6.2 3.4 5.4 2.3 \n", + "149 5.9 3.0 5.1 1.8 \n", + "\n", + " species \n", + "0 setosa \n", + "1 setosa \n", + "2 setosa \n", + "3 setosa \n", + "4 setosa \n", + ".. ... \n", + "145 virginica \n", + "146 virginica \n", + "147 virginica \n", + "148 virginica \n", + "149 virginica \n", + "\n", + "[150 rows x 5 columns]" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/akmand/datasets/master/iris.csv'\n", + "\n", + "iris = pd.read_csv(url)\n", + "\n", + "iris" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Объявляем фигуру из двух графиков и ее размер \n", + "plt.figure(figsize=(16, 7))\n", + "\n", + "# Левый график\n", + "plt.subplot(121)\n", + "sns.scatterplot(\n", + " data=iris, # из этой таблицы нарисовать точки\n", + " x='petal_width_cm', y='petal_length_cm', # с этими координатами,\n", + " hue='species', # для которых цвет определить согласно этому столбцу \n", + " s=70 # размер точек\n", + ")\n", + "plt.xlabel('Длина лепестка, см') \n", + "plt.ylabel('Ширина лепестка, см') \n", + "plt.legend() # добавить легенду \n", + "plt.grid() # добавить сетку\n", + "\n", + "# Правый график аналогично \n", + "plt.subplot(122)\n", + "sns.scatterplot(data=iris,\n", + "x='sepal_width_cm', y='sepal_length_cm', hue='species', s=70)\n", + "plt.xlabel('Длина чашелистика, см') \n", + "plt.ylabel('Ширина чашелистика, см') \n", + "plt.legend()\n", + "plt.grid();" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((127, 4), (23, 4), (127,), (23,))" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(\n", + " # поскольку iris это pandas-таблица, для нее нужно указывать iloc\n", + " iris.iloc[:, :-1], # берем все колонки кроме последней в признаки\n", + " iris.iloc[:, -1], # последнюю в целевую переменную (класс)\n", + " test_size=0.15 # размер тестовой выборки 15%\n", + ")\n", + "\n", + "X_train.shape, X_test.shape, y_train.shape, y_test.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_length_cmsepal_width_cmpetal_length_cmpetal_width_cm
145.84.01.20.2
55.43.91.70.4
165.43.91.30.4
945.62.74.21.3
1227.72.86.72.0
\n", + "
" + ], + "text/plain": [ + " sepal_length_cm sepal_width_cm petal_length_cm petal_width_cm\n", + "14 5.8 4.0 1.2 0.2\n", + "5 5.4 3.9 1.7 0.4\n", + "16 5.4 3.9 1.3 0.4\n", + "94 5.6 2.7 4.2 1.3\n", + "122 7.7 2.8 6.7 2.0" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14 setosa\n", + "5 setosa\n", + "16 setosa\n", + "94 versicolor\n", + "122 virginica\n", + "Name: species, dtype: object" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обучим метод 1 ближайшем соседе" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['versicolor', 'versicolor', 'virginica', 'versicolor',\n", + " 'versicolor', 'versicolor', 'setosa', 'versicolor', 'versicolor',\n", + " 'virginica', 'virginica', 'virginica', 'setosa', 'setosa',\n", + " 'versicolor', 'setosa', 'versicolor', 'versicolor', 'virginica',\n", + " 'virginica', 'setosa', 'virginica', 'setosa'], dtype=object)" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = KNeighborsClassifier(n_neighbors=1)\n", + "model.fit(X_train, y_train)\n", + "\n", + "# Получим предсказания модели\n", + "y_pred = model.predict(X_test)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Покажем на графике, что отражаем полученное число.\n", + "# Красным цветом обозначим точки, для которых классификация сработала неправильно.\n", + "plt.figure(figsize=(10, 7))\n", + "sns.scatterplot(x='petal_width_cm', y='petal_length_cm', data=iris, hue='species', s=70)\n", + "plt.xlabel('Длина лепестка, см')\n", + "plt.ylabel('Ширина лепестка, см')\n", + "plt.legend(loc=2)\n", + "plt.grid()\n", + "\n", + "# Перебираем все объекты из теста\n", + "for i in range(len(y_test)):\n", + " # Если предсказание неправильное\n", + " if np.array(y_test)[i] != y_pred[i]:\n", + " # то подсвечиваем точку красным\n", + " plt.scatter(X_test.iloc[i, 3], X_test.iloc[i, 2], color='red', s=150)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: 0.913\n" + ] + } + ], + "source": [ + "# качество модели (доля правильно классифицированных точек)\n", + "print(f'accuracy: {accuracy_score(y_test, y_pred):.3f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обучим метод 5 ближайших соседях" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['versicolor', 'versicolor', 'virginica', 'versicolor',\n", + " 'versicolor', 'versicolor', 'setosa', 'versicolor', 'versicolor',\n", + " 'virginica', 'virginica', 'virginica', 'setosa', 'setosa',\n", + " 'versicolor', 'setosa', 'versicolor', 'virginica', 'virginica',\n", + " 'virginica', 'setosa', 'virginica', 'setosa'], dtype=object)" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = KNeighborsClassifier(n_neighbors=5)\n", + "model.fit(X_train, y_train)\n", + "\n", + "# Получим предсказания модели\n", + "y_pred = model.predict(X_test)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Покажем на графике, что отражаем полученное число.\n", + "# Красным цветом обозначим точки, для которых классификация сработала неправильно.\n", + "plt.figure(figsize=(10, 7))\n", + "sns.scatterplot(x='petal_width_cm', y='petal_length_cm', data=iris, hue='species', s=70)\n", + "plt.xlabel('Длина лепестка, см')\n", + "plt.ylabel('Ширина лепестка, см')\n", + "plt.legend(loc=2)\n", + "plt.grid()\n", + "\n", + "# Перебираем все объекты из теста\n", + "for i in range(len(y_test)):\n", + " # Если предсказание неправильное\n", + " if np.array(y_test)[i] != y_pred[i]:\n", + " # то подсвечиваем точку красным\n", + " plt.scatter(X_test.iloc[i, 3], X_test.iloc[i, 2], color='red', s=150)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: 0.957\n" + ] + } + ], + "source": [ + "# качество модели (доля правильно классифицированных точек)\n", + "print(f'accuracy: {accuracy_score(y_test, y_pred):.3f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обучим метод 10 ближайших соседях" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['versicolor', 'versicolor', 'virginica', 'versicolor',\n", + " 'versicolor', 'versicolor', 'setosa', 'versicolor', 'versicolor',\n", + " 'virginica', 'virginica', 'virginica', 'setosa', 'setosa',\n", + " 'versicolor', 'setosa', 'versicolor', 'versicolor', 'virginica',\n", + " 'virginica', 'setosa', 'virginica', 'setosa'], dtype=object)" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = KNeighborsClassifier(n_neighbors=10)\n", + "model.fit(X_train, y_train)\n", + "\n", + "# Получим предсказания модели\n", + "y_pred = model.predict(X_test)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAJaCAYAAADpm0w1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACyW0lEQVR4nOzdd3RU1dfG8e/09ITeOwSp0lQQBQUpIiqiiIKKiNhFRWyvioL6s4IVC6hgARs2FBEBAQVERaUj0nsv6ZmZzMz7x5VATJskd1Kfz1pZJPfuzN2ZXGD2nHP2sQQCgQAiIiIiIiIVhLWkExARERERESlOKoJERERERKRCUREkIiIiIiIVioogERERERGpUFQEiYiIiIhIhaIiSEREREREKhQVQSIiIiIiUqGoCBIRERERkQrFXtIJFIXf72fv3r1ER0djsVhKOh0RERERESkhgUCApKQkateujdWa91hPmS6C9u7dS7169Uo6DRERERERKSV27dpF3bp184wp00VQdHQ0YPygMTExmce9Xi8//PADvXv3xuFwlFR6Ug7oXhKz6F4SM+g+ErPoXhKzlKZ7KTExkXr16mXWCHkp00XQiSlwMTEx2YqgiIgIYmJiSvyXIWWb7iUxi+4lMYPuIzGL7iUxS2m8l4JZJqPGCCIiIiIiUqGoCBIRERERkQpFRZCIiIiIiFQoZXpNUDACgQAZGRn4fL6STkWKyGazYbfb1Q5dRERERIqkXBdBXq+XvXv3kpqaWtKpiEkiIiKoVasWTqezpFMRERERkTKqXBdBO3fuxG63U7t2bZxOp0YQyrBAIIDH4+HQoUNs27aNZs2a5bsJloiIiIhITsptEWS32/H7/dSuXZuIiIiSTkdMEB4ejsPhYMeOHXg8HsLCwko6JREREREpg8r9W+kaLShf9PsUERERkaLSK0oREREREalQSrQIatiwIRaLJdvH7bffXpJpZeP3Bzie6sn88PsDJZ2SiIiIiIgUUomuCfr999+ztK5eu3YtvXr1YtCgQSWY1Uk+f4B0r49F/xxi+vIdHE52UzXKxdDODTgvvhrhDhtWq5otiIiIiIiUJSVaBFWrVi3L18888wxNmjShe/fuJZTRST5/gMPJbq54cxm7jqZlHv/nQDLLthyhXuVwZt5yNtWiXKWmENq+fTuNGjXir7/+ol27diWdjoiIiIhIqVRqusN5PB4+/PBDRo8enWsra7fbjdvtzvw6MTERMPYD8nq9mcdPfB4IBPD7/fj9/gLnk+71ZyuATrXraBpXvLmM7+/qRrijdCytOvFzFvZnLgv8fj+BQACv14vNZgv59U7cS6feXyKFoXtJzKD7SMyie0nMUprupYLkYAkEAqVigcunn37KkCFD2LlzJ7Vr184x5vHHH2fcuHHZjs+YMSNbG2y73U7NmjWpV69egTfWtDscLN6SwO0z/so39vUh7enWJJYME3/xX3/9Nc8++yzbtm0jPDyctm3bMn36dCIjI3n//feZNGkSO3bsoH79+tx0003ceOONAFSqVCnL43Tt2pVvv/0Wv9/PCy+8wHvvvcfhw4eJj4/nscce44ILLgCMAvThhx/mm2++4fjx41SrVo3hw4czevRoACZNmsT06dPZsWMHcXFx9O3bl3HjxhEVFWXazxwsj8fDrl272L9/PxkZGcV+fREREREpnVJTUxkyZAgJCQnExMTkGVtqRoLeeecdLrzwwlwLIICHHnoo84U5GCNB9erVo3fv3ll+UK/Xy8KFCwkLCyMqKqrA+8kkpmcw/dedQcV++OtOzm7agZiY8AJdIzf79u3jxhtv5Nlnn2XAgAEkJSWxZMkSoqOj+frrr3nmmWd45ZVXaN++PX/99Rc333wzVapUYdiwYSxfvpzOnTvzww8/0KpVK5xOJzExMbz00ktMmjSJN954g/bt2zN16lSGDBnCmjVraNasGRMmTGDu3Ll88skn1K9fn127drFr167M5zQiIoJXX32VRo0asXXrVu644w6eeuopJk2aZMrPXBDp6emEh4fTrVu3YtknyOv1Mm/ePHr16oXD4Qj59aT80r0kZtB9JGbRvSRmKU330olZYsEoFUXQjh07mD9/Pl988UWecS6XC5fLle24w+HI8Um3WCxYrdZC7S1zONmdfxBwJNkDmLd/zYEDB8jIyODyyy+nQYMGAJx++ukAjBs3jgkTJnDFFVcA0KRJE/7++2+mTJnC8OHDqVGjBmCstTq1mJwwYQIPPPAAQ4YMAeC5555j0aJFvPLKK0yaNIldu3bRrFkzunXrhsVioVGjRllyuueeezI/b9y4MU8++SS33HILb7zxhik/c0FYrVYsFkuuv/NQKe7rSfmle0nMoPtIzKJ7yVyBQIBkbzJ2qx2f34fNasOChTB7+d/gvTTcSwW5fqkogqZOnUr16tW56KKLSjqVTFWjXPxzIDnfuCpRTnJZwlQop59+Oj179qRNmzb06dOH3r17c8UVV+B0OtmyZQsjRoxg5MiRmfEZGRnExsbm+niJiYns3buXrl27ZjnetWtXVq1aBcD1119Pr169aN68OX379qV///707t07M3b+/Pk8/fTT/P333yQmJpKRkUF6ejqpqanZpiGKiIiIVEQp3hRW7F/BlDVTWHXIeI1VyVWJQfGDGNZqGJGOSGzW0K9nluCU+Ip+v9/P1KlTGTZsGHZ7qajJiAlzMLRzg6Bir+3cgGiXeVWvzWZj3rx5zJkzh5YtW/Lqq6/SvHlz1q5dC8CUKVNYuXJl5sfatWtZvnx5ka7ZoUMHtm3bxhNPPEFaWhpXXnll5mjT9u3b6d+/P23btuXzzz/njz/+yJwG5/F4ivbDioiIiJQDKd4UXv7zZe748Y7MAgjgmPsYk9dM5vJvLueY+xilZCm+UAqKoPnz57Nz505uuOGGkk4lk9Vq4bz4atSrnPc6n3qVw+kWX830FtkWi4WuXbsybtw4/vrrL5xOJ0uXLqV27dps3bqVpk2bZvk4MX3tRAOIU/deiomJoXbt2ixdujTLNZYuXUrLli2zxA0ePJgpU6bwySef8Pnnn3P06FH++OMP/H4/EyZMoHPnzsTHx7N3715Tf14RERGRsioQCPDbvt/46O+Pco3Zn7KfuxfeTbI3/1lGUjxKfOild+/epbIqDnPYmHnL2bm2yT6xT1C4w9xhzV9//ZUFCxbQu3dvqlevzq+//sqhQ4do0aIF48aNY9SoUcTGxtK3b1/cbjcrVqzg2LFjjB49murVqxMeHs73339P3bp1CQsLIzY2lvvuu4/HHnuMJk2a0K5dO6ZOncrKlSuZPn06ABMnTqRWrVq0b98eq9XKZ599Rs2aNYmLi6Np06Z4vV5effVVLr74YpYuXcqbb75p6s8sIiIiUlYleZN4e83b+catOrSKo+lHiXZGF0NWkp8SL4JKK5vVQrUoF9/f1Y3F/xziw+U7OJLsoUqUk2s7N6BbfDXCHTbTR4FiYmL46aefeOmll0hMTKRBgwZMmDCBCy+8EDA6tT3//PPcd999REZG0qZNG+6++27AaAv+yiuvMH78eMaOHcu5557LokWLGDVqFAkJCdx7770cPHiQli1bMmvWLJo1awZAdHQ0zz33HJs2bcJms3HGGWfw3XffYbVaOf3005k4cSLPPvssDz30EN26dePpp5/muuuuM/XnFhERESmL7BY7qw+vDir2+23fc/PpN4c4IwmGiqA8WK0WIl12+raqSdemVQgEwGKBaJfD9OLnhBYtWvD999/nen7IkCGZXd5ycuONN2buG3SC1Wrlscce47HHHsvxe0aOHJml2cJ/3XPPPVk6xAFce+21ucaLiIiIVBQZgeD3LUzNSCUQCGAxs6uWFIqKoCBYrRZiwwu24aqIiIiIlH8Oi4NYVywJ7oR8Y1tXaa0CqJQo8cYIIiIiIiJllcVi4fKml+cbF+OMoWudrvnGSfFQESQiIiIiUkhh9jBuaHMDNSJq5Bk3ptMYjQKVIiqCRERERESKINIRyYyLZtC6auts52KcMYw/ezy9G/Ym3J739itSfLQmSERERESkCOxWO9XCqzG512QOpx1mztY5pPnSaFO1DV3rdMWKlXCHCqDSREWQiIiIiEgRWSwWop3RRDujua39bfj9fqxWTboqrfSbERERERExmQqg0k2/HRERERERqVBUBAXD74e045B6zPjT7y/pjEy1fft2LBYLK1euLJWPJyIiIiJiJq0JyovfBxlpsGk+rHgXUg5CZHXodAM0uwDsEVAOhjrr1avHvn37qFq1akmnIiIiIiISciqCcuP3QfJBmNoXjm0/5cQG2LYYKjWE4d9DVI1SXwh5vV4cDkeu5202GzVr1izGjPLn8XhwOp0lnYaIiEi5EQgESPYmc9x9nMXbFxNNNH8d+ItWNVrhsDpw2srP/7senwev38uGIxtYfXg1TquT7vW6E+eKI8oRpf16RNPhcpWRlkMBdIpj243zGammXnby5MnUrl0b/3+m3F166aXccMMNAHz99dd06NCBsLAwGjduzLhx48jIyMiMtVgsvPHGG1xyySVERkby1FNPcezYMYYOHUq1atUIDw+nWbNmTJ06Fch5+tq6devo378/MTExREdHc+6557JlyxYA/H4/48ePp27durhcLtq1a8f333+f58+1ePFizjzzTFwuF7Vq1eLBBx/MkvN5553HHXfcwd13303VqlXp06dPkZ5HEREROSnDn8GhtEPcNv82+n3Rj5f+fAmA2xbcxoCvB7Bi/wpSvea+pikpqd5UVuxfwYCvBzB87nBe/ONFnv39Wfp90Y/b5t/GobRDZPgz8n8gKddUBOXE7zemwOVWAJ1wbDtsXmDqGqFBgwZx5MgRFi5cmHns6NGjfP/99wwdOpSff/6Z6667jrvuuov169fz1ltvMW3aNJ566qksj/P4449z2WWXsWbNGm644QYeffRR1q9fz5w5c9iwYQNvvPFGrtPf9uzZQ7du3XC5XPz444/88ccf3HDDDZlFy8svv8yECRN44YUXWL16NX369OGSSy5h06ZNuT5ev379OOOMM1i1ahVvvPEG77zzDk8++WSWuPfeew+n08nSpUt58803i/I0ioiIyCmSPElc9e1VrDy0Mtu5/Sn7uXXBraw6tAqvz1v8yZnI6/Oy6tAqbl1wK/tT9mc7v/LQSgZ/O5gkT1IJZCeliabD5cSdaKwBCsbv70Cj7hAeZ8qlK1WqxIUXXsiMGTPo2bMnADNnzqRq1aqcf/759O7dmwcffJBhw4YB0LhxY5544gnuv/9+HnvssczHGTJkCMOHD8/8eufOnbRv355OnToB0LBhw1xzmDRpErGxsXz88ceZ0+ji4+Mzz7/wwgs88MADXHXVVQA8++yzLFy4kJdeeolJkyZle7zXX3+devXq8dprr2GxWDjttNPYu3cvDzzwAGPHjs1sIdmsWTOee+65wjxtIiIikotUbyqTVk7iUNqhXGP8AT/jfhnH55d8jsOW+xT60s7j9zDul3H4A7m/QX047TCTVk5idMfRRDgiijE7KU00EpSTQMBoghCMlENGvImGDh3K559/jtvtBmD69OlcddVVWK1WVq1axfjx44mKisr8GDlyJPv27SM19eQw9oli54Rbb72Vjz/+mHbt2nH//fezbNmyXK+/cuVKzj333BzXESUmJrJ37166du2a5XjXrl3ZsGFDjo+3YcMGunTpkmX+bdeuXUlOTmb37t2Zxzp27JjHsyIiIiKF9c2Wb/KN2ZO8h03Hcp7VUVZsOraJPcl78o0L5vmQ8k1FUE4sFqMLXDAiqxnxJrr44osJBALMnj2bXbt28fPPPzN06FAAkpOTGTduHCtXrsz8WLNmDZs2bSIsLOxkWpGRWR7zwgsvZMeOHdxzzz3s3buXnj17MmbMmByvHx4eburPE6z/5iwiIiJFl+hJJDXINczrjqwLcTahtfbw2qDiUjNSSfQkhjgbKc1UBOXEFWO0wQ7GGSOMeBOFhYUxcOBApk+fzkcffUTz5s3p0KEDAB06dGDjxo00bdo020d+OxNXq1aNYcOG8eGHH/LSSy8xefLkHOPatm3Lzz//jNebfV5wTEwMtWvXZunSpVmOL126lJYtW+b4eC1atOCXX34hcMqI2dKlS4mOjqZu3bp55iwiIiJFY7PYgo51WMvuVDgAl80VdGxBnhcpf1QE5cRqNfYBqtQw77hKDaFpz5C0yB46dCizZ8/m3XffzRwFAhg7dizvv/8+48aNY926dWzYsIGPP/6YRx55JM/HGzt2LF9//TWbN29m3bp1fPvtt7Ro0SLH2DvuuIPExESuuuoqVqxYwaZNm/jggw/YuHEjAPfddx/PPvssn3zyCRs3buTBBx9k5cqV3HXXXTk+3m233cauXbu48847+fvvv/n666957LHHGD16dL6Fm4iIiBRNhCOCutHBvenYvW73EGcTWt3qdgsqrm50Xa0HquD0CjQ39nBjH6DcCqET+wTZQ/MXqEePHlSuXJmNGzcyZMiQzON9+vTh22+/5YcffuCMM86gc+fOvPjiizRo0CDPx3M6nTz00EO0bduWbt26YbPZ+Pjjj3OMrVKlCj/++CPJycl0796djh07MmXKlMw1QqNGjWL06NHce++9tGnThu+//55Zs2bRrFmzHB+vTp06fPfdd/z222+cfvrp3HLLLYwYMSLfwk1ERESKzmVzMazlsHzjzqp5FuGO0EyJT/QkkuhJZE/SHhLdiSHrzhbuCOesmmflGzes5bACjRpJ+WMJBExe1V+MEhMTiY2NJSEhgZiYk1PSvF4vP/zwA40aNaJx48ZZ1soUiN9v7AO0eYHRBS7lkLEG6IwRxgiQPaLUb5Ra3qSnp7Nt2zYaNWpU+N9rAXi9Xr777jv69euX54azIvnRvSRm0H0khZXiTeGhnx9i4S5jCw4XLh6Ne5Qnjj+BGze1Imvx0UUfUSW8iunX3Xx8M6/8+Qq/7f8t8/iZNc9kVIdRNI1rSqTD3DXBR9KOcPXsq9mXsi/H8+fXO5+nz33a9OtWVKXp36XcaoOcqEV2XqxWcEbBaRcbbbADAaMJgitGxY+IiIiUGZGOSJ4+92nmbJ3De+vfY1+iUSBEO6O5utnV3NjmRqId0aZeM9WbyqJdi3jo54cIkPU999/2/8a1313L0+c+zfn1zjd1alolVyU+u/gz3l7zNl9s+iKzAULDmIYMazWMCxtdqAJIVAQFxWo1bR8gERERkZIQ6YhkQLMB9G3UlzRPGssWLOPrS7/G4XQQbjd/Gly6L52HlzycrQA6IUCAh5c8zI9X/mhqEWS1Wol1xXJbu9u49fRbSc1IxWax4bA6CLOHYbfq5a9oTZCIiIhIhWG32olyRhHnigOMNTQhKYAy0vlow0f4Ar4843wBHx9t+Ij0jHTTcwi3hxPhiKBqeFUqhVUiyhmlAkgyqQgSEREREVOl+9L5ac9PQcX+tOcn0n3mF0EieVERJCIiIiKmsmAhw58RVGyGPwML5m48L5IfFUEiIiIiYiq71U7zSs2Dim1eqbmmqUmxUxEkIiIiIqaKdERyQ+sbgoq9ofUN6tYmxU5FkIiIiIiYrmZkTS5tcmmeMZc0voRakbWKKSORkzT2KCIiIiKmi3JG8dBZD1E9ojofbviQtIy0zHPh9nCGnjaUG9veqFEgKREqgoLgD/hJ8iRlfh3tjMZqKZlBtMcff5yvvvqKlStXFulxFi1axPnnn8+xY8eIi4sL6nuuv/56jh8/zldffVWka4uIiEjFEOmI5MY2NzKizQh+2fsLB1IPUCOiBp1rdcZqsZq6P5BIQagIyoPP78Ptc7NkzxI+3fgpR9KPUCWsClc2v5Jz6pxDmD2s2IuhMWPGcOeddxb5cc4++2z27dtHbGxs0N/z8ssvEwjkvOGZiIiISE5OFDoXNLighDMROUlFUC58fh9H0o8wbM4wdifvzjy+mc38uv9X6kbV5b0L36NqeNViLYSioqKIiorK9bzH48HpdOb7OE6nk5o1axbo2gUpmERERERESis1RsiF2+fOVgCdanfybobNGWb6DseTJ0+mdu3a+P3+LMcvvfRSbrjhBh5//HHatWuXefz6669nwIABPPXUU9SuXZvmzY12lMuWLaNdu3aEhYXRqVMnvvrqKywWS+Y0ukWLFmGxWDh+/DgA06ZNIy4ujrlz59KiRQuioqLo27cv+/bty3atE/x+P8899xxNmzbF5XJRv359nnrqqczzDzzwAPHx8URERNC4cWMeffRRvF6vqc+XiIiIiEhBqQjKgT/gZ8meJbkWQCfsTt7N0j1L8Qf8ecYVxKBBgzhy5AgLFy7MPHb06FG+//57hg4dmuP3LFiwgI0bNzJv3jy+/fZbEhMTufjii2nTpg1//vknTzzxBA888EC+105NTeWFF17ggw8+4KeffmLnzp2MGTMm1/iHHnqIZ555hkcffZT169czY8YMatSokXk+OjqaadOmsX79el5++WWmTJnCiy++WIBnQ0RERETEfJoOl4MkTxKfbvw0qNhPNn7CmbXOJNZlzlSxSpUqceGFFzJjxgx69uwJwMyZM6latSrnn38+P//8c7bviYyM5O23386cBvfmm29isViYMmUKYWFhtGzZkj179jBy5Mg8r+31ennzzTdp0qQJAHfccQfjx4/PMTYpKYmXX36Z1157jWHDhgHQpEkTzjnnnMyYRx55JPPzhg0bMmbMGD7++GPuv//+AjwjIiIiYjaf31fSKYiUKI0E5eJI+pGg4o6mHzX92kOHDuXzzz/H7XYDMH36dK666iqs1px/XW3atMmyDmjjxo20bduWsLCwzGNnnnlmvteNiIjILIAAatWqxcGDB3OM3bBhA263O7NQy8knn3xC165dqVmzJlFRUTzyyCPs3Lkz3zxERETEfBn+DJI9yaw+tJpJKycBMG/HPFK8KVnaV4tUBCqCclElrEpQcZXDKpt+7YsvvphAIMDs2bPZtWsXP//8c65T4cAYCTKDw+HI8rXFYsm1G1x4eHiej/XLL78wdOhQ+vXrx7fffstff/3Fww8/jMfjMSVXERERCZ7H52FP8h6umn0VQ78bykd/fwTA2KVj6fVZLxbsWECKN6WEsxQpPiqCchDtjObK5lcGFTu4+WCindGmXj8sLIyBAwcyffp0PvroI5o3b06HDh2C/v7mzZuzZs2azJEkgN9//93UHJs1a0Z4eDgLFizI8fyyZcto0KABDz/8MJ06daJZs2bs2LHD1BxEREQkOMfdxxkyewg7ErP/X5zkTeKhJQ+xZM8S3BnuHL5bpPxREZQDq8XKOXXOoW5U3Tzj6kbVpWudriFpkT106FBmz57Nu+++m+coUE6GDBmC3+/npptuYsOGDcydO5cXXngBMEZ3zBAWFsYDDzzA/fffz/vvv8+WLVtYvnw577zzDmAUSTt37uTjjz9my5YtvPLKK3z55ZemXFtERESCl+JJ4eU/XibRk5hn3LO/PUtGIKOYshIpWSqCcuGyuXjvwvdyLYRO7BMUZg/L8XxR9ejRg8qVK7Nx40aGDBlSoO+NiYnhm2++YeXKlbRr146HH36YsWPHAmRZJ1RUjz76KPfeey9jx46lRYsWDB48OHMN0SWXXMI999zDHXfcQbt27Vi2bBmPPvqoadcWERGR4FgsFubumJtv3KG0Q6w7vK4YMhIpeZZAbos+yoDExERiY2NJSEggJiYm87jX6+WHH36gUaNGNG7cuNAv/P0BP+kZ6Szds5RPNn7C0fSjVA6rzODmg+lapyth9rBi3Si1KKZPn87w4cNJSEjIdz1PaZaens62bdto1KiRqQVdbrxeL9999x39+vXLtmZKpCB0L4kZdB9JYexL3kfvz3tnOebCxaNxj/LE8Sdwc3IK3ANnPMA1La8p7hSlDCtN/y7lVhvkRC2y82C1WIlwRNCzQU/OrHWyu1q0M7rUFz/vv/8+jRs3pk6dOqxatYoHHniAK6+8skwXQCIiIlJwTpsz/6B/RTgiQpiJSOmhIigIVovVtH2Aisv+/fsZO3Ys+/fvp1atWgwaNIinnnqqpNMSERGRYuayuWgS14Qtx7fkGWe1WOlet3sxZSVSslQElVP333+/NiUVEREJQoY/g/SMdI6mHyXJk0SV8CpEOiKJdESW+pkfwQi3hzOi9Qj+b8n/5RnXvW53HDZNs5SKQUWQiIiIVFgp3hQW7lzIW6vfYnvi9szjLau05J6O99CmahsiHebsx1dSbFYbPer3YGDTgXyx+YscY5rENeGJrk8Q48x7HYVIeVH2394QERERKYRkTzJT107loSUPZSmAANYfWc9NP9zEjzt/JNWbWjIJmijSEcn9Z97Pqz1epV21dpnHa0TWYEynMXx44Ydlbuq/SFGU+5GgMtz8TnKg36eIiJjlUNoh3lr9Vq7nAwQYu2xsuVknE+mIpHvd7nSs0RGLz8KCHxYwo98MIlwRmgYnFU65HQny+XwApKaW/Xdv5KQTv8+SbsEoIiJlW4onhbdXv51vXIY/g8/++QyPz1MMWYWexWIh2hmNy+4CjG5wKoCkIiq3I0GBQICYmJjMzTsjIiKwWCwlnJUUViAQIDU1lYMHDxIXF4fNZivplEREpAzzBXysOLAiqNhf9v7CFfFXFKjVtIiUbuW2CAKoXr06NpstsxCSsi8uLo6aNWuWdBoiIlIOBAhuinWwcSJSdpTrIshisVCrVi2qV6+O1+st6XSkiBwOh0aARETEFFaLldZVW7MvZV++se2qtcNlcxVDViJSXMp1EXSCzWbTi2cRERHJFOWM4sY2NzJvx7w846wWK0NaDCHMHlZMmYlIcSi3jRFERERE8tIgugGXNbksz5hR7UdlNhEQkfKjQowEiYiIiPxXpDOSB856gHox9Xh//fscdx/PPFczsia3n347vRr2KvObpYpIdiqCREREpMKKdERybctrGdpiKBuObuBY+jFqRtakUWwjHFaHOsKJlFMqgkRERKRCO7Hep2ONjiWciYgUF60JEhERERGRCkVFkIiIiIiIVCgqgkREREREpELRmiARERGREuL1efH4PViwEOGIKOl0xCSp3lQCBHBanThsjpJOJ2R8fh+p3lQA/AF/CWdTMCqCRERERIpZsjeZDH8Gn238jH+O/YPT5qRfo360q94Ol82F3aqXaGVNhj8Dt8/NyoMr+W7bd3h8HuIrxTOo+SDsVjtRjqiSTtE0qd5UfAEfs7fOZtWBVXSmM/N3zOe8hudhs9jKxObC+hsmIiIiUoxSvClMWzuNt9e8jS/gyzw+a8ssakTUYHKvydSNrqv23GWIx+dhd9Jubpp3EwdSD2Qe/37790xaOYkb29zI8NbDy8WeUyneFOZun8v/fv0fbp8bFy46x3XmsWWP4VrhYuJ5E2lbtS3hjvCSTjVPWhMkIiIiUkxSvalM3zCdt1a/laUAOuFA6gGu+e4aEtwJJZCdFFaCO4FrvrsmSwF0gi/g463VbzF9w/TMqWNlldfnZemepTy27DHcPne284meRG6Zfws7knaUQHYFoyJIREREpJgECPD2mrfzjEnyJvHmqjfL/AvmiiLVm8qbq94kyZuUZ9zba94uc+tm/svj9zBhxYQ8YzL8GUxYMYFET2IxZVU4KoJEREREismCHQtIy0jLN+6brd9gtehlWllgtVj5Zus3+calZaTx484fiyGj0NmWsI29KXvzjft136/4/NlHOksT/e0SERERKQaBQIAtCVuCik3LSMPj84Q4IzGDx+cJqrAF2Hx8c5keDdqVtCuouAABDqUdCnE2RaMiSERERKQYWCwW4lxxwcViUWOEMsJpc2LBElRsXFhcmR7hi3ZGBx0bYS/dLd/L7m9BREREpIzp16hfUHGda3XWSFAZ4fF5OKvWWUHFXtToohBnE1rtq7cn3J5/17d60fWoFFapGDIqPBVBIiIiUqG5fW5SvamsOriKxbsWs+HIBlK8KXh9XtOvFeGI4Nw65+Ybd/PpNxPjijH9+mK+GFcMt5x+S75x59Q5J6gCorQb2GxgvjEjWo/AZXMVQzaFp32CREREpMJK8abw2cbPmLZuGkfSj2QerxNVhzvb38l59c4zdW+XaGc0z5z7DDfMvYGNxzbmGHNfp/s4rfJppl1TQu+0yqdxX6f7eH7F8zmej68Uz7PnPlvmC9tIRyR3tLuDrQlb+WXvLznGXNn8Svo07FPqN/wt8ZGgPXv2cM0111ClShXCw8Np06YNK1asKOm0REREpJxL8aTwwooXmPDHhCwFEMCe5D08+PODzPxnJimeFFOvG+OK4b0L3+OJrk8QXykeu8VOuD2cvg378sUlX3B5/OXlYlPNiiTSEcnl8ZfzxSVf0LdhX8Lt4dgtduIrxfNE1yd4/8L3y3wBdEKyN5mxncfyv3P+x+nVTs8sdjrX7sxrPV5jcPzgHPfAKm1KtEQ7duwYXbt25fzzz2fOnDlUq1aNTZs2UalS6Z5DKCIiImXfruRdzPxnZp4xE/+YyMVNLiYSc4uSSEckFze+mB71euC0OfEH/PgDfqKcUaZeR4pPpCOSZpWa8ViXx7BarFgtVjx+D5H2SGxWW0mnZ4okTxIP/vwgaw+vpXeD3ozuOJo6EXVY/uNyroy/ks82fcbPu3/msmaXcV+n+4hwlN7mCCVaBD377LPUq1ePqVOnZh5r1KhRCWYkIiIiFUGyJ5m3V+e9aSmAP+Dnow0fcWPbG01f42Cz2srN6ICcdGohG0ZYCWZivmRvMn8c+AMw9rL6Zus3uHDxaNyjjF40GjduAGZvnc2YTmNKMtV8lWgRNGvWLPr06cOgQYNYvHgxderU4bbbbmPkyJE5xrvdbtxud+bXiYnGTrRerxev9+TixROfn3pMpDB0L4lZdC+JGXQfmcfj9bDh8AZc5F/YrD6wmuT0ZKzOEl9FYBrdS1IYq/evzvZ3xokzy58A/gw/exL20Ci2eAc3CnI/WwKBQCCEueQpLMyojkePHs2gQYP4/fffueuuu3jzzTcZNmxYtvjHH3+ccePGZTs+Y8YMIiJK73CbiIiIiIiEVmpqKkOGDCEhIYGYmLxHWUu0CHI6nXTq1Illy5ZlHhs1ahS///47v/ySveNETiNB9erV4/Dhw1l+UK/Xy7x58+jVqxcOhyO0P4SUa7qXxCy6l8QMuo/Mk+JJYcIfE5izbU6+sbecfgtXn3Z1udq8VPeSFMbhtMNc8uUlBDhZPjhx8kDcAzx7/Fk8GHtbRToimTVgVrGvCUpMTKRq1apBFUElOh2uVq1atGzZMsuxFi1a8Pnnn+cY73K5cLmyD1s7HI4c/wLndlykoHQviVl0L4kZdB8VXZwjjuvbXs9X277KM85usTOoxSAiXeWzW1tx3Uup3lSslpPTCf0Bf6leNF8USZ4knFYnAQL4Aj4cVke5KaAjA5G0r90+x/bYHjyZa4KuaHJFifw7VZDrlWgR1LVrVzZuzNoj/59//qFBgwYllJGIiIhUFDUjazKi9QjeWftOrjFju4wt9fudlGbpGekcdx/nrdVvMXvrbNIy0gi3h9O/cX9uansTca44wuzlo3lAijeFv4/+zeTVk/ll7y8ECFAzsiZDThvCoPhBRDoisVgsJZ1mkcQ4Y3iy65Nc+c2V2drKn9A4tjG3tb+t1Be5JbrC75577mH58uX873//Y/PmzcyYMYPJkydz++23l2RaIiIiUgFEOiIZ2XYk488eT93oulnONa/UnDd6vkHvhr21Z08huX1u1h1ZR/8v+zPzn5mkZaQBkJaRxmf/fEb/L/uz7vA63D53Po9U+qV4U3hnzTtc//31LNu7LHO62P6U/Uz8YyKDvx3Mcffxkk3SJJXCKvHZxZ/Ru0Fv7JaTbxCE2cO4Mv5KPuj3AdGO6BLMMDgl+tbGGWecwZdffslDDz3E+PHjadSoES+99BJDhw4tybRERESkgoh0RHJxk4vp3bA3B1MPkuBOoFp4NWJdsUTYI7Bay09HuOLm8Xm4df6tuRY5bp+bWxfcyoJBC0xvP17cVh5cyZQ1U3I9vzNpJ6MXjeblHi8T4yzbbdEdVgfVIqox7uxxPNblMbYd28b2X7fz7YBvcTqdpX4E6IQSH9/t378//fv3L+k0REREpIKyW+3YrfZib+dbnnl9Xr7c/GXm6E9u0jLS+HLzl1zd/GoctrK5zi3Rk8jk1ZPzjVtxYAVJ7qQyXwSdcGI/pJZVWrKd7UQ6I8vUWkW9vSEiIiIipkrNSGXutrlBxc7dNpfUjNQQZxQ6DquDPw/+GVTs7G2zQ5yNBEtFkIiIiIiYLr9RoBPSfekhziS0vL7gN+hM8aZQgrvTyClUBImIiIiIqawWK/Vj6gcVWy+6Xpb22WWNw+YgyhEVVOxplU8r8x3iyouye8eJiIhIyKV6U0lwJ5DoScTv95d0OiGV5EkiwZ1AiielpFMp86Kd0Vzf6vqgYq9vdT3RztB0E0vPSCfRnUiiO5EMf0ZIrgEwoOmAfGMiHZF0q9stZDlIwZR4YwQREREpfZI9yRxOO8x7695jR9KOzL1dutftjsPqKLOL2P/LH/CTnpHOykMr+WzjZyR4EqgeXp2hLYfSOLax2mMXQbNKzehcqzPL9y3PNeasmmfRrFIz06+d7EkmNSOV99e/z99H/sZutXN+vfO5qPFF2Kw2wu3hpl0r3B7OTW1vYs62ObnunQMwqv0orBp/KDVUBImIiEgWKd4UHlv2GD/s+CHL8Z92/0TlsMpM6T2FhjENcdqcJZShOfwBP0fSjnDD3BvYnrg9y7nZ22ZzerXTeb3n68S4ykc3r+IW6YjkpfNfYuzSsczbMS9z7xwACxYuqH8B47uON73QTPGm8Nbqt5i2blqW40v3LmXCHxN46byXaF+jvamFULQzmhkXzeDW+beyNWFrlnNhtjBGdRjFpU0vJdxh3jWlaFQEiYiISKYkTxLP/fZctgLohKPpR7l+zvV8c9k3VAmvUszZmSstI43r5lzH7uTdOZ5fdWgVty24jbd6vaURoUKKdETy+NmP88CZDzDzn5kcTjtM1fCqXBF/BeH28Mw2y2ZJy0jjo78/ylYAnXr+9h9v59P+n5o6AmW32qkRUYMZF81gW8I2Zm+djdvnpmWVlvRt2BerxVpm9s+pKFQEiYiISCaPz8OsrbPyjEnyJjF17VRub3+7qe+mFyef38f8HfNzLYBOWHVoFVuPb6VNtTbFlFn5E+2MJtoZzc1tbyYjkIHdYsdmtYXkWv6An3fWvJNnTIY/g5f/fJmnz33a1LVINquNSGskrau25rTKp+EL+HBanWqEUEppYqKIiIgARmHw+abP8Qfyb4Dw5eYviyGj0En2JvPxxo+Div1ww4cke5JDnFH5Z7PacNlcISuAAH7b9xvJ3vx/Vz/v+RkLoStO7FY7LptLBVAppiJIREREAOMd8r3Je4OKTfQkhvRFZKhZLBYOph4MKvZA6gF8AV+IMxIz5Deyd4I/4CfRkxjibKQ0UxEkIiIigPHudZwrLqhYl80V2mRCLBAIEOuMDSo21hmrrl5lRJWw4NepaZ1Xxaa/0SIiIgIY05Uuj788qNi+Dfvi85fd0ZFweziXNrk0qNgr4q8g2hWafWzEXOfWPRenNf+uhe2rt9dUtQpORZCIiIhkinPF0blW5zxj7FY7N59+M5HOsvtOutPmZGD8QGKcebe/rhtdl441OhZTVuVTqjeVFG8Ki3Yt4tONn7Jo1yJSvCmkelNNv5bVYg1q49Lb2t1GtMP8wjbJk8Sx9GN8u+VbZv4zk9WHVpPiTcHr85p+rZLk8/tI8iSx5fgWvtnyDWBMGy1LUwzVHU5EREQyRTujmXDeBEb+MJL1R9ZnO++wOnjxvBepGl61BLIzl8vmYmqfqQyfOzzHF2+1I2szrc80wuxhJZBd+ZDiTeG9de/x/vr3SfGmZB6PdERyXcvrGNZqmKnT0iIdkYzuNJr9Kfv5ac9P2c5bsPDgmQ/SpmobU0eCAoEAiZ5Exi4dy6Ldi7I0F6kbXZdHznqE9tXbl4s22ekZ6exI3MH/Lfk//jn2Dy5cPBr3KAO+GkCbGm145txnqBJeBbu1dJcZpTs7ERERKXYxzhim9pnK8n3L+WD9B+xI3EG4PZxeDXpxbctriXBElNnW2Kdy2pw0jG3I95d/zxf/fMFXW77iuPs41cOrM/i0wfRp2IdwWzhWiybOFEayN5kXfn+Bzzd9nu1cijeFN1a9wYHUA9zX6T5T9wuKdETyXPfn2HBkA++ufZeNxzZit9g5p8453ND6BuLC4kKyQeu1c65lW8K2bOd2J+3m1vm38mqPV+lcqzMue9ldT+cP+NmZtJOh3w3F7XNnO7/iwAoGfzuYmZfMLPVvlKgIEhERkWwiHBGcX+98OtXohMViwR/w47K5yt2oiNPmxGlzcnWLq7ms2WWZP2uUIyqkrZwrgoMpB3MsgE71xaYvGNZymOmbpkY6IulUsxPxleOxYCEQCGC32kMyEuPxeZi+YXqOBdAJAQI8tuwxZg+cjYuyWwSleFMYu3RsjgXQCUfSjzBhxQQePuth03+vZtJbGyIiIpIji8VCjCuGaGc0sa7YclcAncppc2b5WVUAFU2KJ4V3174bVOy7a9/NMlXOTDFO43ca44oJ2VS0DH8Gn2z8JN+4I+lH+OvAXyHJobgcSz/GuiPr8o37YfsPxZBN0agIEhERERFTZQQy2HB0Q1CxG45uIMOfEeKMQscX8HEo7VBQsX8c/INAIBDijEIn2N+px+9hf8r+EGdTNCqCRERERMR0dktwqy7sFjsBym5hUJA1Yw6ro0y35g72dwqU+tFUFUEiIiIiYqowWxjn1DknyzG71U6sKzZb17Bz6pxDuK3sNtoIBALEV4oPKrZH/R4hzia0OtToEFTRF+eKo0ZEjWLIqPDUGEFERKQAPD4PXr8Xr9/Y98NpdWK32nHa8t+gUUqvRE8idouddF864fZwfH5fqV7UXdq57C6GtBjCO2vfoXOtzlx12lW0q9aORE8iMc4YVh5ayScbP2HZ3mUMaTEkJB3T0jPS8Qf8uH1ubBYbVouVcHu46SMU4fZwrm91Pf+35P/yjGsa15S6UXVNvfYJCe4EnDYnqd5Uwu3heHwe4sLiTL+O3Wqne93uLNy1MM+4K5pdUeq7KqoIEhERCVKKN4WZ/8xk+obp7EvZB0CNiBoMbTGUK+OvLNObh1ZUKd4Uth7fyqSVk1i2dxkBjC5iPev15M4Od1I9onq5aAdeEsLt4Xx+yeckehKZunYqdy+8G1/Ah81io1vdbtzU9ibu7XSv6c+vz+8jxZvC1HVTmfnPTI67jwPQJK4J17e6nl4NepnaIttmtdGjfg8uqH8B83fOzzEmxhnDK+e/YvrPmuxJ5lDaISb9NYkFuxaQ4c/AgoWza5/NLaffQpO4JkQ7zdsUNtoZzbizx/HP7H/Yk7wnx5i2Vdsyos2IUt9IpXSXaCIiIqVEsieZm+fdzAsrXsgsgMDYJX3iHxO5cd6NJHuSSzBDKagUbwrzd8xn6HdDWbp3aea6lAx/BnN3zGXg1wNZe3gt6RnpJZxp2WSxWNiZuJPh3w9n4a6F+AI+wGgksHDXQoZ/P5ydiTuxYO4amQRPAoO/Hczba97OLIAAthzfwqNLH+XRJY+a3o0u0hHJk+c8yf+d9X9ZRnucVicXN76YLy/9khqRNUwdhUrxpLDuyDqumHUFc3fMzWwuESDA0r1LuW7OdczbMY9Ed/aNgIsixhnDJ/0/YchpQ7IUk5XDKnN7u9t5q9dbZWIUVSNBIiIi+Uj1pjJp5SRWHVqVa8zaw2t55a9XuLvD3eViV/iKINmTzNhlY3NdlO/xe7hjwR0sGLSgmDMrH9w+N/cuvjez+PkvX8DHmMVj+PHKHwnHnBGSRE8iD/78ILuTd+caM2/nPLps7cJlzS7Ltj6pKCIdkVzR7AouaXIJSZ4kvH4vlcMqEwgEQlIUBAgw6sdRePyeXM+P+2UcXWp3IcYVY9p1bVYbsa5Y7upwF3d1uItDyYdY+dNKZl48E5fLhctWNvZB0kiQiIhIPgIE+HLzl/nGfbX5K/wBfzFkJEWV5k1j2rpp+f6+UjNSmbN9Dj5/zi/kJWcen4dP//40c+1cbrx+L5/+/SkeX84v5AsqPSOdX/b+km/ctHXT8tzws7AcNgeRjkhqRtakXnQ9Ih2RISmAvD4v3279ltSM1Dzj/AE/7619jyRPkuk5RDgiiHBEUDuqNgDhjvAyUwCBiiAREZF8bTm+JajpM2kZaWw6tqkYMpKi8vg9LN69OKjY+Tvmk+zVVMeCSM1I5cddPwYV++OuH/N9MR+sn3b/FFTczqSdpGWkmXLNkpDoScy3OcEJP+35qUzvwxQqKoJERETyUZB3qXObmiKli8ViCfr3atYoRUViwZLvKNAJXr/XtHVBBVm/VdYLg4Lcv6W9U1tJ0DMiIiKSj4YxDUMSKyUoYHQLC0Z8pXi1QC8gm8UW9PPbJK4JNos5DQNaVmkZVFy4PZwYp3nrZIqb0+akaVzToGKbxjXVNN0cqAgSERHJh9Pm5MyaZ+Yb16lGJ8IdaqdcFsS4Yrih9Q0AVAuvxnPnPsecgXOYf8V8Zl82m0fOeoQou7GWY1irYWqTXUBRzqjM5zc/N7S+wbR1M80rN6dWZK184/o37m/K9UpKtDOaYa2GBRV7XcvrqBRWKcQZlT0qgkRERPIR44rhkc6PEGbLfd8Ll83Fw50fLtPvLlc0rau25vWerzNrwCxSM1J5eMnD3Dz/Zp5c/iSVwyozb9A8Xj7vZf1OC6ledD16NeiVZ0yvBr2oF13PtGs6rU7Gdhmb5/S6KmFVuKPdHWW+i2OMM4bLm12eZ0znWp1pW61tMWVUtqhFtoiISBBqRdZier/p3Lv4XrYnbs9yrkFMA57v9nzIdoOX0HBYHNSPqc/FX13M4bTDmce3HN/CL/t+oXFsY97t826Z2POkNAq3hTPu7HFUDqvMF5u+yLJGyGF1cFmzy7i7w92E28wbZXPYHHSo3oHXer7GuF/GcTD1YJbzraq04qXzXzK1ZXRJiXHFMKbTGGJdsUzfMD1Ltzu7xc6FjS7k/876P92/uVARJCIiEoQwexiN4xrz0UUfsT1xO7/s/YUAAbrU6kLjuMa4bC5T9xyR0PP4PQybM4wj6UdyPL81YSsjfxjJB/0+yLIppAQn3ZfOrfNvZWiLoYxsM5IFOxdwNP0olcMq07N+T/46+Be3zr+Vyb0mE2E1b1QmwhFB51qdmTVgFmsOrWHloZU4bU561OtBlfAqRDoiy02jgChnFCNaj+DGNjcyb8c89iXvo3JYZfo26osFiwqgPOhfaxERkSDZrXainFG0rtqa1lVbl3Q6UgQen4evt3ydawF0wqbjm1h9aDVdancppszKB3/Az5I9S1h1aBWrDq2iSlgVutXtRrQzmr+P/s3k1ZMzn/sle5ZwQYMLTC1MnDYnTpuTzrU707l2Z9MetzQ6Mao1sNnAEs6kbFERJCIiIhVOijeFrzZ/FVTsZ/98xmmVT9Pi8gJI8iTx6cZPM78+kn4k1w2HP9n4CWfVOotYV2xxpSeixggiIiJS8VgtVo6mHw0q9mj6UbUYLoT8RtlOOJZ+LMSZiGSnIkhEREQqHH/AT+WwykHFVgmrUm7WkBSnKmFVgooL9vcgYib9jRYREZEKJ9IRycCmwa2huLL5lZoKV0DRzmgGNx+c+XX1iOoMih/EDa1vYFD8IKpHVM88N7j5YKKd0SWRplRgWhMkIiIiFY7T5uTiJhczZc0UDqUdyjUuvlK8mmAUgtVipWudrnSo3oGhLYbSpmob5u+cz5G0IzSKbcTINiNZc3gN0zdMp2udruVipC0QCJDsTeZ4+nHmbp9LWkYaraq24qxaZ2Gz2Aiz577PmBQ/FUEiIiJSITltTt7r+x7Xz70+234yAE3jmjKl9xS1xy6kMHsYk3pO4oUVL/DATw+QEcjIPDdxxUQubXopr/V8rVwUBz6/j2PuY9y98G5WHVqV5VysK5YHz3iQ8+ufr3upFFERJCIiIhWS0+akRmQNZg2YxYKdC/hq81ckuBOoHlGdwc0Hc0bNM/SitQjSMtJ4dOmjzN85P9u5jEAGn2/6nOPu4zx1zlNl/nlO8aZw9eyr2Z+yP9u5BHcCDy15iP+d8z96NehVLoq+8kBFkIiIiFRYJ/aTuajhRZxT5xwIABYt1jfDzsSdORZAp1qwcwE3J95Miyotiikr86VnpPPu2ndzLIBO9ezvz9Kjfo9iykryU/YnYIqIiIgUkc1mo3JYZSqHV1YBZIJkTzLvrn03qNh3175Lsic5xBmFTiAQ4PNNn+cbl+BOYPne5cWQkQRDRZCIiIiImMoX8LE1YWtQsVsTtmZZL1TWeANejruPBxW7+vBqAoFAaBOSoKgIEhERERHTOawOU+NKK7sl+NUl4fZwLBZLCLORYKkIEhERERFThdvDg17/0qN+DyLsESHOKHR8AR+tqrQKKrZPwz4hzkaCpSJIREREpAQke5JJ9iSzPWE7e5P3kuJNwePzlHRapnDanAxuPhin1ZlnnMPq4MrmV+K05R1XmkU6IhnZZmS+ca2rtqZqeNViyEiCoe5wIiIiIsXI4/NwLP0YL6x4gfk755PhN9bD1IqsxbUtrmVg/MAy3zIajEJo4nkTuXvh3Tmu+bFb7Lx43ou4bK4SyM48VouVzrU7Myh+EJ/981mOMTUiavDy+S8T5Ygq5uwkNxoJEhERESkmPr+P/Sn7GThrIN9v/z6zAALYl7KP51Y8x0M/P0SKN6UEszRHuD2cM2qewcxLZnJB/Qsy187YLXYuqH8BMy+ZyRk1zyDcHl7CmRadBQvDWg3jqXOeyjI1LsYZw3Utr+P9C9+HAPgD/hLMUk6lkSARERGRYpKWkcaohaNI9CTmGrNw10IW7FjARY0vwma1FWN25otwRNAkrgnju47HYXWQnpFOmD0Mr99LtDO6pNMzhc/vY/6O+YxfPp4LG13I2C5jqRFRA7fPjcvm4rtt33HzvJuxWW18eOGHRDk1GlQaqAgSERERKSa7knax5fiWfOOmrZtGj/o9ys0L5hMFT5g9zPiTsJJMx1RpGWlMXTcVt8/NV5u/4qvNX+GwOnDanNlG9HYl7SrTG8OWJ5oOJyIiIlJMFu5cGFTcpuOb1Eq5jLBYLGw+vjnLMa/fm+OUxh93/VhcaUk+VASJiIiIFINAIIA34A06XutHyoaC/J4y/BnaLLWUUBEkIiIiUgwsFgudanQKKrZ6RHVslrK9HqiisFlsVI+oHlRspxqdNMJXSmhNkIiIiEgxaV+9PVXDq3I47XCecVc1vwq7NTQv01K8Kbg9bgCSPElUdlQOyXUqCrvVzuDmg3n1r1eJrxTP4OaDaV+9PXarnQMpB/h6y9fM3T6XWFcs7aq3K+l05V8qgkRERESKic1i48muT3LbgttynUbVJK4JV592tekbiKZ4UziSdoR31r7Db3t+4xbnLTyy5BGubXMtbau1LRd7E5UEp83JkNOGEF8pnjpRdfh448dMWTMFj89D49jGDIofxB3t7+BQ6qHMNuFS8vSbEBERESkmLruL9tXb81avt3hy+ZPsSNyRec5msdGjfg8e7/K46V3hUrwpfLHpC577/TkjD1zghN/2/8bP+3/m7NpnM/G8iSqECslisXA8/Th3LbwrS3F7NP0oKw6soH319kzqOQmXvWxvDFueqAgSERERKUYRjgg61ejExxd9zM6knWw8upEwexhdanXBZrWZvn9OIBBg9aHVmQVQTpbtXcaEFRMY3XF0uWnLXZy2J2xn7LKxBMi56cFfB//isWWPMe7sceVmf6SyTo0RRERERIqZ3WonyhlFyyotuazZZVzY6ELiwuJC8gI52ZvMpJWT8o37avNXub6Il9wleZKYtHJSvs/d/B3z8fg8xZSV5EdFkIiIiEg55g/4WXVoVb5xXr+Xn3b/VAwZlS8Oq4Ole5fmGxcgwLdbvy2GjCQYmg4nIiJS2u3cCdOmwbZtMGAA3HQTNGoE118P9euXcHJS2qV6U4OOPZp2NISZlE8enyfovYKOpB0hEAioTXYpoJEgERGR0mrxYrjkEmjYEMaPh5kzjeMzZxpfN2xonP9J795L7qKd0Vgtwb3kqxtdN8TZlD9OmxOXLbiGBw1iGqgAKiVUBImIiJQ2gQC88AKcdx7MmWN87fMZH3Dy80DAON+9O0yYYHxtNr8fPGlQAdYyZPgzSM9Ix+f3Fds1fT4fKZ4U0jPSQ3aNAAG61e2Wb1y0I5oza50ZsjzKK5/fR9+GffONc1qd9G7YO6R5pGekk+HPCNk1yhNNhxMRESltJk6E++4zPs/I5wXNifNjxhh/3nuvOTm4k8Dvg5XT4dDf4IiA06+Gyo3BGQXW8vM+apIniePu43z2z2ckuBOoGVGTQc0H4bK5QtbJK8GdgNViZdaWWWw6tgmnzUmfhn1oXqk5LpsLh81h2rWindHc3eFuluxZkucL5Bvb3hj0iJGcFOmM5LZ2t/HDjh9Iy0jLNW5oi6FYQzD+kOxJJi0jjZn/zGR/6n5iXbEMih9EnCs0jTbKCxVBIiIipcnixScLmoIaMwbOOAO65f+uf57cybDkJVj2Mvi8J4//+ibUaAVDP4eo6mC1Fe06pUCiJ5F7F93L8n3Lsxx/Y9UbXNT4Ih7p/Ijpe+ckeZKY+c9M3lj1Bm6fO/P4R39/RIOYBrze83VqRNYIeopVMGpG1OT1nq9z98K7Sc3IukbIgoXrW13PlfFXEm4PN+2aFUklVyXe7v02t86/lURPYrbzg+IHcVPbm4h0mnsvpXhTePLXJ/lu63dZutNNXTuVzrU6M+G8CcQ4Y0y9Znmhcl9ERKQ0mTAB7IV8j9JuN76/KNxJsPQl+PmFrAXQCQfWwds9wZNctOuUAqneVEb+MDJbAQQnO3k9vORhkk38WZPcSXyx6Qte+vOlLAXQCTsSd3DNd9eYek2ARG8iG45s4NvLvuXBMx+kS+0uAAxpMYRZA2bRoUYHluxZkmNOkr80XxpL9yzlq0u/YmznsXSv250utbowtMVQvrz0S3o37M3c7XNJ8+Y+UlRQyd5kHl7yMLO3zs6xPffyfcsZ+cPIAjXGqEhUBImIiJQWO3fCt9/mPwUuNxkZ8M03sGtX4XPw+4wiKC+Je+C3yZBRdl8wBwIBftv/G+uPrM8zbsHOBRxMPWjada1WK2+seiPPmGPuY0xZPYUkT5Ip10z2JPPyHy/z4p8vMuDrAexO2k3vBsbalDhXHHf+eCd3/ngnz/z2jNaTFEKaN43Jqyfz+qrX6f9lf/4+9jd9Gvbh8vjLqRVZi/sX38/IH0by/Irn8RNcF7lgHEw5yIKdC/KMWX9kPb/t/41AKNYLlnEqgkREREqLadOKvtbGaoWpUwv3vX4/rPwo5xGg//ptSnBxpVSSJ4n31r0XVOx7694z7d30BTsXkOJNyTfu6y1fY7eas2rBYrHww44fAGP634cbPmTcL+MAeH3l62xP3A7AkfQjrD602pRrVigW+Hrz1wCkZqTy6cZP+b8l/8eYxWN4YcULbDq+CTCmri3etdiUS6Z6U5m2blpQse+te8+0gro8UREkIiJSWmzaZM7jbN5cuO/zueHQhuBikw+U+TVBu5KCGzHbmbQTr7/oBZ/f72fL8S1BxSZ7k/GaVGQmuhODzj/Y/OQkr89Lsje46Ysbj200ZVTG6/cGff/uStoF6sqdjYogERGR0iIp6WQb7MLy+SAx+8LsoFjt4IwIMrZsF0ABAkE3AQi3h2Mx4VWk1Wolwh7k8wumdYhz2YNvsGB2E4iKoCC/pyhHlCn7BFmwFOj+1XS47FQEiYiIlBbR0WArYnFhs0FMIbtB2RzQbmhwsfEXlunpcGG2sMx1Mfnp37g/UY4oU67bv3H/LF/XjqxNh+odaFO1TZYXtZ1qdMJt0porp9VJfKX4zK+jHFG0qtIKgGoR1TKPWy1Wzqt3ninXrEi8fi+danQKKvaixheZcs0oR1TQj9WnYR/CbGGmXLc8UYtsERGR0qJZM3Mep2nTwn9vXAOo2Rb257M2pNt9EBaC1rvuZMAPh/4xmjRUbWaMUJl8LZfdxdCWQ5m2bhoef+4bwVZyVaJ7ve5YTdoXKcoZxVk1zyLSEck1La+hWng1tidux2lz0iyuGfN2zGPaummMaDOCuLA4U64Zbg/nxjY38tpfrzG89XC61+3OhsMbOPbXMd684E12p+7m/fXvE+mING0dUkUS44zh5rY3s2Leijzjzqx5JlFOc4ppq9UoWCu5KnHMfSzXOKfVyZAWQwo0GlhR6E4XEREpLa6/Hh5/vGiP4ffD8OGF/35XNAz9DN6+ABJyWXNw4XNQpQiFVk4CAUhPgB8egbUz4UQrYavNGHXq9wJEVjVGq0wSbg/n5fNf5s6Fd+bYFS3aEc3bfd7GaXWads1YVywTzpvA7qTdvPjHi/y6/9fMczHOGAY0HcBHF31EmN28d+5tVhvn1TuPM2ueyRur3uD535/Hl+Hj0bhHuWLWFZxR5wzu63Qf1SOra3PNQmpTrQ23nn5rrp3/GsY0ZEJ3c/fscVqdvN3nba6fcz1J3uyNDxxWBy+f/7L2fspFiU6He/zxx7FYLFk+TjvttJJMSUREpOTUrw/VqxftMapXh3r1Cv/9FgtEVodbl0LPxyGmtnHcaocWF8PNPxlT5lzmvKOdKT0B3rkA/vrgZAEExmjQ39/Cm10h2bxW1WAUQR1rduTbAd8ysNnAzClDMc4YhrUcxjeXfUPDmIamrc0BY+rUnuQ9XP/99VkKIDA6t72//n3GLC7kZrl58Pl93Db/Nj7Z+EmWzVIDBPh5z89cM+cajqYdxe83r4VzRRLpiGRYq2F8cOEHnFvnXKwW4yV2nag63H/G/Xx00UfEumJNvabD5qBhTEO+vexbhrUclllghdnCGNhsIN8M+IaONTuqCMpFiY8EtWrVivnz52d+bS/sBnEiIiJl3c6dcOBA0R7jwAFjn6CiFEJWK4TFQpfb4MwbjQIIwOcxjpvNkwILn4LDeXTHSz0CX90Kgz8wNYdwezh1oo0Xqg+e+SAWLPgDfiyW4BeeF4TH5+HexfeS7kvPNWbFgRV8s+Ubroi/wpTpaW6fmw83fMj6o7nviZTiTeH+n+7nnT7vaDSokCIdkbSr3o5nuz2Lw2oUzhn+DFw2l6mF9KmcNieVwytze/vbua3dbZnFly/gU5OLfJR4xWG326lZs2ZJpyEiIlLypk0zGhsUpUOczWbsEzR2bNHzsbuMjxMcIXpHORCAlTPyj9u22CiYQlCIFdcLxk3HNrE7aXe+cR+s/4CLm1xsShHk8/v4+O+P843bcHQDh1IPqQgqopJ4/jTaU3AlXgRt2rSJ2rVrExYWRpcuXXj66aepX79+jrFutxu3+2SnlMR/W4B6vV683pMdak58fuoxkcLQvSRm0b0kQdm2DcLDcy2CvOHhWf7Mkc0G27dDWbrXjuyAjAywBrEOZsfvcFq/0OcUIkt3LcVF/ovUDyQdwOvx4qXov8fjacdJTk/Ocl0nzix/nvDbnt+oF1mEUUSpcErT/28FycESKMHG4XPmzCE5OZnmzZuzb98+xo0bx549e1i7di3R0dmr6Mcff5xx48ZlOz5jxgwiIoLvuy8iIiIiIuVLamoqQ4YMISEhgZh8tgoo0SLov44fP06DBg2YOHEiI0aMyHY+p5GgevXqcfjw4Sw/qNfrZd68efTq1QuHIzRzMKVi0L0kZtG9JEG56SaYOTPPkaB5775LrxtuwJGWlmMMNhsMGgRvvRXCRE3mSYZXOoA3Nf/Y23872ayhDFp5YCW3Lrg137jaUbX54MIPiHAU/U3eNG8aA2cN5Lj7eOYxJ04eiHuAZ48/i4eTLcI/7PchTeKaFPmaUnGUpv/fEhMTqVq1alBFUIlPhztVXFwc8fHxbN68OcfzLpcLlyv7ELLD4cjxSc/tuEhB6V4Ss+hekjw1agRpafmuCXKkpeVdBDVsCGXpPvM7oPWl8MfUvOMadIXIuJD8bEnuJKxWK3aLHa/fixUrEU7zZ5m0rNGSKpFV2JuyN8+4K1tcSYQrwpQF9X6Ln0vjL+XttW9zTp1zGNx8MM1jm7P8x+W81fctZm2bxTdbv6FOVB3qxtbVv1FSKKXh/7eCXL9EW2T/V3JyMlu2bKFWrVolnYqIiEjxu/56Y5+foijqPkElwRUFFzwGlRrlHhMWBwPeML0pQrInmQMpB3jlr1foPbM3naZ34pKvLuGdte9wPP046Rm5d3ErDKfVyfPdn8/sHpaT06udzmXNLjOto5jL7mJ46+F8dNFHDDltCJ9u/JRLv7oUgP8t/x/NKjXjy0u/1J4yUqGUaBE0ZswYFi9ezPbt21m2bBmXXXYZNpuNq6++uiTTEhERKRn160P//lDY7SLsdrj44qK1xy4prlgY+SO0vjzrhqgWCzTtCbcsgWhzu8kme5JZc3gNF315ER9v/JhEj9Fw6VDaISavmczFX13MnuQ9eHyefB4peA6bg2aVmjGj3wxOr3Z6lnPh9nCuPu1q3rzgTdO71VksFuZun8st829h8e7FmZvDbjq+iSeWP8G9i+4l1hWLzWoz9boipVWJTofbvXs3V199NUeOHKFatWqcc845LF++nGrVqpVkWiIiIiVnzBj45pvCfa/PB/fea24+xcVqhYjK0P8luGgi7F9tjGrVaAk2F4Sb3xbb6/cy6sdRuH3uHM8fdx9nxNwRzB44G6fNmWNMYYTbw2leuTlvXPAGyZ5ktiVsw2V3cVrl07BgMWUd0Kn8fj/L9i7j3bXv5hqz5vAanlj+BI92flQtsqVCKNEi6OOP8+9ZLyIiUqF06wYvvGAUQwX1/PPG95dlYf8uZm4U2p8j1ZvK9A3T89y0FOBI+hEW71pMn4Z9TB0lsVgsRDujiXZGUysqtMsAUjJSmLJ6Sr5xP2z/gf876/9CmotIaVGq1gSJiIgIMHo0PP2E8bkln9gT558eb3yfBMXtc/PD9h+Cip29bTYJnoQQZxQ6Gf4MNhzdkG+cL+Bj8a7FxZCRSMlTESQiIlLaWCxwz90wohLE/ztpw8LJgufUz+PtMLYn3Hmb8X0SFKvFSmpGEC25MUaNStGOIgVWkOYOSZ6kEGYiUnqUqhbZIiIi8i+fBzrEQ90NkOCHlV5I+bdhQCsHRPqhnQNirdDlTLCHlWy+ZYwv4KNOVB0OpB7IN7ZOVB3s1rL7kinGFYPdas9shpCXhrENQ5+QSClQ4L/R48ePz/P82LFjC52MiIhImeDLOLmxpyMCbCF4geyMhE4j4LsxRqHT3QXWfwud/mFwaifts24Fl7ndxMq7WGcsV592NX8e/BMLFrrW6Ur3ut2JcESQ4E7gh+0/sPLQSgCuaXkNsS7zGzMUl0AgQM/6PZm7fW6ecZXDKtO+evtiykqkZBX4X+3HH3+cmjVrUrNmzWxDwxaLRUWQiIiUX54U8Ptg9Sew7d+1Ew3PhdOvBqvNKFzMYnfB6VfB8tfh6Nbc49pcaeyzIwVis9o4t+65XBF/BcNbDWdX0i7mbJtDgieBauHVGHPGGFw2F1/88wV1ouqUdLpFEuWM4p4O9/DT7p9Iy8hlk11gVPtR2C1ld8RLpCAKfKffddddzJgxg/r16zNy5Ej69euHRXOQRUSkvHMnw6a58NVtcOoaiw3fwLyxcPErcNpF5hYk9gi4YS5MvwL2rcp6zmKBtldBv+fBpZbGhRFuDeOOdndwy/xb+Pvo31nOffbPZ3Sp3YUJ3SeUi5bRVcKr8F7f97htwW0cTjuc5ZzT6uSejvfQt1FfXHZXCWUoUrwK3BjhxRdfZOfOnQwaNIjnnnuOhg0bMm7cOPbv3x+K/EREREqe3w+7f4fPR2QtgE7ISIcvb4Jdy42RIrPYbBBRFYZ9AyMXQvvrjONn3wn3bIA+T6sAKoI0fzrDvx+erQA64Ze9v3D3wrtJLgfNAsLsYTSJa8Lsy2YzqeckLmp8EQCjO45m0eBFXNbsMtM3aBUpzQrVHc7lcjF06FAWL17MSy+9xMSJE3n//ffNzk1ERKR08CTDvEchvw5hPzxiTJkzk9UKYbFQpwP0eNg41vVuiKkFEZXMvVYFkpHhZeHOH9mWuC3PuN/2/8b2xB3FlFVoOW1OIhwRnFvnXMZ0MvahGthsINHOaBVAUuEUqgjyeDxMnz6dbt26cc8993DvvfcybNgws3MTEREpHVKPwP41+ccd3ADJ+XcbK7QTa440ZanIkrxJfLzxk6Bip2+YTkL6sRBnVHwsFgth/3YTNHMDWJGypMBrgu6++24++ugjunTpwoMPPkjfvn2xWrXdkIiIlGOJe4KPTdgNVZuFLhcxhdVqY39KcFP596XsIyNg4jRHESlxBa5eXnnlFaxWKzt27OCRRx6hU6dOdOjQIfNDRESk3HHFBB8bVnZbKVck/oCfKGdwTSyindFYURMokfKkwCNBY8eOVTc4ERGpWCo3hqga+U91i6wG1eKLJycpkjCbiwsbXshrK1/LN/aSxpcQ69L6K5HypFD7BImIiGThTgb8sPM38CRBlaZQqSHYw0OzkWhxszmgy50w75G847rcDqHYZ8WTYjRl2PGb8fW+VVCjOdhcYHeafz0wNoTNSINjO+DIJnBGQb2zjNbc5aAjXbgjgsGnDebdte+SmpGaa1yNiBqcXedsTf0XKWcK/C/177//jt/v56yzzspy/Ndff8Vms9GpUyfTkhMRkTLAnQTzHoNVM8B7ykaMVZpA32eg/tllfzNPuws6XQ+H/oaVH+Yc03YwdBoBjjBzr+1OhsXPwR/vgtcLp0+GaRdBTHW44HFo1tv8osSdDLt+hTn3w5HNJ487wo29iXqNh7ACTBEspZwWB2/1eoub592cYyFUNbwqU/tMxaENREXKnQK/rXH77beza9eubMf37NnD7bffbkpSIiJSRriT4aOrYMU7WQsggCNbYMaVsHkeeHJ/p73McKdAl9tgyKdG4REWZ6z/aXoBXP0xnHP3vyNiZl4zGb4YCcteNorNUx3fCTNvgDWfmXtdbxpsXQTTL89aAJ0498dU4/dq9s9aAiKckcTHNWPO5XO4sc2N1IqsRbg9nAYxDbin4z3MGjCLGuHVcaobn0i5U+C3NtavX59jA4T27duzfv16U5ISEZEywO+Dv2fD9iW5xwQCMGsUjN5QfHmFQupRmH0P/PO9UQCdcSP0ewEswKF/YMW7sGmuURANeBMiKptz3V3LYeN3ecfMeQBaX27O9cD4vX59W957Iu38BdZ/DadfBWW8xXKEM5IIIrmx9Q0MbzUcm9VGhj8Dl9VJmCO8pNMTkRApcBHkcrk4cOAAjRs3znJ837592O0aLhYRqTA8yfDLq/nHuRONYqnNIGPjz7IoEDCKnIDfKIT++T7nuE3zwKxWymnHYclL+cf5PPDXh3DmTcbapaIIBOCfuZCekH/sL69Ci/7lphtepLPsr3MSkeAV+H+j3r1789BDD5GQcPIfyOPHj/N///d/9OrVy9TkRESkFLO5gttAFGDHUvC5Q5tPKB1cb4yQ5Cfgh/1rzbmm1Q57/woudufy7NMRC8Pnhh15jOyd6uAG4x4QESmDCjx088ILL9CtWzcaNGhA+/btAVi5ciU1atTggw8+MD1BEREpxSyWvKdNZcZZoSzvs2IpwHuGBYnNUyD4xzLtmhYTH0tEpPQq8L90derUYfXq1Tz33HO0bNmSjh078vLLL7NmzRrq1asXihxFRKQ0ykiHep2Di43vY37XtOJUs7XRIe5UFmv2gsHmhFqnm3PNgB8adg0utlkvcEYW/Zp2F8T3DS627hngSy/6NUVESkChFvFERkZy0003mZ2LiIiUJWGxcM5omDEo77jIatDo3NDk4Ek1Bpj8fmP6mM8dmjUqAT+0ugw2zoF2Q6Dj9cbPBZB6BP6YBn9Nh2YXAEGMjAUjLBbOvde4Zl6cUdDyUvMaFNTvAtE1IWl/3nHn3AOu8rEeSEQqHnUyEBGRwrFYoMHZ0OZKWPNpzjF2FwyeDtYiLtj/rwyPsXj/5xdg5Qyj+YLFaoyIdH8QqsabuzdReCXo+xyc/4jRre3T6+DQRuNc1WbQ6Qa4dalRkITHmXfdai3gzJvht7dyPm+1waCpRgFoFpvD+J1N6wcZuazjajUQGnU37gERkTJIE39FRKTwXFHQ/0Xo+yzE1j153GKBJj3hpkVQs032qWRF4csw9siZdAb8+qZRAMG/ndvmwpTzYfUn5u9jY7UaraPn3H+yAAI4vAm+fwi+uCkE7aItxohLvxegctaurDToCtd+BTXbmlsE2V1QoxXc/DM07Zm10ImtC32ehkteKfsb4IpIhaaRIBERKRpXlDES0v4aSD4A3lSIrmWM/oSHYLpURjp8cCmkHcs95rt7jSl4rnhzrulJhZ9egG0/5R6zYyksetoYLXJGmHPd5P0wuTt0HA7XfA4px+DP3UaBkn4Yfn8bdiyDO1cUvT32qRzhUK05XDHVKDqT9oI93JgmZ3OYW9SKiJQAFUEiIlJ0dqfxURyjA7t+hYTdeccEAvDzROj3PLhM2P8l4DfW/eTnzw/gvP8r+vUA3EmwZKLx57JXjH15qrSAeg/CjCshYdvJ2O1LoFkf86ennVhfFVnF3McVESlhmg4nIiJlhyc59/VH/7XxO/Oue3gjpB/PP86dCAfWmXfdU3+GQACObjU+T9qXNW71p8ZzIyIiQTG1CGrUqBEjRoxg7969Zj6siIiIwe8Hb5Btmb1pYDFpjU6w1wTIMGHTUjAaPQR73Yz04PZrEhERwOQiaNiwYfh8Prp2DXJfAxERkYKwh0H1FsHFVo0Hv9ec61ZuVIDYJuZc0+c1Os8Fo1oLrdMRESkAU4ugxx9/nGnTprFt27b8g0VERArK7oQzbsy+SWlOOt9mtKw2gyPS2D8nP/XOhLAYc67pijF+BoAqzeCOP+DOP42vR/0F134NFruxDuism0JXBLmTIPWo0YjC7wvNNf7D4/OQ4E4gwZ1AmlkjayIip1BjBBERKVtsTuh8u9EoIDfVW5q7gWhYjNFkYUoP8HlyycsBFz5vFC9msFrhtP4waiVEVoW/v4PVX0DMEJj3GJw1Ah7YBgfWG53bzOZOgmPbYdmrcHSLUQi2GQStBhi/gxAUXaneVDx+Dx///TG/7P0FX8BH22ptGdZyGJGOSKLMKmpFpMIrVBG0e/duZs2axc6dO/F4sv5nMHHiRFMSExERyVFYDHS/H2x2WP569g09G58HV7xr7ot0i8WY5nb9d/DZMEjck/V8TG24/F1jCp6ZHdosFvBnwKsdjfbj1jA4fQhsmAXrPjVGp4Z8Yt7o0wnuZPj8Rvjn+6zHty2GHx6B674ypiXaw0y7ZIo3hR93/sjYpWPJCGRkHl91aBUfrP+Am9rexA2tbyDSEWnaNUWk4ipwEbRgwQIuueQSGjduzN9//03r1q3Zvn07gUCADh06hCJHERGRk9IT4Zs7oXk/Y5Rk/VfG5qmuaGP0x50MX4w0ipLwOPOu64yAWqfD7b/Bnj9g8zzjeJOeUPeM0Oyf4/PC1L6Qcjjn8zt/gU+uhSvfN+9nTU+Eb+/JXgBlnj8O0/rDnX8Y+waZwB/ws/bwWh5e8jABcm7wMHn1ZKqGVWVg/EBcNq1/EpGiKfCaoIceeogxY8awZs0awsLC+Pzzz9m1axfdu3dn0KBBochRRETkpJSDsO4r+OImeKsbHN5sTEHzpsOXt8C7fWDzAvhtitE1zUwn9kJq3B0uGGd8NDnfOGZ2AeROht+n5F4AnbBtMSSa2JXVmwrrPs87xpMMS14ET4opl0z2JvPyny/nWgCd8Nbqt8jwZ+QZIyISjAIXQRs2bOC6664DwG63k5aWRlRUFOPHj+fZZ581PUEREZFM3jT4dfLJr1MOwYp3YPGzxoai+9ecPPfne5CRy/odM1ht5q05yonfC39NDy729ymQnmDCNX3GprDBtNteOQMwZ+qfO8PNmsNr8o07kn6Ev4/8bco1RaRiK3ARFBkZmbkOqFatWmzZsiXz3OHD+bxbJSIiUhQ+LyTvDy42eT9Yy3D/H5sj+J81ab85BZ/PE/yokjvRtPVPx9zHgo49kHrAlGuKSMVW4P8dOnfuzJIlS2jRogX9+vXj3nvvZc2aNXzxxRd07tw5FDmKiIgYbA4IrxxcbEQVo6lAWeXLMH5W7578YyOqmFPwWR1GJ7pgOMzrSBftiA46tkp4FdOuKyIVV4FHgiZOnMhZZ50FwLhx4+jZsyeffPIJDRs25J133jE9QRERkUyOcDhjRNavW1xi7B10+tUQU+fkubZXG0VTWWWxQNvBwcV2vB4iKhX9mja78VjBaH2FafsGRTujia8Un29cjDOG1lVbm3JNEanYCvy2UePGjTM/j4yM5M033zQ1IRERKYPSE4ypahu/M7qLVW8B9c4y1syYOGIAQFwDaHguxPeBNlfA9iUnu8Od/3+wbxX8/AKcfYf51/ZlGE0BEnfD1sXGsUbdILYeOCPNLbrCYqHL7cZ6H3dS7nG1Oxituc28brNesGle7jE2p9Gm3GXOvj3h9nBub3c7dy28K8+461peh80SwnVYIlJhFLgISkhIIDY2Nsdzb7/9NjfeeGORkxIRkTIkPQG+vh3+ng0B/8njkVWh13hjpMYV/HSnfIXFwFXT4a8P4PUukHbKepLvHzI287z2K3BEmHdNAHcKJOyCz0fAgbVZz1VvCZe/bRRoJhUGgFFsXPsVfHCZsQbnv6q3hGtmmrtPUFgsXP4OfHg57P49+3l7GFz9MURUM+2SNquNs2qdxeiOo5n4R877DV7W9DKuaXkNYSbuTSQiFVeBi6Du3bszb948qlU7+Y/f7t27GTFiBKtXr1YRJCJSkbiT4L2LjdGX/0o5DF/dZrSubnsVuEza5NKdBCumwvzHsp/zZ8CamcbI0DVfmtu2OnkfvN3TGAn6r4Pr4Z1eMHIRVDNzVCYGqjaHu9cY3e7Wfm0cr98FzhgGTXuZW3RlXjcWrvsadv4Kv7wGR7cao2qtLjOmIzoiTB9li3REcmX8lfRu0Jt3177Lb/t/wx/w07JKS25scyN1o+tqo1QRMU2Bi6C2bdvStWtXFixYQL169ZgyZQpjxozhoosuYu3atfk/gIiIlA++fwuOnAqgU/3wMLQ1cR85fwb8+ETeMbt+M6ZztbwUrAVe/ppd6hH47r6cC6ATPCnw3RgYNA0igmzeEIywf0fRzrgRWg+GRb/CZW9AdA1zfrbcOCOhaQ+o0wEIQABjw1iz90M6RaQzkkhnJPd2uhev3wuAzWIjyhmCQk9EKrQCF0Hvv/8+d955J127dqV58+asWbOGqVOnMnDgwFDkJyIipZU3FZZPCiIuDdZ8Dh2GFf1Fu88Lf7wXXNe3X14xNjINjyvaNcG43taF+cdtWwwZ7qJfLyfOSLA4jc8jqoa2ADqVGc9fAUWYPZVRROQ/CvUv6Kuvvsp1113Hjz/+yHvvvacCSESkIrI54fCm4GL3/AE+E4qDjHTYtzK42APrjBzNcGhjcBuIgjE1TkRESrUCjwTNmjULgDPPPJMePXowePBgXn75ZSpVMlpzXnLJJeZmKCIipZfFmrUZQm5sDpM21rQEvx+O1RFcbsE+VrDMKrxERCRkClwEDRgwINux4cOHA2CxWPD5zNkzQERESjmfGxqfB1t+zD+25QCjq1hROSKMbnNrPjvlWDiEVwJPKqQfP3m8aU/ziqAarYzpaJ6UfPILh1qnm3NNEREJmQIXQX6/Sf+hiIhI2RYWC+fem38RFFsP6nQ055pWKzTpYbTfrnYanDESGnaFlENGG+7kQ/D720aRdO4YE1tH+42NS1e8m3dYmyvNK7xERCRkCrwm6P3338ftDtGiTxERKVtqnQ6db8v9vCsahn4GNhM7itkccOOP0PdZWP8VTGxh7Bf0Ymv47l5jBOi25VC5kXnXDIuDCx7Pe5SnRmvo/USJNBIQEZGCKXARNHz4cBISEkKRi4iIlDWuaDj//2DQe1Cz7cnjdpcxcnLbcqjUCOwFWFOTH3+GsQfRO71g3ZdGx7gT9vwJM2+ANZ+C2TMXwmJh2LfQ/QGIqn7yeGQ16HYfDP/OiBERkVKvwNPhAsF2xxERkYrBFW2s02nSA/xeY3PUsFijm9qJPW7MFAjAR1caLbpzs+gZiO8L4e3NvXZYDHS9C84eZWzaSsD4+bGatxmsiIiEXIGLIIBPP/2UmJic51lfd911RUpIRETKIKvVxPU3efD7YPM8YyQoP0tegv4vmrtxKRgNEgBc2sBTRKSsKlQR9Nxzz2Gz2bIdt1gsKoJERCR03Inw9+zgYrcsMNYPiYiI/EehiqAVK1ZQvXr1/ANFRETMFAgYa4KC4fMY+xiJiIj8h/53EBGRssMRATXbBBdboxVkqJupiIhkV+AiqEGDBjlOhRMRkQouww1px/79OB6aazjCoONwsAYxkeGs28pXt7YMz8nNYNMTjFExEREplAIXQdu2baNKlSqhyEVERMoibxqkHoVlr8K0i2DyeTBzOGyeD55k869nsRhtufNS70xo3hes5eBNuwy3UfT8NhlmXGUc+/xGY21UKJ5fEZEKoMBrgkaNGkXTpk0ZNWpUluOvvfYamzdv5qWXXjIrNxERKe28abD7d5hxpfH5Cce2w5YfoW4nuOYLc0dkwitBpxvB5oSfJxgjTydYbdDqMuj3QnCjRaWdNx0ObYD3LjGaQljDoCaw8xfYvhCqt4TrZ5vfAU9EpJwr8EjQ559/TteuXbMdP/vss5k5c6YpSYmISBmRehSmD8paAJ1q9wr4bDikJ5p3zfQE+PQaY0Totl9g4BToORb6PQ+jVkLLAfDBQHCXg1ESTwq8d7FRAOXk4HqYfvm/exaJiEiwCvw22ZEjR4iNzf6OXkxMDIcPB7Fvg4iIlA+eZPj5BchIzztuywJIO2rePkLHtsO2n4yPH5+CZr0gsppRMCx5CRL3GHG/vAbdxvy7mWkZ5E2HX9/Iv8DZ8ycc2QK12xVLWiIi5UGBR4KaNm3K999/n+34nDlzaNy4sSlJiYhIWWCF1Z8GF7piKvi8Rb+kO8l4rBO8qbD+a/j9bVj10ckCCGD1xxDwF/2aJcXngZUzgov9/W3wpIY2HxGRcqTAI0GjR4/mjjvu4NChQ/To0QOABQsWMGHCBK0HEhGpSCzW4BfmpxwyiqCibl7q8xijSsFIPVK21wVZbQX7Wf0mFJkiIhVEgf93uOGGG3C73Tz11FM88cQTADRs2JA33niD6667zvQERUSklAr4jCYFpzYmyE1M7aIXQAA2F0QFuVl3VM3gN1YtjfwZEFXDmP6Xn+iaRqMIEREJSqE2S7311lvZvXs3Bw4cIDExka1bt6oAEhHJi68MvxjPlQVOHxJcaKcbzCmCXFFwxsiTX0dWhU4joPsDcPadUKP1yXPth5btkSB7GHQYFlzsmTeDIzy0+YiIlCOFKoIyMjKYP38+X3zxBYF/N2vbu3cvycnloBOPiIhZ3EnGpqHL34SFTxrHkg8Y3c3KA2cEnHMPuPJpeNDyUnBGmXfdqBpGB7jL3oKbf4aqTY3n2hEOAyfDDXOhSQ+jMHBGmnfd4mZ3GcVjRD578zXqBrF1iicnEZFyosBvke3YsYO+ffuyc+dO3G43vXr1Ijo6mmeffRa3282bb74ZijxFRMoWdzIseAL+eNdYC2MNg9PPhNc6QdPzjRfwZnVLK0muaGOfmvcvyXlaXNML4NJJ5nZoC4+DS16FJS/CN6OMzURPWPwcND4frninbBdAJzgjYcQPMLWfUUD/V/0uMHh62e2AJyJSQgo8EnTXXXfRqVMnjh07Rnj4yaH3yy67jAULFpianIhImZSeCHPuh9/eyt4RLRCAjd/Bh+VkHxtHGFRrDnevgUtfh8bnGRukthlkjNIMmmb+C/TUY7D4WVgyMWsBdMLWhTCtv9FEoayzOSCuIdz5J1z+LjTqbhxvcTGMmAdDZ5aPYlpEpJgVeCTo559/ZtmyZTidWRdgNmzYkD179uTyXSIiFUjaUVg5Pe+Y3b/D9iUQ38fY9LMss7uMj9OvgtP6Gces9tCNTvgzYPnrecccXA9rv4B2Q8xZi1SSbHawRUGry6Bhd/hxKVz4HERVLunMRETKrAKPBPn9fnw+X7bju3fvJjpaw/EiUsF5UmHZa8HF/vJq+VkfBEZL5/BKxkeoCiBPGvw+Jbj9f36bXD5G206wWiHs383KNf1NRKRIClwE9e7dO8t+QBaLheTkZB577DH69etnZm4iImWPzw2H/wku9vA/ZX8UqLhlpMKhjcHFHv4H7GobLSIi2RV4OtyECRPo06cPLVu2JD09nSFDhrBp0yaqVq3KRx99FIocRUTKEKuxTiYY9nBjjZAEz2IL/vl1hAc3YiQiIhVOgYugunXrsmrVKj7++GNWr15NcnIyI0aMYOjQoVkaJYiIVEiuaGg1EP6Zm3/saRdpg8uCCo+DlpfBqo/zj43vW7Y3SxURkZAp1C5ydruda665xuxcRETKPqsVTutvrIvJqWV0ZpzN2NzTGVF8uYVShseYCph8ELypEF3bWNB/Yg2LmRp2hZg6kJhHMx6LBc4ZbfweRERE/qPARdCsWbPyPH/JJZcUOhkRkXLB5oBrv4RpF4EnJft5ixUumwyuEBQIJcGdBH9Nh19eg4RdxjGLBRr3gD5PQVwDc4s9qwOu/Qre7Z17odnvBYiuZd41RUSkXClwETRgwIBcz1kslhw7xwXjmWee4aGHHuKuu+7K0nhBRKTM8WcYLaJHLoRfJsGaz8D379qU5v2gy81gDwPKwXoVdzJ8OxrWfJr1eCAAWxbA5CUw7FuodbrRRtsMPjcEfMbzu3wSrPoE3IlGcdmsF3S+zRgBUs8JERHJRaGmw+3fv5/q1aublsTvv//OW2+9Rdu2bU17TBGREuPPgCk9oHpLOGMEXPAYeNyw+Hdjr5dFT8PWRXD7r1DttJLOtvACAdixNHsBdKoMN3w8BO5aCZhUBFms8E5viK0DnUbAqD+N4zYH7PzVKDw3z4dh30DDc8y5poiIlCsFbpFttuTkZIYOHcqUKVOoVElzt0WkjPN54c8PwOeBfSth1p3wXGOYdKZx/ouRRgEE8PNEYypZWZWeAEtezD8u5RBs+9mca/oyYP3XxsjPwQ3w3Rh4vilMbAHPNIAZV8KmH4yucEtfhpQj5lxXRETKlUKNBJnp9ttv56KLLuKCCy7gySefzDPW7Xbjdrszv05MTATA6/Xi9Xozj5/4/NRjIoWhe0kKLD0Btv4M1qxtnL0Bm/Hnqcd3/G6MEFmDbPlc2gTssGdlcPlvnA/1zgVHEUeDUo/Clp+yXzOA0WziVLv+AGxQjv7+6t8kMYvuJTFLabqXCpKDJRAo2CYVNpuNf/75h2rVquV4PiYmJujH+vjjj3nqqaf4/fffCQsL47zzzqNdu3a5rgl6/PHHGTduXLbjM2bMICKinHRYEhERERGRAktNTWXIkCEkJCTkW5MUuAiyWq1YctjhPBAIFKgxwq5du+jUqRPz5s3LXAuUXxGU00hQvXr1OHz4cJYf1Ov1Mm/ePHr16oXD4SjATyeSle4lKbAMNyx7FZa+lOWw1xrGvDav0GvNKBz+dONgs95w8UvgCv7No1LFnQjTB8GBdfnHXvwKtBxgtBAvCq8b/voAFjyef2y9s2DgFIioXLRrliL6N0nMontJzFKa7qXExESqVq0aVBFU4OlwCxcuLHRip/rjjz84ePAgHTp0yDzm8/n46aefeO2113C73dhsWac2uFwuXK7sUykcDkeOT3pux0UKSveSBM3hgM4jYclzxrqU/572p58sgs65E6KqhCaPtOMnp4cF/KHZr8cWB51vhi9vyjvOFQMtL4Ic/v0uMIcDOg6BhY9DRnresV1uhuhqRS+8cpJ+HCz/Pr9+P4QXb7tz/ZskZtG9JGYpDfdSQa5f4CKoe/fuBf2WHPXs2ZM1a9ZkOTZ8+HBOO+00HnjggWwFkIhImWF3Qc/HYP5juce0HgTVW5h/bXcy7FkBS16CvX8andQadIVz74WqzcAVbd61rDY47SKjA9v2JTnHWCzGKJDFxELE74O+T8O39+Qe0/QCaNTN/ALInWSMfC2ZaHSiA6h3BpxzD9Rsa+7zKyIiIVOoxgg///wzb731Flu3buWzzz6jTp06fPDBBzRq1IhzzgmuHWl0dDStW7fOciwyMpIqVapkOy4iUqa4oo3W2BFVYNH/IHHvyXNhsdBpFHS9C1xR5l7XnQxf3gJ/f5P1+N/fGh9n3Qo9Hja/ELryA/jxCVj1EXjTTp6r0sQoBht1M3ez1IjK0Gqg8VzOHwfHd5w854yCDtfB+Q+ZX5C4k2HOg7Dyw6zHN80zPtpeBRdNMP/3KiIipitwEfT5559z7bXXMnToUP7888/MNToJCQn873//47vvvjM9SRGRMscVDW2vNPYFOrgeju2GbcDtv4HDaW5RAOBJgZ8nZC+ATvXrG1CjFZx+lbGnjhkS9xptqc+5B7rfDzuWGblUagixdeH3t2H56zDkMwgzce1TeBzE9zU2Rz20EY5uM4qiBmcbI0Vmr7PKcMMf07IXQKda/TFUP80oNh1ltOOfiEgFUeAi6Mknn+TNN9/kuuuu4+OPP8483rVr13xbXOdn0aJFRfp+EZFSxe4yPuqdCTXbw7bvwBlprGsxW8BvFBz5WTIRWg0wpwhyJ8FPz8ORzfD17RBeCeqeAY5wSNoPu38zNlQFSNprbhEExnMJxjXrnmHuY/+Xzwu/vJp/3C+T4IyRoc1FRESKrMCTpTdu3Ei3bt2yHY+NjeX48eNm5CQiIgW150+jW1t+jm41Ni81g9UO6748+XXaMWOj0vVfw65fTxZAAH+8b2wgW1Yd3WoUdvlJOQSH/wl9PiIiUiQFLoJq1qzJ5s2bsx1fsmQJjRs3NiUpEREpoLTjwce6k0y6qCX/Dm0npB8HX4ZJ1y0BwRSYJ6QnhC4PERExRYGLoJEjR3LXXXfx66+/YrFY2Lt3L9OnT2fMmDHceuutochRRETyE1c/+NiomuZc058BkTlvnJ1N5UZgc5pz3ZIQUyf42Ni6octDRERMUeA1QQ8++CB+v5+ePXuSmppKt27dcLlcjBkzhjvvvDMUOYqISH6qNjMKoeM7ISwO2g6CKk2NtUIH1sHaL8CbCvW7mLdo32qDjsPhp+fyjrNYjThboRqSlg4RVaBmG9i/Ju+46i0gqkbx5CQiIoVW4P+RLBYLDz/8MPfddx+bN28mOTmZli1bEhWllqAiIiXG5oRe4yFpn9E+ev3XWfcJ6vGo0TihWR/zOqc5wqHLbfDHu5ByOPe49teW7VEgMFpv93oCPrws61qn/+r1xMmGDSIiUmoV+m05p9NJy5YtzcxFREQKy+6EJufD33Pg1Q5Gm+oTVs4wOrddMRWqxhsbmJrFGQUj5sN7F0PCruznTx8Cff5X9vfOsVqNDnSXvwNf3ZZ9LZTdZWwKW7+LMUImIiKlWoGLoA4dOuR5/s8//yx0MiIiUki+DNixHL66JefzacdgxiAYuRDC25h3XZsD4urB7cth56+waoZRgFVuAp1vNUadynoBdIIrytibaMwmY0+gbT8Zo0KNzjWKPatNo0AiImVEgYuglStXcu+992r6m4hIaZKRBnMfyjvG54W5/weDPzQ2FjWL1W6MCDXtaeyJ5PcbIyPlccPQE0VOxxug7VXG545w8zafFRGRYlGo6XD33Xcf1atXNzsXEREprKPbjL1s8rPtp9Du1+OKDt1jlyY2O9hM3vxVRESKTYFbZFssFixmzicXEZGiO7ot+NjEfaHLQ0REpAwo8EhQIBAgPj4ep9NJZGQktWvXpn379gwbNoxOnTqFIkcREclPWAFGYBwRoctDRESkDChwETR16lQCgQBer5fExET27t3L77//TufOnfnqq6/o379/KPIUEZG81D3DWK9yale4nMTVh2iTNksVEREpowpcBA0bNizH4w8//DDjx49XESQicoIvw2hYkLAbju0xjnlSwBIGdpObBlgs0P46+PWNvOPOvrPs79kjIiJSRKZt3z169Ghq1NAu2SIiALiTYMtCWPA4HNkC1jA4fTK8dS50vgk6Dje3dbQzCno8DIf+hq0Lc45pN9Ro5WxXESQiIhWbaUVQlSpVGDVqlFkPJyJSdrmTYfUnMPve7OeSD8IPjxiFUe8nzO2m5oo22l9v+RGWvQx7/wIs0PAcOOceqNOx/OzZIyIiUgSmFUEiIvIvnwfm3J93zB9ToeP1ULududd2RcFp/aFR95MjPj6PufsCiYiIlHEFbpEtIiJ5yHDDinfB78s/dslESE80PwerFcJjjU08HeEqgERERP5DRZCIiJm8abBjaXCxu36DQCC0+YiIiEg2KoJEREqKxQLae1pERKTYFXpN0Pr169m5cycejyfL8UsuuaTISYmIlFmOcGM9zpYf84+t1xlVQSIiIsWvwEXQ1q1bueyyy1izZg0Wi4XAv1M5LBbjP3KfL4h58CIi5ZXdBR2HwY9PgD8j79hzR0NYTPHkVV55043n2WozvvZ59ZyKiEi+Cjwd7q677qJRo0YcPHiQiIgI1q1bx08//USnTp1YtGhRCFIUESljrA7o/1LeMWfeApUaFkc25ZPPC2nH4OcJ8Eo7eKomPFMfvr0bDm002pSLiIjkosAjQb/88gs//vgjVatWxWq1YrVaOeecc3j66acZNWoUf/31VyjyFBEpO1xR0OoyiKoB8x+Dg+tPnoupA11vh7ZXmrtHUEXi90HiXnjnAmPfpRN8Hlj7Oaz7Ei57C5r3075IIiKSowIXQT6fj+ho4z/uqlWrsnfvXpo3b06DBg3YuHGj6QmKiJRJriho2hPqd4aUw5CwF9YcgZELwBV5cg8fKThvGrx/adYC6FQBP3x5M9z5p4ogERHJUYGnw7Vu3ZpVq1YBcNZZZ/Hcc8+xdOlSxo8fT+PGjU1PUESkzLLajPUpVRpDvbOMY84oFUBFtfdPOLYt75iA39iHSdPiREQkBwUugh555BH8fj8A48ePZ9u2bZx77rl89913vPLKK6YnKCIiksmdAqs+Ci52wzeA9mESEZHsCjwdrk+fPpmfN23alL///pujR49SqVKlzA5xIiIiIRHwgScluFhPClhsoc1HRETKpELvE3SqypUrm/EwIiIiebO7oEqz4GIrNwK/N7T5iIhImVTgImjgwIF5nv/iiy8KnYyISLmUdhw8aSWdRflgd8GZI2HJBAjkM9XtrFvAEVk8eYmISJlS4DVBsbGxmR+zZ8/GarVmOSYiIv9KT4S9f8Hch+DrUcaxrYvBnQTaWLrwHBHQYXjeMVWaQJsrwWbKhAcRESlnCvy/w9SpUzM/nzlzJs8995y6womI/Fd6Anw8BLYvMb62hsHp18AnQ6FSXRj2LURWB5vWrBRYWAz0fsIocFa8Y+wbdKo6HWHIp+DUKJCIiORMb5GJiJgtPRE+uhp2LM35/JHNMLUv3LIEbNowtVBcUdDjUTjvQfjzfTiyBVwx0OE6iKltFEoiIiK5UBEkImK2I5tyL4BOOLYd1n4O7YaCzVEsaZU7Jwqds0eBzwNWu55LEREJSoGLoFP3AsrIyGDatGlUrVo189ioUaPMyUxEpCxKOw6/TQ4udsVUOO1iiKwS0pTKPasNrOElnYWIiJQhBS6CXnzxxczPa9asyQcffJD5tcViUREkIhWb3wuJe4OLTdxjvIAXERGRYlXgImjbtm2hyENEpHywWCEsLrjY8DgI+EOZjYiIiOSgwC2yRUQkDxFVoP3Q4GLbXAn2sNDmIyIiItkUeCRo9OjReZ6fOHFioZMRESkXGnSFyo3h6NbcY1wxcMaN4IwovrxEREQEKEQR9NJLLxEdHU3Hjh0J/Ge3bovFYlpiIiJllj3C2Afo3T6QsCv7eVc0XPulRoFERERKSIGLoClTpjB27FjsdjsTJkygTZs2ochLRKTsstkgqgbc9gus+gT+nAbJR4xz594LZ91oFEAaBRIRESkRBV4TNGLECDZt2kSXLl3o2rUrI0eO5MCBA6HITUSk7LLZjRGfDtfBdV/DzT8bx8+8BSIqqwASEREpQYVqjBAREcG4cePYuHEjPp+P+Ph4xo8fT1pamtn5iYiUbXan0SwhLNb42qn9bEREREpagafDzZo1K8vXAwYMoEGDBjz//PNMnjyZ3bt3m5aciIiIiIiI2QpcBA0YMCDXcykpKUXJRUREREREJOQKXAT5/drYT0REREREyi5tlioiEkppx8CbZvx54msREREpUYUqghYsWED//v1p0qQJTZo0oX///syfP9/s3EREyi53EhzdDnPuh2cbwEv/bifwzV2wewWkJ5RoeiIiIhVZgYug119/nb59+xIdHc1dd93FXXfdRUxMDP369WPSpEmhyFFEpGxxp8CBtfBGZ1j9KWS4T57b8iO8cwGs/xrSjpdYiiIiIhVZgdcE/e9//+PFF1/kjjvuyDw2atQounbtyv/+9z9uv/12UxMUESl7/DBjsDENLieBgDEi1Ph8CI8r1sxERESkECNBx48fp2/fvtmO9+7dm4QETe8QkQrO54W1X+Q/3S3gh2WvQHpi8eQlIiIimQpcBF1yySV8+eWX2Y5//fXX9O/f35SkRETKrPQE+Pvb4GL/+R78GaHNR0RERLIp8HS4li1b8tRTT7Fo0SK6dOkCwPLly1m6dCn33nsvr7zySmbsqFGjzMtURKQsCATA5wkuNiMdLGrSKSIiUtwKXAS98847VKpUifXr17N+/frM43FxcbzzzjuZX1ssFhVBIlLx2MOgWnPYuij/2GqnaSRIRESkBBS4CNq2bVso8hARKR/CoqHz7fDrW/nHdr4NIquGPicRERHJQvMwRETMFhYDHYblHdOgKzQ8p3jyERERkSwKPBI0evToPM9PnDix0MmIiJQL4ZWgz1MQFgu/vZV1nyCLFVoNhItfBld0yeUoIiJSgRW4CHrppZeIjo6mY8eOBAKBLOcsFotpiYmIlGmuaDh3NHQbA+u+hKM7IRW4809wuozRIhERESkRBS6CpkyZwtixY7Hb7UyYMIE2bdqEIi8RkbIvvJLxZ8frweuF774z1gA5HCWaloiISEVX4DVBI0aMYNOmTXTp0oWuXbsycuRIDhw4EIrcRERERERETFeoxggRERGMGzeOjRs34vP5iI+PZ/z48aSlpZmdn4iIiIiIiKkKPB1u1qxZWb4eMGAADRo04Pnnn2fy5Mns3r3btORERERERETMVuAiaMCAAbmeS0lJKUouIiIiIiIiIVfgIsjv94ciDxERERERkWKhzVJFRERERKRCCXok6JVXXgkqbtSoUYVORkREREREJNSCLoJefPHFPM97PB7279+vIkhEREREREq1oIugbdu25Xl+5cqVdOzYscgJiYiIiIiIhJJpa4IsFotZDyUiIiIiIhIyaowgIiIiIiIVStDT4RITE/M8n5SUVORkREREREREQi3oIiguLi7PKW+BQEBT4kRESgNPKgT8kHoELBaIqAwWOzjCSjozERGRUiHoImjhwoV5nt+0aRM333xzkRMSEZFC8vvBnQCLnoWV08H97wh+ZFXoNAK63AFhMSWbo4iISCkQdBHUvXv3PM/HxcUV+OJvvPEGb7zxBtu3bwegVatWjB07lgsvvLDAjyUiUuGlH4MpPeHYf7p5phyGxc/Cpnlw3dcqhEREpMIr0cYIdevW5ZlnnuGPP/5gxYoV9OjRg0svvZR169aVZFoiImVPegJ8c3f2AuhUe/+En543psuJiIhUYCVaBF188cX069ePZs2aER8fz1NPPUVUVBTLly8vybRERMoevw82zs4/7s/3jfVCIiIiFVjQ0+EGDhyY5/njx48XKRGfz8dnn31GSkoKXbp0yTHG7Xbjdrszvz7Rsc7r9eL1ejOPn/j81GMihaF7ScwS8ntp+3LAAVZH3nGedDiyHao1D00eElL6N0nMontJzFKa7qWC5GAJBAKBYAKHDx8e1ANOnTo16IsDrFmzhi5dupCenk5UVBQzZsygX79+OcY+/vjjjBs3LtvxGTNmEBERUaDrioiIiIhI+ZGamsqQIUNISEggJibv9a9BF0Gh4vF42LlzJwkJCcycOZO3336bxYsX07Jly2yxOY0E1atXj8OHD2f5Qb1eL/PmzaNXr144HPm8KyqSB91LYpaQ30vHd8EbOY+iZ2FzwF2rwKXmCGWR/k0Ss+heErOUpnspMTGRqlWrBlUEBT0dLlScTidNmzYFoGPHjvz++++8/PLLvPXWW9liXS4XLpcr23GHw5Hjk57bcZGC0r0kZgnZvRRdBWq3ht0r8o5reRHYHaD7uUzTv0liFt1LYpbScC8V5Pol2hghJ36/P8toj4iIBMEVA5dMAkd47jERVaDP/9QiW0REKrwSHQl66KGHuPDCC6lfvz5JSUnMmDGDRYsWMXfu3JJMS0Sk7LFYoFIDuHEBfHkz7F+T9Xz9LnD52xBRuWTyExERKUVKtAg6ePAg1113Hfv27SM2Npa2bdsyd+5cevXqVZJpiYiUTY5wqNYCrv8OkvbBrl/BYoNG3cAVDWGxRrEkIiJSwZVoEfTOO++U5OVFRMofq9WY7hYWozbYIiIiuSh1a4JERERERERCSUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIiIhUKCqCRERERESkQlERJCIiIiIiFYqKIBERERERqVBUBImIiIiISIWiIkhERERERCoUFUEiIiIiIlKhqAgSEREREZEKRUWQiIiIyP+3d9/hUVX5/8Dfd/pMMpNeSUIIKCAlFGlRKSpCUAS7oCyoiAV0Afu6PuJPd1l31eVrRbDEAoqKqCuKUgxNOoRFSiDFEEqAQMikTrvn9wfLSEibhBsmN/N+PU+ex7n3MzlnxmOe+/bcew4RBRSGICIiIiIiCigMQUREREREFFAYgoiIiIiIKKAwBBERERERUUBhCCIiIiIiooDCEERERERERAGFIYiIiIiIiAIKQxAREREREQUUhiAiIiIiIgooDEFERERERBRQGIKIiIiIiCigMAQREREREVFAYQgiIiIiIqKAwhBEREREREQBxa8haPbs2ejXrx+sViuio6MxduxYZGdn+7NLRERERETUxvk1BK1evRpTp07Fxo0bsXz5crhcLlx33XWoqKjwZ7eIiIiIiKgN0/mz8WXLltV4nZGRgejoaGzbtg2DBw/2U6+IiIiIiKgt82sIOl9paSkAIDw8vM7zDocDDofD+9putwMAXC4XXC6X9/jZfz73GFFzcCyRUjiWSAkcR6QUjiVSSmsaS03pgySEEC3YF5/Jsowbb7wRp0+fxrp16+qsmTVrFl544YVaxxcuXAiLxdLSXSQiIiIiolaqsrIS48ePR2lpKWw2W4O1rSYEPfTQQ/jxxx+xbt06JCQk1FlT10xQYmIiiouLa3xQl8uF5cuXY/jw4dDr9S3ed2q7OJZIKRxLpASOI1IKxxIppTWNJbvdjsjISJ9CUKu4HW7atGn4/vvvsWbNmnoDEAAYjUYYjcZax/V6fZ1fen3H24rSKhfOZliLQQeDrm2ueO6RZZRVuwEAkgRYjXpoNNJF7UNbH0t08XAskRI4jkgpHEuklNYwlprSvl9DkBACjzzyCJYsWYLMzEx06NDBn91RjQqHG78dLsW8tXnIP1EBs0GLUT3icNeAJBh1WpgNWn93URFujwyHW8bS/x7F51sKcbrSiWibERMGJWPopVEw67UXPQwRERERkfr5NQRNnToVCxcuxLfffgur1YqioiIAQEhICMxmsz+71mqVV7sw+eOt2Jh3qsbx3UfseH3lAXwwqR/6JIWpPgi5PTIOn67CrXM34ETZH7dA5hVXYGPeKSRHWPDlg2mIDDZAkhiEiIiIiMh3fr1/6p133kFpaSmGDh2KuLg478+iRYv82a1Wy17lwmNf7qwVgM5yuGXcm7EFxeWOOs+rSbVLxq3v1AxA5/r9ZCXunLcBlU7PRe4ZEREREamdX0OQEKLOn0mTJvmzW61WpdODn3Yfa7DG4ZbxxqoDKP/fMzRq5PbI+DbrME40EuZyT1RgW0HJReoVEREREbUVbfNJ+jZIlgUWbTnoU+23WUeg1ar3FrFyhxufbyn0qfaTjQWwV/l/XXoiIiIiUg+GIJVwyXK9t4adz+GWod4IBEiShFMVTp9qT5Y7IbeOVd6JiIiISCUYglRCr9EgNsTkU63FoIWac4EQAlHW2kuh1yXKaoSGCyMQERERURMwBKmERiPhjn5J8OV6/6be7VQ9O2I16XDXgCSfaiemtYfNzP0NiIiIiMh3DEEqYtJrMDo1vsEas16LaVd3QpCxVeyD2yxajQajesQhvpGZry6xVqQmhF6cThERERFRm8EQpCJWkx5/v6kHru4SXef5YKMOn04egDCL4SL3THkmvQZfPZSGdqF17xfVOcaKhfcPVHXYIyIiIiL/4BWkygQbdXh9XG/8XlyBeWvykF9cAbNBi9E94zC2dzvotRqY9OreKBU4MxsUazPh5xmDsebACSzcdBAllU7E2EyYOCgZfduHMQARERERUbPwKlKFgo06dG8Xgr/d1B0e+cyzP0FGHfTatjWxp9FICDLqMOKyWKSlREDgzMpxIXwGiIiIiIguAEOQillNgREGNBoJIW3gFj8iIiIiah3a1tQBERERERFRIxiCiIiIiIgooDAEERERERFRQOEzQSplr3ZBCOCYvRomvRbhQQYYtRrodS2Xa6tdHnhkgeP2aniEQKzNDElCi67SJssCFU43Khxu2KvdCLcYYNBpYDXpIPmyc2wzlf3v+z1yqhwAUOl0wyxpYWjB75eIiIiILg6GIJWpdnlQZK/GS9/vwS/ZJ7yrwyWEmTH5yg649fJEBLdAKCmrduHtzFx8tvkgTle6AJzZy+fG1Hg8ld4FIWY9dBplA0K5w40NuScxZ8V+7D5i9x7v2z4MT43sjG7xIYoHMIfbg5PlTry0dA9+3n0MWknGP/sDN7yxDuMHdsCEgckINvE/GyIiIiI14//WVhGXR0buiXKkz1mLFXuPewMQABwqqcKs/+zBM4v/i3KHW9F2y6tduOu9TXgnM9cbgACg2iXji62HMOr/1qKkwtXAb2hGmw43Fm4swP0fb60RgABgW0EJ7pi3ESv3HkOFgp/VI8s4croaI+eswQ+7iuA+5/s9XubAy8uyMW3hdkXbJCIiIqKLjyFIRZxuGfd/tBVVLk+9Nf/571GsO1AMIUS9NU1R7fLg7cxc/PdQab01x+wOPPZFFuxVygWhkgon/v7jvnrPCwE89uVOuDyyYm1WOj148JNtsFfXH3Iy95/Ad1lH4FawXSIiIiK6uBiCVGRn4WkcKa1utG7u6lyUNXAh3xQeWWDh5oON1q3NKUZ1A+GsKSocbsxdndtoncsj8Nnmg3C4lWm38FQVso+VNVo3f20eql0MQURERERqxRCkEm6PjJ/3HPOpNqvwtGIP8B8vq65xC1x9hAA2559SpE2XR8b6nGKfalfvP4EqpzIhaOU+377fvOIKyArNtBERERHRxccQpBKyQI1ngBqj1CV6U+76cjehf42262PIaMp3ouTvYggiIiIiUi+GIJUw6DQYkBLuU22HyCDFnlmJDTHBpPdtmKQmhirSplYjoXt8iE+1vRJDYVRo1mtAB9++32irEXot/9MhIiIiUiuu9asiwzpHw2bWITLIgPcmXo4Q85k9czyygFsW+HJLIV7+KRuTr+wAs16rSJsSgDGp8Vi09VCDdT0TQhARZFCkTatJj6nDOuHH34oQH2LCuAFJuLZrDIKNOpyudOGHXUfxxdZCnKxwYvJVKTAblBnGPRNCERdiwtFGnruaMKg9dNqW2aOo3OGCLAOSdGaPpBCLMt8pEREREf2BIUhFtBoJP08fjGCTHst3F+GjDQXIKy6HRa/D8G4xeHBwCu7snwS9TgOdQjMVQUYdnkrvitX7i1FkrzscmPQa/OvWVEX3J0qOCMKb43qhd/twLNpyEA9+ug0llU5EW024tU8Clj56FXYcPIUggzJhDwD0Wgmv3p6KCe9vrvfWuEuigzEpLRlGnXLtAmeWBD9ur8ZbmTlYk10MlyyjS6wVUwanYECHiBbdkJaIiIgo0PDKSkVMei1Mei3ueHdDjb1z7FVufLKhAAs3HcRrt6ViaJdoRdu1mXX4zyNX4okvd2L1gRM493GYngkheOW2VCSFW6DRKDc7YtBJSI4MRvqcNTWWrLZXleMfy/bhg/X5WPxQGswKhiCDToteCaH47P6BeHbJLhw4Xu49p9NIGN4tDn+7qQesJr1ibQJnAtCiLQfx4vd7axzfmHcKG/NOYVDHCMyfcDk3aSUiIiJSCK+qVKSk0olpC7fX2jz0LI8sMPPLnfjh0asQYlbuQl2n0SDKasTr43rD4ZaxOf8k3LJAakIowoMNCDboFA1AwJmNWMfP31jvnj3Hyxy4/d0NWDFzCIKMyj2fYzHq0Ld9KL5+OA1HTldh35HTQOEOZD4xFCaDQfEAJITAzsLTtQLQuTbknsTz//kNs0Z3U7x9IiIiokDEp7tVxF7lwvqckw3WeGSBN1cdwKkKh+Lt28x6RFmNuL5nPMb0aofkyCDYTHrFA5DLLWPR1sIGNy0FgKOl1Vh7oBiygivEAYBWo4HVpEfnWBtG9YgDAISalQ9AAGCvdmPOiv2N1n2XdUTxz0lEREQUqBiCVMLl9mDRlkKfapftLoJFocUC/KHC6cbX2xteiOGsRVsKUeZofB+j1kqSgC2/lzRa5/IIn/eJIiIiIqKGMQSphNMtYK/y7WLf5RFQ8zY2kiTBXtXwLNBZpVUuVX/WSofvG72eqnC2YE+IiIiIAgdDkEqY9Bq0CzP7VGsz6SAU2y714hNCIC7E5FNtfKgJWoVvx7uYrCYddD72v32EpYV7Q0RERBQY1HvPVCtT4XDD5ZFh1mthVGiPnnNptRrc0S8Jr/y8Hx5ZINZmwo294hFrM8Hh9mBT3invym239k2AS6HNUutS7fRAQMCo0yr+PBAA2Ex6TExLxtaCM7eJpSaE4JquMbCa/tgn6OzKbfdd2UHViwXIQmD4ZTH48beiBuusRh2uuiTqIvWKiIiIqG1jCLpApVUuHC6pwhdbC1FW7UK7MDPuHtAeeq0GYQptHnqWJAH3XpGM1MRQ9E4Kw5Lth7H7SCnMBh3uuSIZs27shtdX7cdDQzshxKxs2063By6PwMa8k1i+5xg8skC/DuEY1SMOGgmKPoOk0Ui4uks0RvWIxYNDOgIAvs06goKTFYi2mvD2XX1wssKJhZsO4tIYq2Lt+oPVpMeTI7tg1b7jcLjrD65Th3WEpN4JLyIiIqJWhSGomTweD05XuTH5o63YUXi6xrk3VuXglj4JmDW6m6J7u4RZDHj0mkvw1i85mP55FtznrBb26cYCdIwKRsY9/WAxKHuXY5XLg31H7Zjy8TacKP9j1bkvtx3CrO9246Wx3XFdt1hFN0u1GLT4+0098NCC7diQW3NFvHdW5yK9eyz+eWvPNrGJaKzNiE/vG4D7PtpSa0U8SQIeGtIRdw9KVvViF0REREStCa+qmqnKJXD7uxuRe6K81jkhgK+2HYLLLeOFMd0QalFmVqak0on31uZh7uq8Os/nnijHze/8iuUzBivS3lmHS6pw57yNdc5UVDo9mPnFTsy9W4trusRAr1MmgFU6PZjw/mbsOlxa5/kffytClcuD1+/sDZuCeyL5g9mgQ4+EEGx45hos212En34rgssj0C3ehklpyTDqNYoGTCIiIqJAx4URmsHh8uD7/x6pMwCd69udR1DWyF43TaGRJMxfk99gzYkyB+avyUNZtTLLRturXPjb0r0N3qoFAC8t3QuHQs8hybKM9TnF9QagszKzT+DgqUpF2vQ3k16LIKMOY3vF45XbUjHnzl545JpOiLQaVf3MExEREVFrxBDUDBVODz7ZWOBT7Qfr81Hm49LWDZFlGYu3FcLpQ9D4bEshNAo9QCIEsHr/8UbrDpVUIedYmSJtllS68OGvv/tU+8H6fJS0oaWjtRoNbGY9Qsx6GHXKL7BBRERERAxBzaLXSig46dsMRMHJSkVmSKqcMvJOVPhUe6rCqdiqbcfLqiH7uNp2XrFv/WuMRpJQ6OMMT8HJSnh87SARERERERiCmkUWZx7c90WQQQsNLjyQ6HUSLD4+F6KRoECLZ5h9/JwAFHtuRQgBs4/LjAc1oX9ERERERABDULMIITCye6xPtWN6tUN48IUvjGDQaXFzn3Y1jqVEBmFQxwj0SQqrERqu7hKNKqfngtsEgFCzAUnhf2zSGWbRo19yGAamhNfY0NSo02BgxwhF2jToNbi+Z5xPtaNT42Ezc9EAIiIiIvIdrx6bIdRiwANDOmLhpoM1lqk+X7tQMwamKBMMACAuxIxeiaFIjgjCpLT2MBm0yC+ugEWvRZc4G37YdRTz1uRh6rBOiu1RZNRr8NCQFHy0oQBTBqcgrWMkfjtSCo8s0DXWhrzicsxfm4eEMIsiM14AEGzU40+DkjF3dS6qXfXfShhm0SO9eywMfHaGiIiIiJqAIaiZgg1avD6uNx79bEedQSgiyIBPJw+AQitGAwBCzHp8OKkfso+V4YX/7KmxP5HNrMOd/ZLw/SNXwqhgo3qtBmN6xePqrjH457J9eObrXd6V4jQSMPjSKPy/G7sj2mZQdE8kvQaY/6fLMfmjrXWuTGcz6bBg8gDFnn0iIiIiosDB2+GaSavVoH+HMCyfOQS39U3w3o4WFWzEI8M6YeVjQ2DRa+BR8Jn9smoX9h614+73NtXaoNVe5ca8NXmYvigLyj0RdIZLFhg/fyMWbz9cI5DI4swy1Te/8ytKKpVbChwArGYDeiWEYtXjQ3HXgCTv80ZhFj2mXJWCVY8PRfsICzcQJSIiIqIm4xVkM+07asetczdg5nWX4rHrLsULY7pBI0lweWScKnfi2SW7sGLvcWz567WKtSlJEh79vO6Zp7PWHijGj78dxZjUeBh8XFygIaVVLry2fD9yG1iZrrTKhce+yMK8CZcrdhseAFjNeljNejwxojOeHdUVGo0Etywgy0L1G6QSERERkf8wBDWDvcqFtzNzAQCv/bwfr/28v97ar7cfwl0D2kOvvfBJt19zilFc3vieOB+sz8fwy2IUCUFajYTF2w43Wrfl9xKUO9yKhqCzQi3K/04iIiIiCly8Ha4ZNJKEbQUlPtX+mnNSkZXaqpwerM896VPt3qNlMCkQgACg6HQVyh2+3eq2Of+UIm0SEREREbUkhiAiIiIiIgooDEHNIAuBvu3DfKod1DGiSRuO1sds0OIKH/fh6RpnRbVLmX2CYkPNPm+C2r9DuCJtEhERERG1JIagZrCZ9Xh4aMdG64w6DW7pm6DI80AAkNYpEpE+bLx67xUdEORjcGmMxyPjlr7tGq3rlxzmc1hqqkqnG5VON6pdHlQ43IoFPCIiIiIKTAxBzdQlzoZb+yY0WDP75h7QScotVy2EwJw7e0HXwN44V3aKRHr3OMWCV4jFgJnXXoqUyKB6a2xmHV69LRU2k7KbllY53ThaWoW//7AP/f+2El2eW4YrX16FOSv241SFA043wxARERERNR1DUDMFG3WYdWM3PJPeBVHBxhrnOsdYkXFPP4zoFguLgrMjVpMe3eND8MUDg9A7MbTGOZtZhwcGp+Cdu/tAkhTcnAiAXivhsykDcUufdjU2YtVIwLDO0fj6oSsQFqSHVqtcCKp2epBVeBpD/5WJTzcWeBdnKKl0Ye7qPAz9Vybyiivg8tTeSJWIiIiIqCFcIvsCBBt1mHRFMu4e2B55Jypgr3YhPtSEyGAjLAYttBplM2ZplQuTPtyCW/q0w7w/9UWVS0Z+cTkseh26xFmRd6Icd7+3CS/c2B29kkIVadPh8uDrHUewYFMBpgzuiCdGdMGuw6WQhUCXWCvyiysw67vdaBdmxjPpXRRbzrrK7cE9GVtqbM56Lnu1G+Pnb8LaJ4cpNutFRERERIGBIegCGXVaGHVAj4SQFm+rqLQKWYWnkVV4Gs99uxtDO0ehU3QwKhweLF9Q5N1D6K3MHLx8S0+EK7Bnj9MjY/7aPBScrMSMRVkIs+jRKToYWo2EgycrcaS0GsCZ55+eHdX1gtsDAIfbg082FKDa1fAsz6kKJ37ecww3psYpHjiJiIiIqO1iCFIJp9uDxdtrblqamX0CmdknatWu2nccFgVWpAPO3H5WcLKyxustv9feI8nhlrEupxijesRdcJtVTg++/+8Rn2qXbD+EqztHI8TCEEREREREvuGVo0q43AKVPm5a6pEFhEKPBfnaJgCUV/te2xBJklDp4wazFU4PBJR9BoqIiIiI2jaGIJUwGzRIiap/hbZzhQcZICuUgmJDTGhgMboafO1f4wQSwy0+VSaFW6DjrXBERERE1AS8elQJjUaDW/omwuDDIgDj+iVClpUJQUIAQy6NbrQuIcyMLrE2Rdq0mfSYfGUHn2qnDE5BsIl3dRIRERGR7xiCVEQWApOvajgcRFmNuH9wCqxmvSJthgUZ8MyoLjWWxq7L0+ldGty/qCkkScLAlAj0aNfwYhNDL41CYphvM0ZERERERGcxBKlImMWAh4Z2xINDUuoMHB2jgrDk4TQYtMpt0AoA8SEmLLx/ACKDa682ZzFo8c9be2LwJVEwKbQYAwAEGXX4dPIADOoYUef5UT1i8eb4PpwFIiIiIqIm4xWkipyudOKzTQdx7xUd8MCQjvhs00HkniiHWa/FmN7t0CXWii35J9EjIQwWY+O/z1fBJj26xtqQ+fgwrM8txqp9xyHLAr2TwnBjajxkIWBTaObpXCFmPeZN6IvicicWbCzAqUon4kJMuHtgewQbdQxARERERNQsvIpUEVkAryzfj5d/ysbQS6PwzKguGJ0aByGAbQdLcOf8DfB4gHuvSMaM4ZfCalIumFiMZ4bK8K7RuKJjBAQAi14LbQtvVGo16WE16fFUehe43DL0Og03RyUiIiKiC8IQpBIej4xFWw7C878FDzL3n0Dm/tp7BAHAV9sO4fERnVukHxqNBsGmix9C9FqGHyIiIiJSBq8qVcLpkXG4pMqnWnu1GxKUfS6IiIiIiKitYAhSCb1W8vm5G71WgsQMRERERERUJ4YgldBptbj98kSfakd0i0W1y9PCPSIiIiIiUic+E3SBKhxuCABb8k+htMqFhHAzusbaoNdqYGhkb52mCrXokdYxAr/mnqy3RquR8MjVnRBqqb2cNRERERERMQRdkHKHG/+3Yj8WbDqISucfMy+xNhOeGNEZI7rHItio3FccajHg7bv6YPz8Tdhz1F7rvFYj4dXbUhEXYlasTSIiIiKitoYhqJnKHW5M/3wHVuw9Xutckb0aj325E6ernLizXxKCFA5CXzw4CMt3FyHj19+Rf7ICZr0W13WLxYODU2A16Vtkzx4iIiIioraCIaiZdhwsqTMAnWv2D/twS58ExdsONuowOjUeQzpHQ6+VIMsCGkmCleGHiIiIiKhRXBihGUqrXJi7OrfROrcs8Nnmg3C6lV+kQKfVIDzIAKtJjxCLgQGIiIiIiMhHDEHNoJUk7DpU6lPttoISVLvkFu4RERERERH5iiGoGQQENBrfNuLRarhtKRERERFRa8IQ1AwCwKCUCJ9qh3WOhsWobdkOERERERGRzxiCmsFm0mPqsE6N1lkMWtzQMx5ajfJfc5XTjSqnG2XVLlQ5PbBXuRRvg4iIiIioLeLqcM2UHBGEBwan4N01eXWe12kkvDW+D7Q+3jbnK7dHRlm1G+9k5mLR1kKU/i/8DOgQjmlXd0LvxDAEm/ivlYiIiIioPn6dCVqzZg1Gjx6N+Ph4SJKEb775xp/daZJgkw6PXH0J5tzRCx2jgmucG9QxAl8/nIYBKeEwG5S7Fc4jCxwrc+C6f6/BvLV53gAEAJvyT2HC+5vxzuoclDvcirVJRERERNTW+HXKoKKiAqmpqbj33ntx8803+7MrzRJs0uGGnnG4pms07FVulDtciLIaodNoWmTD0kqnG/d8uBknyh311rz1Sy4GXxKFAT4+s0REREREFGj8GoLS09ORnp7uzy5cMJ1WA6tWA6tJD8Dcom0VnKzE/mPljda9+UsOusbZWiSIERERERGpnaoeHnE4HHA4/pgFsdvtAACXywWX649bw87+87nH1M7tkfHt9oMwakWjtVvyT0AjPGhDH99v2uJYIv/gWCIlcByRUjiWSCmtaSw1pQ+SEKLxq+qLQJIkLFmyBGPHjq23ZtasWXjhhRdqHV+4cCEsFksL9o6IiIiIiFqzyspKjB8/HqWlpbDZbA3WqioE1TUTlJiYiOLi4hof1OVyYfny5Rg+fDj0+rZzS9jibYfw/H92N1oXYzXhP49cAYtBVRN9rVJbHUt08XEskRI4jkgpHEuklNY0lux2OyIjI30KQaq6SjYajTAajbWO6/X6Or/0+o6r1fW9EvDC0mxUuTwN1o0bmAyz0Qi9jttAKaWtjSXyH44lUgLHESmFY4mU0hrGUlPa51WyimgkCY+PuLTBmqRwC+4e2B4GBiAiIiIiojr5dSaovLwcOTk53tf5+fnIyspCeHg4kpKS/Niz1inIqMMd/ZKg1Wjwyk/ZtfYD6pcchrl390UQb4MjIiIiIqqXX6+Wt27dimHDhnlfz5w5EwAwceJEZGRk+KlXrVuwUYfbL0/ArX0TsGLPMew5akeQUYuxvdohzGLgsthERERERI3wawgaOnQoWsm6DKpydsGDsb3b4cbUeGg0kp97RERERESkHnxwROUYgIiIiIiImoYhiIiIiIiIAgpDEBERERERBRSGICIiIiIiCigMQUREREREFFAYgoiIiIiIKKAwBBERERERUUBhCCIiIiIiooDCEERERERERAGFIYiIiIiIiAIKQxAREREREQUUhiAiIiIiIgooDEFERERERBRQGIKIiIiIiCigMAQREREREVFAYQgiIiIiIqKAwhBEREREREQBRefvDlwIIQQAwG631zjucrlQWVkJu90OvV7vj65RG8GxRErhWCIlcByRUjiWSCmtaSydzQRnM0JDVB2CysrKAACJiYl+7gkREREREbUGZWVlCAkJabBGEr5EpVZKlmUcOXIEVqsVkiR5j9vtdiQmJqKwsBA2m82PPSS141gipXAskRI4jkgpHEuklNY0loQQKCsrQ3x8PDSahp/6UfVMkEajQUJCQr3nbTab3/9lUNvAsURK4VgiJXAckVI4lkgprWUsNTYDdBYXRiAiIiIiooDCEERERERERAGlTYYgo9GI559/Hkaj0d9dIZXjWCKlcCyREjiOSCkcS6QUtY4lVS+MQERERERE1FRtciaIiIiIiIioPgxBREREREQUUBiCiIiIiIgooDAEERERERFRQFFtCHrrrbeQnJwMk8mEAQMGYPPmzQ3Wf/nll+jSpQtMJhN69OiBH3744SL1lFq7poyljIwMSJJU48dkMl3E3lJrtGbNGowePRrx8fGQJAnffPNNo+/JzMxEnz59YDQa0alTJ2RkZLR4P6n1a+pYyszMrPU3SZIkFBUVXZwOU6s0e/Zs9OvXD1arFdHR0Rg7diyys7MbfR+vleh8zRlLarlWUmUIWrRoEWbOnInnn38e27dvR2pqKkaMGIHjx4/XWf/rr79i3LhxuO+++7Bjxw6MHTsWY8eOxW+//XaRe06tTVPHEnBmR+SjR496fwoKCi5ij6k1qqioQGpqKt566y2f6vPz83H99ddj2LBhyMrKwvTp0zF58mT89NNPLdxTau2aOpbOys7OrvF3KTo6uoV6SGqwevVqTJ06FRs3bsTy5cvhcrlw3XXXoaKiot738FqJ6tKcsQSo5FpJqFD//v3F1KlTva89Ho+Ij48Xs2fPrrP+9ttvF9dff32NYwMGDBAPPPBAi/aTWr+mjqUPP/xQhISEXKTekRoBEEuWLGmw5sknnxTdunWrceyOO+4QI0aMaMGekdr4MpZ++eUXAUCUlJRclD6ROh0/flwAEKtXr663htdK5AtfxpJarpVUNxPkdDqxbds2XHvttd5jGo0G1157LTZs2FDnezZs2FCjHgBGjBhRbz0FhuaMJQAoLy9H+/btkZiYiDFjxmD37t0Xo7vUhvBvEimtV69eiIuLw/Dhw7F+/Xp/d4damdLSUgBAeHh4vTX8u0S+8GUsAeq4VlJdCCouLobH40FMTEyN4zExMfXeA11UVNSkegoMzRlLnTt3xgcffIBvv/0Wn376KWRZRlpaGg4dOnQxukxtRH1/k+x2O6qqqvzUK1KjuLg4zJ07F4sXL8bixYuRmJiIoUOHYvv27f7uGrUSsixj+vTpuOKKK9C9e/d663itRI3xdSyp5VpJ5+8OEKnJoEGDMGjQIO/rtLQ0dO3aFe+++y5efPFFP/aMiAJR586d0blzZ+/rtLQ05Obm4t///jc++eQTP/aMWoupU6fit99+w7p16/zdFVI5X8eSWq6VVDcTFBkZCa1Wi2PHjtU4fuzYMcTGxtb5ntjY2CbVU2Bozlg6n16vR+/evZGTk9MSXaQ2qr6/STabDWaz2U+9oraif//+/JtEAIBp06bh+++/xy+//IKEhIQGa3mtRA1pylg6X2u9VlJdCDIYDOjbty9WrlzpPSbLMlauXFkjdZ5r0KBBNeoBYPny5fXWU2Bozlg6n8fjwa5duxAXF9dS3aQ2iH+TqCVlZWXxb1KAE0Jg2rRpWLJkCVatWoUOHTo0+h7+XaK6NGcsna/VXiv5e2WG5vj888+F0WgUGRkZYs+ePWLKlCkiNDRUFBUVCSGEmDBhgnj66ae99evXrxc6nU688sorYu/eveL5558Xer1e7Nq1y18fgVqJpo6lF154Qfz0008iNzdXbNu2Tdx5553CZDKJ3bt3++sjUCtQVlYmduzYIXbs2CEAiNdee03s2LFDFBQUCCGEePrpp8WECRO89Xl5ecJisYgnnnhC7N27V7z11ltCq9WKZcuW+esjUCvR1LH073//W3zzzTfiwIEDYteuXeLPf/6z0Gg0YsWKFf76CNQKPPTQQyIkJERkZmaKo0ePen8qKyu9NbxWIl80Zyyp5VpJlSFICCHeeOMNkZSUJAwGg+jfv7/YuHGj99yQIUPExIkTa9R/8cUX4tJLLxUGg0F069ZNLF269CL3mFqrpoyl6dOne2tjYmLEqFGjxPbt2/3Qa2pNzi5TfP7P2bEzceJEMWTIkFrv6dWrlzAYDCIlJUV8+OGHF73f1Po0dSy9/PLLomPHjsJkMonw8HAxdOhQsWrVKv90nlqNusYQgBp/Z3itRL5ozlhSy7WSJIQQF2/eiYiIiIiIyL9U90wQERERERHRhWAIIiIiIiKigMIQREREREREAYUhiIiIiIiIAgpDEBERERERBRSGICIiIiIiCigMQUREREREFFAYgoiIiIiIKKAwBBERqcjp06chSVKtn9DQUH93jYiISDUYgoiIVGjx4sU4evQojh49ijlz5vi7O0RERKrCEEREpCJutxsAEBERgdjYWMTGxiIkJKTO2kmTJtWaMZo+fbr3vCRJ+Oabb7yv33///Vo1ycnJtULWpEmTMHbsWO/rZcuW4corr0RoaCgiIiJwww03IDc3t9HPkpGRUat/vXr18p6XZRmzZ89Ghw4dYDabkZqaiq+++sp7PjMzs85ZsfM/V2FhIW6//XaEhoYiPDwcY8aMwe+//16jLx988AG6desGo9GIuLg4TJs2zfv562sjIyOj1vcohMCf/vQn9OzZEyUlJQCA3NxcjBkzBjExMQgODka/fv2wYsWKRr+f8x06dAjjxo1DeHg4goKCcPnll2PTpk0AgFmzZkGSJDz66KM13jNjxgxIkoRZs2Y1uT0ioraMIYiISEUcDgcAwGg0NlorhMDIkSO9M0aDBg2qt7aiogLPPfccgoODm9yniooKzJw5E1u3bsXKlSuh0Whw0003QZblRvtns9m8/XvsscdqnJ89ezY+/vhjzJ07F7t378aMGTNw9913Y/Xq1TXqsrOzvb/j6NGjNc65XC6MGDECVqsVa9euxfr16xEcHIyRI0fC6XQCAN555x1MnToVU6ZMwa5du/Ddd9+hU6dOAIAtW7Z4f29CQgLmzJnjfX3HHXfU+kyPPvoofv31V/z8888ICwsDAJSXl2PUqFFYuXIlduzYgZEjR2L06NE4ePCgz99xeXk5hgwZgsOHD+O7777Dzp078eSTT9b4jmNiYvDZZ5+huroaAFBdXY0FCxYgJibG53aIiAKFzt8dICIi3506dQoAYLVaG611uVwIDg5GbGwsAMBgMNRb+89//hOXXXaZd6apKW655ZYarz/44ANERUVhz5496N69e4P9MxgM3v6dG8AcDgf+/ve/Y8WKFd7wlpKSgnXr1uHdd9/FkCFDvLXR0dH1PhO1aNEiyLKM9957D5IkAQA+/PBDhIaGIjMzE9dddx1eeuklPPbYY/jzn//sfV+/fv0AAFFRUd5jWq0WISEh3v6e769//SuWLFmCdevW1ahJTU1Famqq9/WLL76IJUuW4LvvvvPOODVm4cKFOHHiBLZs2YLw8HAA8Aa1s2JjY5GUlIQvv/wSEyZMwFdffYWBAwc2KWwREQUKzgQREanI4cOHAQBxcXGN1trtdgQFBTVad+TIEbz22mt49dVX6zz/1FNPITg42PuzYMGCGucPHDiAcePGISUlBTabDcnJyQDQ6MV3Q/3LyclBZWUlhg8fXqPtjz/+2Kdb7c7auXMncnJyYLVavb8jPDwc1dXVyM3NxfHjx3HkyBFcc801Pv/Ourz55pv429/+hs6dO3s//1nl5eV4/PHH0bVrV4SGhiI4OBh79+5tUjjJyspC7969vQGoPlOmTMG8efMAAPPmzcP999/f5M9CRBQIOBNERKQie/bsQVRUVKMXw8CZcNOzZ89G65599lncdtttNWYrzvXEE09g0qRJ3tdPPfUUPB6P9/Xo0aPRvn17zJ8/H/Hx8ZBlGd27d/febtZQ/+Lj4+s8V15eDgBYunQp2rVrV+OcL7cCnvt7+vbtWyu4AWdmeTQaZf5f4ObNm/HDDz9g0qRJePfdd/HAAw94zz3++ONYvnw5XnnlFXTq1Almsxm33npro9/Pucxms0916enpePjhh/H1118jPz8fo0aNwnPPPdfkz0NE1NYxBBERqcjKlSuRlpbWaF1FRQX27t2LZ555psG6rKwsfPXVV8jOzq63JjIyssatV1arFadPnwYAnDx5EtnZ2Zg/fz6uuuoqAMC6det8+CRnnrfp3bt3necuu+wyGI1GHDx4sMatb03Vp08fLFq0CNHR0bDZbHXWJCcnY+XKlRg2bFiz25kzZw7S09Px9ttv45577kF6ejqSkpIAAOvXr8ekSZNw0003ATgTzM5fmKExPXv2xHvvvYdTp041GIC1Wi3uu+8+TJo0CdOnT4dWq232ZyIiast4OxwRkQpUVVXh/fffx48//ogRI0agqKjI+1NaWgohBIqKiuDxeLBv3z6MGzcOoaGhSE9Pb/D3vvLKK5g5c2a9MzKNCQsLQ0REBObNm4ecnBysWrUKM2fObPA9xcXFePbZZ7F+/XpMnDixzhqr1YrHH38cM2bMwEcffYTc3Fxs374db7zxBj766COf+3fXXXchMjISY8aMwdq1a5Gfn4/MzEw8+uijOHToEIAzK6u9+uqreP3113HgwAFvO01xNpjccsstGDVqFCZPnuw9d8kll+Drr79GVlYWdu7cifHjxze6aMT5xo0bh9jYWIwdOxbr169HXl4eFi9ejA0bNtSqfeCBB/CXv/wFDz74YJPaICIKJAxBREQqsGjRIkyePBlCCDz88MOIi4vz/kyfPh12ux1xcXEoLCzErFmz4Ha7sWLFikZXe7NarXjyySeb3S+NRoPPP/8c27ZtQ/fu3TFjxgz861//avA9CxYswE8//YQlS5agf//+9da9+OKLeO655zB79mx07doVI0eOxNKlS9GhQwef+2exWLBmzRokJSXh5ptvRteuXXHfffehurraOzM0ceJEzJkzB2+//Ta6deuGG264AQcOHPC5jfO9+eab2Llzp/fZnNdeew1hYWFIS0vD6NGjMWLECPTp06fGe2bNmlXrWaJzGQwG/Pzzz4iOjsaoUaPQo0cP/OMf/6hzpic2NhZPP/10s4MtEVEgkIQQwt+dICKihmVkZCAjIwOZmZn11kiShPz8/AYvpql1mjhxYo29h4iIqGXxmSAiIhUwm82NLoYQExPDZ0BUSAiBzMxMn5+lIiKiC8eZICIiIiIiCih8JoiIiIiIiAIKQxAREREREQUUhiAiIiIiIgooDEFERERERBRQGIKIiIiIiCigMAQREREREVFAYQgiIiIiIqKAwhBEREREREQBhSGIiIiIiIgCCkMQEREREREFlP8P9aItKunt/VoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Покажем на графике, что отражаем полученное число.\n", + "# Красным цветом обозначим точки, для которых классификация сработала неправильно.\n", + "plt.figure(figsize=(10, 7))\n", + "sns.scatterplot(x='petal_width_cm', y='petal_length_cm', data=iris, hue='species', s=70)\n", + "plt.xlabel('Длина лепестка, см')\n", + "plt.ylabel('Ширина лепестка, см')\n", + "plt.legend(loc=2)\n", + "plt.grid()\n", + "\n", + "# Перебираем все объекты из теста\n", + "for i in range(len(y_test)):\n", + " # Если предсказание неправильное\n", + " if np.array(y_test)[i] != y_pred[i]:\n", + " # то подсвечиваем точку красным\n", + " plt.scatter(X_test.iloc[i, 3], X_test.iloc[i, 2], color='red', s=150)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: 0.913\n" + ] + } + ], + "source": [ + "# качество модели (доля правильно классифицированных точек)\n", + "print(f'accuracy: {accuracy_score(y_test, y_pred):.3f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3.2 Задание\n", + "\n", + "Определите набор признаков человека, по аналогии из РТ 1, – например, \n", + "цвет глаз и конвертируйте его в матрицу признаков. " + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2., 0., 3., 1.],\n", + " [0., 1., 1., 1.],\n", + " [5., 3., 0., 5.],\n", + " [3., 4., 2., 0.]])" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_dict = [{\"карий\": 3, \"голубой\":2, \"серый\":1}, \n", + " {\"карий\": 1, \"зеленый\":1, \"серый\":1},\n", + " {\"зеленый\": 3, \"голубой\":5, \"серый\":5},\n", + " {\"карий\": 2, \"голубой\":3, \"зеленый\":4}]\n", + "\n", + "dictvectoriser = DictVectorizer(sparse=False)\n", + "\n", + "features = dictvectoriser.fit_transform(data_dict)\n", + "features" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Third term/Artificial intelligence systems and big data/4.ipynb b/Third term/Artificial intelligence systems and big data/4.ipynb new file mode 100644 index 0000000..5e1982d --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/4.ipynb @@ -0,0 +1,1357 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Рабочая тетрадь No 4" + ] + }, + { + "cell_type": "code", + "execution_count": 478, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1.3 Задание\n", + "\n", + "Представьте собственные данные и постройте эктраполяцию полиномами \n", + "первой, второй и третьей степени. " + ] + }, + { + "cell_type": "code", + "execution_count": 479, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-5.1585996 -4.46639064 -2.55830037 -2.0590825 -0.53638287 0.3553611\n", + " 0.60294719 2.45189108 3.28141706 4.08769096 4.92161744]\n", + "[24.70826208 16.36113899 9.04877285 4.01427977 1.02983411 0.38854345\n", + " 0.74865966 4.11727242 9.13843478 15.83010792 24.60875347]\n" + ] + } + ], + "source": [ + "delta = 1.0\n", + "x = np.linspace(-5, 5, 11)\n", + "y = x ** 2 + delta * (np.random.rand(11) - 0.5)\n", + "x += delta * (np.random.rand(11) - 0.5)\n", + "\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Эктраполяция полиномом первой степени" + ] + }, + { + "cell_type": "code", + "execution_count": 480, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = np.vstack((x, np.ones(11))).T\n", + "s = np.linalg.lstsq(m,y,rcond = None)[0]\n", + "\n", + "x_prec = np.linspace(-5, 5, 101)\n", + "\n", + "plt.plot(x, y,'D')\n", + "plt.plot(x_prec, s[0] * x_prec + s[1], '-', lw=1)\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Эктраполяция полиномом второй степени" + ] + }, + { + "cell_type": "code", + "execution_count": 481, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = np.vstack((x**2, x, np.ones(11))).T\n", + "s = np.linalg.lstsq(m, y, rcond = None)[0]\n", + "\n", + "x_prec = np.linspace(-5, 5, 101)\n", + "\n", + "plt.plot(x, y,'D')\n", + "plt.plot(x_prec, s[0] * x_prec**2 + s[1] * x_prec + s[2], '-', lw=2)\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Эктраполяция полиномом третьей степени" + ] + }, + { + "cell_type": "code", + "execution_count": 482, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = np.vstack((x**3, x**2, x, np.ones(11))).T\n", + "s = np.linalg.lstsq(m, y, rcond = None)[0]\n", + "\n", + "x_prec = np.linspace(-5, 5, 101)\n", + "\n", + "plt.plot(x, y,'D')\n", + "plt.plot(x_prec, s[0] * x_prec**3 + s[1] * x_prec**2 + s[2] * x_prec + s[3], '-', lw=3)\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1.5 Задача\n", + "\n", + "Необходимо проверить гипотезу, что наши точечно заданная функция ложится \n", + "на кривые вида: \n", + "1. $f(x,b) = b_0+b_1x$\n", + "2. $f(x,b) = b_0+b_1x+b_2x^2$\n", + "3. $f(x,b) = b_0+b_1\\ln(x)$\n", + "4. $f(x,b) = b_0x^{b_1}$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Функция №1" + ] + }, + { + "cell_type": "code", + "execution_count": 483, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.2474115 1.73859228]\n", + "0.0001438268762724966\n", + "0.12646845774981774\n" + ] + } + ], + "source": [ + "beta = (1.24, 1.74)\n", + "def f(x, b0, b1):\n", + " return b0 + b1 * x\n", + "\n", + "xdata = np.linspace(0,5,50)\n", + "y = f(xdata, *beta)\n", + "ydata = y + 0.05 * np.random.randn(len(xdata))\n", + "\n", + "from scipy.optimize import curve_fit\n", + "beta_opt, beta_cov = curve_fit(f, xdata, ydata)\n", + "print(beta_opt)\n", + "\n", + "lin_dev = sum(beta_cov[0])\n", + "print(lin_dev)\n", + "\n", + "residuals = ydata - f(xdata, *beta_opt)\n", + "fres = sum(residuals**2)\n", + "print(fres)" + ] + }, + { + "cell_type": "code", + "execution_count": 484, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, y, 'r', lw=2)\n", + "ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2)\n", + "ax.set_xlim(0,5)\n", + "ax.set_xlabel(r'$x$', fontsize=18)\n", + "ax.set_ylabel(r'$f(x, \\beta)$', fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Функция №2" + ] + }, + { + "cell_type": "code", + "execution_count": 485, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.53903101 2.70563694 1.17692555]\n", + "0.00014584672644415915\n", + "0.12162090612880988\n" + ] + } + ], + "source": [ + "beta = (0.51, 2.74, 1.17)\n", + "def f(x, b0, b1, b2):\n", + " return b0 + b1 * x + b2 * x**2\n", + "\n", + "xdata = np.linspace(0,5,50)\n", + "y = f(xdata, *beta)\n", + "ydata = y + 0.05 * np.random.randn(len(xdata))\n", + "\n", + "from scipy.optimize import curve_fit\n", + "beta_opt, beta_cov = curve_fit(f, xdata, ydata)\n", + "print(beta_opt)\n", + "\n", + "lin_dev = sum(beta_cov[0])\n", + "print(lin_dev)\n", + "\n", + "residuals = ydata - f(xdata, *beta_opt)\n", + "fres = sum(residuals**2)\n", + "print(fres)" + ] + }, + { + "cell_type": "code", + "execution_count": 486, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, y, 'r', lw=2)\n", + "ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2)\n", + "ax.set_xlim(0,5)\n", + "ax.set_xlabel(r'$x$', fontsize=18)\n", + "ax.set_ylabel(r'$f(x, \\beta)$', fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Функция №3" + ] + }, + { + "cell_type": "code", + "execution_count": 487, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.36588575 0.48465322]\n", + "3.7836263532723186e-05\n", + "0.11229032607799314\n" + ] + } + ], + "source": [ + "beta = (1.37, 0.48)\n", + "\n", + "def f(x, b0, b1):\n", + " return b0 + b1 * np.log(x)\n", + "\n", + "xdata = np.linspace(0.01,5,50)\n", + "y = f(xdata, *beta)\n", + "ydata = y + 0.05 * np.random.randn(len(xdata))\n", + "\n", + "from scipy.optimize import curve_fit\n", + "beta_opt, beta_cov = curve_fit(f, xdata, ydata)\n", + "print(beta_opt)\n", + "\n", + "lin_dev = sum(beta_cov[0])\n", + "print(lin_dev)\n", + "\n", + "residuals = ydata - f(xdata, *beta_opt)\n", + "fres = sum(residuals**2)\n", + "print(fres)" + ] + }, + { + "cell_type": "code", + "execution_count": 488, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, y, 'r', lw=2)\n", + "ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2)\n", + "ax.set_xlim(0,5)\n", + "ax.set_xlabel(r'$x$', fontsize=18)\n", + "ax.set_ylabel(r'$f(x, \\beta)$', fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Функция №4" + ] + }, + { + "cell_type": "code", + "execution_count": 489, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.8817479 1.92063655]\n", + "0.00010562358913983954\n", + "0.14631327681648387\n" + ] + } + ], + "source": [ + "beta = (0.89, 1.92)\n", + "def f(x, b0, b1):\n", + " return b0 + np.float_power(x, b1)\n", + "\n", + "xdata = np.linspace(0,5,50)\n", + "y = f(xdata, *beta)\n", + "ydata = y + 0.05 * np.random.randn(len(xdata))\n", + "\n", + "from scipy.optimize import curve_fit\n", + "beta_opt, beta_cov = curve_fit(f, xdata, ydata)\n", + "print(beta_opt)\n", + "\n", + "lin_dev = sum(beta_cov[0])\n", + "print(lin_dev)\n", + "\n", + "residuals = ydata - f(xdata, *beta_opt)\n", + "fres = sum(residuals**2)\n", + "print(fres)" + ] + }, + { + "cell_type": "code", + "execution_count": 490, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, y, 'r', lw=2)\n", + "ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2)\n", + "ax.set_xlim(0,5)\n", + "ax.set_xlabel(r'$x$', fontsize=18)\n", + "ax.set_ylabel(r'$f(x, \\beta)$', fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.1 Задание\n", + "\n", + "Постройте модель линейной регрессии для произвольных данных из двух \n", + "столбцов. Для примера можно взять точечную зависимость заработной платы от \n", + "опыта работы: \n", + "(https://raw.githubusercontent.com/AnnaShestova/salary-years-simple-linear-regression/master/Salary_Data.csv). \n", + "Найдите коэффициенты линии регрессии. Постройте прогноз. " + ] + }, + { + "cell_type": "code", + "execution_count": 491, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearsExperienceSalary
count30.00000030.000000
mean5.31333376003.000000
std2.83788827414.429785
min1.10000037731.000000
25%3.20000056720.750000
50%4.70000065237.000000
75%7.700000100544.750000
max10.500000122391.000000
\n", + "
" + ], + "text/plain": [ + " YearsExperience Salary\n", + "count 30.000000 30.000000\n", + "mean 5.313333 76003.000000\n", + "std 2.837888 27414.429785\n", + "min 1.100000 37731.000000\n", + "25% 3.200000 56720.750000\n", + "50% 4.700000 65237.000000\n", + "75% 7.700000 100544.750000\n", + "max 10.500000 122391.000000" + ] + }, + "execution_count": 491, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/AnnaShestova/salary-years-simple-linear-regression/master/Salary_Data.csv'\n", + "\n", + "ds = pd.read_csv(url)\n", + "\n", + "ds.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 492, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAGwCAYAAACAZ5AeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+jElEQVR4nO3df3hT5f3/8Vda6A+hDRRt02rBDhEoRQEZtYI6tVgmdnZzU1hxDJnuy2BSUQfOQWETEdRNUCni9hnbwB/oNdGidp8OnAysLbRULCCiVkFsQCkk5UcLNuf7Rz+NhLbQhtMkbZ6P68q15Zw7J+9EJS/Ouc/7thiGYQgAAADnJMTfBQAAAHQGhCoAAAATEKoAAABMQKgCAAAwAaEKAADABIQqAAAAExCqAAAATNDF3wUEE5fLpS+//FJRUVGyWCz+LgcAALSCYRiqqalRQkKCQkJaPh9FqPKhL7/8UomJif4uAwAAeGHv3r266KKLWtxPqPKhqKgoSQ3/UKKjo/1cDQAAaA2n06nExET373hLCFU+1HjJLzo6mlAFAEAHc7apO0xUBwAAMAGhCgAAwASEKgAAABMQqgAAAExAqAIAADABoQoAAMAEhCoAAAATEKoAAABMQKgCAAAwAR3VAQBAwKp3GSqprNaBmlrFRkVoRFKMQkPO3NncXwhVAAAgIBVUVGle/g5VOWrd2+KtEcrNTNaYlHg/VtY8Lv8BAICAU1BRpSkryzwClSTZHbWasrJMBRVV7m31LkNFnxzUa+X7VPTJQdW7DF+XK4kzVQAAIMDUuwzNy9+h5qKRIckiaV7+Do1Otqlwhz1gzmZxpgoAAASUksrqJmeoTmVIqnLU6un1H7f6bJYvEKoAAEBAOVDTcqA61V83VbZ4NktqOJvly0uBhCoAABBQYqMiWjXu8PGTLe5rPJtVUlltUlVnR6gCAAABZURSjOKtEWqpcYJFUo/Irq06VmvPepmBUAUAAAJKaIhFuZnJktQkWDU+nzTy4lYdq7VnvcxAqAIAAAFnTEq88iYMk83qGYps1gjlTRimadf3O+vZrHhrQ7NQX6GlAgAACEhjUuI1OtnWYkf13MxkTVlZJovkMWG9MWjlZib7tPu6X89UbdiwQZmZmUpISJDFYtGaNWvc+06ePKmZM2dq8ODB6tatmxISEvSzn/1MX375pccxqqurlZ2drejoaPXo0UOTJ0/WkSNHPMZs27ZNV199tSIiIpSYmKhFixY1qeXll1/WgAEDFBERocGDB+vNN9/02G8YhubMmaP4+HhFRkYqPT1du3fvNu/LAAAATYSGWJTWt5duGXKh0vr28ghJZzubFVR9qo4eParLL79czzzzTJN9x44dU1lZmWbPnq2ysjL985//1K5du/SDH/zAY1x2dra2b9+uwsJCrV27Vhs2bNDdd9/t3u90OnXjjTeqT58+Ki0t1WOPPaa5c+dq+fLl7jHvvvuuxo8fr8mTJ2vr1q3KyspSVlaWKioq3GMWLVqkJUuWaNmyZSouLla3bt2UkZGh2lrfTYADAACexqTEa+PM6/XCXVdq8bgheuGuK7Vx5vX+WcbGCBCSjFdfffWMY0pKSgxJxueff24YhmHs2LHDkGRs3rzZPeatt94yLBaLsW/fPsMwDGPp0qVGz549jbq6OveYmTNnGv3793c/v+2224yxY8d6vFdqaqrxy1/+0jAMw3C5XIbNZjMee+wx9/7Dhw8b4eHhxgsvvNBivbW1tYbD4XA/9u7da0gyHA7HWb4NAAAQKBwOR6t+vzvURHWHwyGLxaIePXpIkoqKitSjRw8NHz7cPSY9PV0hISEqLi52j7nmmmsUFhbmHpORkaFdu3bp0KFD7jHp6eke75WRkaGioiJJUmVlpex2u8cYq9Wq1NRU95jmLFiwQFar1f1ITEw8ty8AAAAErA4TqmprazVz5kyNHz9e0dHRkiS73a7Y2FiPcV26dFFMTIzsdrt7TFxcnMeYxudnG3Pq/lNf19yY5jz44INyOBzux969e9v0mQEAQMfRIe7+O3nypG677TYZhqG8vDx/l9Nq4eHhCg8P93cZAADABwL+TFVjoPr8889VWFjoPkslSTabTQcOHPAY/80336i6ulo2m809Zv/+/R5jGp+fbcyp+099XXNjAABAcAvoUNUYqHbv3q1///vf6tWrl8f+tLQ0HT58WKWlpe5t69evl8vlUmpqqnvMhg0bdPLkt+sDFRYWqn///urZs6d7zLp16zyOXVhYqLS0NElSUlKSbDabxxin06ni4mL3GAAAENz8GqqOHDmi8vJylZeXS2qYEF5eXq49e/bo5MmT+vGPf6wtW7Zo1apVqq+vl91ul91u14kTJyRJAwcO1JgxY3TXXXeppKREmzZt0rRp0zRu3DglJCRIkn76058qLCxMkydP1vbt2/XSSy9p8eLFmjFjhruO6dOnq6CgQE888YQ+/PBDzZ07V1u2bNG0adMkSRaLRTk5OXr44Yf1+uuv64MPPtDPfvYzJSQkKCsry6ffGQAACFC+uRmxeW+//bahhiaoHo+JEycalZWVze6TZLz99tvuYxw8eNAYP3680b17dyM6OtqYNGmSUVNT4/E+77//vjFq1CgjPDzcuPDCC41HH320SS2rV682Lr30UiMsLMwYNGiQ8cYbb3jsd7lcxuzZs424uDgjPDzcuOGGG4xdu3a16fO29pZMAAAQOFr7+20xDMNoNm3BdE6nU1arVQ6Hw2NuGAAA/lTvMlpcCgat//3uEHf/AQCA9lFQUaV5+TtU5fh2hZB4a4RyM5P905W8AwvoieoAAKD9FFRUacrKMo9AJUl2R62mrCxTQUWVnyrrmAhVAAAEoXqXoXn5O9TcHKDGbfPyd6jexSyh1iJUAQAQhEoqq5ucoTqVIanKUauSymrfFdXBEaoAAAhCB2paDlTejAOhCgCAoBQbFWHqOBCqAAAISiOSYhRvjVBLjRMsargLcERSjC/L6tAIVQAABKHQEItyM5MlqUmwanyem5lMv6o2IFQBABCkxqTEK2/CMNmsnpf4bNYI5U0YRp+qNqL5JwAAQWxMSrxGJ9voqG4CQhUAAEEuNMSitL69/F1Gh8flPwAAABNwpgoAgP/DwsI4F4QqAADEwsI4d1z+AwAEPRYWhhkIVQCAoMbCwjALoQoAENRYWBhmYU4VACCosbBw85i033aEKgBAUGNh4aaYtO8dLv8BAIIaCwt7YtK+9whVAICgxsLC32LS/rkhVAEAgh4LCzdg0v65YU4VAABiYWGJSfvnilAFAMD/CfaFhZm0f264/AcAACQxaf9cEaoAAIAkJu2fK0IVAABwY9K+95hTBQAAPDBp3zuEKgAA0ESwT9r3BqEKAAAfYT29zo1QBQCAD7CeXufHRHUAANoZ6+kFB0IVAADtiPX0ggehCgCAdsR6esGDUAUAQDtiPb3gQagCAKAdsZ5e8CBUAQDQjlhPL3gQqgAAaEespxc8CFUAALQz1tMLDjT/BADAB1hPr/MjVAEA4COsp9e5cfkPAADABIQqAAAAExCqAAAATECoAgAAMAET1QEACHD1LoO7BjsAQhUAAAGsoKJK8/J3eCzKHG+NUG5mMv2tAgyX/wAACFAFFVWasrLMI1BJkt1Rqykry1RQUeWnytAcQhUAAAGo3mVoXv4OGc3sa9w2L3+H6l3NjYA/EKoAAAhAJZXVTc5QncqQVOWoVUllte+KwhkRqgAACEAHaloOVN6MQ/sjVAEAEIBioyLOPqgN49D+CFUAAASgEUkxirdGqKXGCRY13AU4IinGl2XhDAhVAAAEoNAQi3IzkyWpSbBqfJ6bmUy/qgBCqAIAIECNSYlX3oRhslk9L/HZrBHKmzCMPlUBhuafAAAEsDEp8RqdbKOjegdAqAIAIMCFhliU1reXv8vAWXD5DwAAwASEKgAAABMQqgAAAExAqAIAADABoQoAAMAE3P0HAOh06l0GLQjgc4QqAECnUlBRpXn5O1Tl+Hah4XhrhHIzk2mWiXbF5T8AQKdRUFGlKSvLPAKVJNkdtZqyskwFFVV+qgzBgFAFAOgU6l2G5uXvkNHMvsZt8/J3qN7V3Ajg3BGqAACdQklldZMzVKcyJFU5alVSWe27ohBUCFUAgE7hQE3LgcqbcUBb+TVUbdiwQZmZmUpISJDFYtGaNWs89huGoTlz5ig+Pl6RkZFKT0/X7t27PcZUV1crOztb0dHR6tGjhyZPnqwjR454jNm2bZuuvvpqRUREKDExUYsWLWpSy8svv6wBAwYoIiJCgwcP1ptvvtnmWgAA/hMbFWHqOKCt/Bqqjh49qssvv1zPPPNMs/sXLVqkJUuWaNmyZSouLla3bt2UkZGh2tpv/5aRnZ2t7du3q7CwUGvXrtWGDRt09913u/c7nU7deOON6tOnj0pLS/XYY49p7ty5Wr58uXvMu+++q/Hjx2vy5MnaunWrsrKylJWVpYqKijbVAgDwnxFJMYq3RqilxgkWNdwFOCIpxpdlIYhYDMMIiBl7FotFr776qrKysiQ1nBlKSEjQfffdp/vvv1+S5HA4FBcXpxUrVmjcuHHauXOnkpOTtXnzZg0fPlySVFBQoJtuuklffPGFEhISlJeXp4ceekh2u11hYWGSpFmzZmnNmjX68MMPJUm33367jh49qrVr17rrufLKKzVkyBAtW7asVbW0htPplNVqlcPhUHR0tCnfGwDgW413/0nymLDeGLTyJgyjrQLarLW/3wE7p6qyslJ2u13p6enubVarVampqSoqKpIkFRUVqUePHu5AJUnp6ekKCQlRcXGxe8w111zjDlSSlJGRoV27dunQoUPuMae+T+OYxvdpTS3Nqaurk9Pp9HgAANrPmJR45U0YJpvV8xKfzRpBoEK7C9jmn3a7XZIUFxfnsT0uLs69z263KzY21mN/ly5dFBMT4zEmKSmpyTEa9/Xs2VN2u/2s73O2WpqzYMECzZs37+wfFgBgmjEp8RqdbKOjOnwuYENVZ/Dggw9qxowZ7udOp1OJiYl+rAgAgkNoiEVpfXv5uwwEmYC9/Gez2SRJ+/fv99i+f/9+9z6bzaYDBw547P/mm29UXV3tMaa5Y5z6Hi2NOXX/2WppTnh4uKKjoz0eANBZ1LsMFX1yUK+V71PRJwdpqomgF7ChKikpSTabTevWrXNvczqdKi4uVlpamiQpLS1Nhw8fVmlpqXvM+vXr5XK5lJqa6h6zYcMGnTx50j2msLBQ/fv3V8+ePd1jTn2fxjGN79OaWgAgmBRUVGnUwvUa/9x7mv5iucY/955GLVzPMjAIan4NVUeOHFF5ebnKy8slNUwILy8v1549e2SxWJSTk6OHH35Yr7/+uj744AP97Gc/U0JCgvsOwYEDB2rMmDG66667VFJSok2bNmnatGkaN26cEhISJEk//elPFRYWpsmTJ2v79u166aWXtHjxYo/LctOnT1dBQYGeeOIJffjhh5o7d662bNmiadOmSVKragGAYMH6ekDz/NpS4T//+Y+uu+66JtsnTpyoFStWyDAM5ebmavny5Tp8+LBGjRqlpUuX6tJLL3WPra6u1rRp05Sfn6+QkBDdeuutWrJkibp37+4es23bNk2dOlWbN2/W+eefr1//+teaOXOmx3u+/PLL+t3vfqfPPvtM/fr106JFi3TTTTe597emlrOhpQKAjq7eZWjUwvUtLgdjUcOddhtnXs/EcHQarf39Dpg+VcGAUAWgoyv65KDGP/feWce9cNeVTBRHp9Hh+1QBAAIP6+sBLSNUAQBajfX1gJYRqgAArcb6ekDLCFUAgFYLDbEoNzNZkpoEq8bnuZnJTFJHUCJUAQDahPX1gOaxTA0AoM1YXw9oilAFAPAK6+sBnrj8BwAAYAJCFQAAgAkIVQAAACYgVAEAAJiAUAUAAGAC7v4DAB+odxm0HwA6OUIVALSzgooqzcvfoSrHt4sMx1sjlJuZTKNMoBPh8h8AtKOCiipNWVnmEagkye6o1ZSVZSqoqPJTZQDMRqgCgHZS7zI0L3+HjGb2NW6bl79D9a7mRgDoaAhVANBOSiqrm5yhOpUhqcpRq5LKat8VBaDdEKoAoJ0cqGk5UHkzDkBgI1QBQDuJjYowdRyAwEaoAoB2MiIpRvHWCLXUOMGihrsARyTF+LIsAO2EUAUA7SQ0xKLczGRJahKsGp/nZibTrwroJAhVANCOxqTEK2/CMNmsnpf4bNYI5U0YFhB9qupdhoo+OajXyvep6JOD3I0IeInmnwDQzsakxGt0si0gO6rTmBQwj8UwDP5K4iNOp1NWq1UOh0PR0dH+LgdAkGtsTHr6j0Bj1AuUM2mAv7X295vLfwAQhGhMCpiPUAUAQYjGpID5CFUAEIRoTAqYj1AFAEGIxqSA+QhVABCEaEwKmI9QBQBBiMakgPkIVQAQpDpCY1KgI6H5JwAEsUBuTAp0NIQqAAhyoSEWpfXt5e8ygA6Py38AAAAmIFQBAACYgFAFAABgAkIVAACACQhVAAAAJiBUAQAAmIBQBQAAYAJCFQAAgAm8bv559OhRvfPOO9qzZ49OnDjhse+ee+4558IAAAA6Eq9C1datW3XTTTfp2LFjOnr0qGJiYvT111/rvPPOU2xsLKEKAAAEHa8u/917773KzMzUoUOHFBkZqffee0+ff/65rrjiCj3++ONm1wgAABDwvApV5eXluu+++xQSEqLQ0FDV1dUpMTFRixYt0m9/+1uzawQAAAh4XoWqrl27KiSk4aWxsbHas2ePJMlqtWrv3r3mVQcAANBBeDWnaujQodq8ebP69euna6+9VnPmzNHXX3+tf/zjH0pJSTG7RgAAgIDn1ZmqRx55RPHx8ZKk+fPnq2fPnpoyZYq++uorLV++3NQCAQAAOgKLYRiGv4sIFk6nU1arVQ6HQ9HR0f4uBwAAtEJrf7+9OlN1/fXX6/Dhw97WBgAA0Ol4Far+85//NGn4CQAAEMy8XqbGYrGYWQcAAECH5vUyNT/84Q8VFhbW7L7169d7XRAAAEBH5HWoSktLU/fu3c2sBQAAoMPyKlRZLBY98MADio2NNbseAACADsmrUEUXBgAdSb3LUElltQ7U1Co2KkIjkmIUGsK8UADm8ipU5ebmcukPQIdQUFGlefk7VOWodW+Lt0YoNzNZY1Li/VgZgM6G5p8+RPNPwLcKKqo0ZWWZTv9DrvEcVd6EYQQrAGfV2t9vryeqv/LKK1q9erX27NnTpGdVWVmZt4cFAFPUuwzNy9/RJFBJkqGGYDUvf4dGJ9u4FAjAFF71qVqyZIkmTZqkuLg4bd26VSNGjFCvXr306aef6vvf/77ZNQJAm5VUVntc8judIanKUauSymrfFQWgU/MqVC1dulTLly/XU089pbCwMP3mN79RYWGh7rnnHjkcDrNrBIA2O1DTcqDyZhwAnI1XoWrPnj266qqrJEmRkZGqqamRJN1xxx164YUXzKsOALwUGxVh6jgAOBuvQpXNZlN1dcMp8969e+u9996TJFVWVtJuAUBAGJEUo3hrhFqaLWVRw12AI5Ji2uX9612Gij45qNfK96nok4Oqd/FnI9DZeTVR/frrr9frr7+uoUOHatKkSbr33nv1yiuvaMuWLfrRj35kdo0A0GahIRblZiZrysoyWSSPCeuNQSs3M7ldJqnTxgEITl61VHC5XHK5XOrSpSGTvfjii3r33XfVr18//fKXv2xxTcBgR0sFwPd8HXBo4wB0Pq39/aZPlQ8RqgD/8FVH9XqXoVEL17d416FFks0aoY0zr6eNA9CBtGufqtdff/2M+3/wgx94c1gAaBehIRal9e3V7u/TljYOvqgHgG95FaqysrJa3GexWFRfX+9tPQDQYdHGAQhuXt39J0lVVVXuuVWnPghUAIIVbRyA4OZ1qAoJ8fqlrVZfX6/Zs2crKSlJkZGR6tu3r/7whz94tG0wDENz5sxRfHy8IiMjlZ6ert27d3scp7q6WtnZ2YqOjlaPHj00efJkHTlyxGPMtm3bdPXVVysiIkKJiYlatGhRk3pefvllDRgwQBERERo8eLDefPPN9vngADokf7dxAOBfXiej5557Tnl5efr73/+uf//73/r666/NrEuStHDhQuXl5enpp5/Wzp07tXDhQi1atEhPPfWUe8yiRYu0ZMkSLVu2TMXFxerWrZsyMjJUW/vt6fXs7Gxt375dhYWFWrt2rTZs2KC7777bvd/pdOrGG29Unz59VFpaqscee0xz587V8uXL3WPeffddjR8/XpMnT9bWrVuVlZWlrKwsVVRUmP65AXRMjW0cJDUJVu3dxgGA/3l199/FF18sSTp58qScTqeOHj2qkJAQjR07Vv/4xz9Mu7Pt5ptvVlxcnP7yl7+4t916662KjIzUypUrZRiGEhISdN999+n++++XJDkcDsXFxWnFihUaN26cdu7cqeTkZG3evFnDhw+XJBUUFOimm27SF198oYSEBOXl5emhhx6S3W53t4OYNWuW1qxZow8//FCSdPvtt+vo0aNau3atu5Yrr7xSQ4YM0bJly5qtv66uTnV1de7nTqdTiYmJ3P0HdHL0qQI6l9be/efVmarPPvtMn332mfbt26eamho5HA7961//0kcffaTf/OY3Xhd9uquuukrr1q3TRx99JEl6//33tXHjRveizZWVlbLb7UpPT3e/xmq1KjU1VUVFRZKkoqIi9ejRwx2oJCk9PV0hISEqLi52j7nmmms8+mtlZGRo165dOnTokHvMqe/TOKbxfZqzYMECWa1W9yMxMfFcvg4AHcSYlHhtnHm9XrjrSi0eN0Qv3HWlNs68nkAFdHJe3f13uqioKN1www1aunSpJk+ebMYhJTWcLXI6nRowYIBCQ0NVX1+v+fPnKzs7W5Jkt9slSXFxcR6vi4uLc++z2+2KjY312N+lSxfFxMR4jElKSmpyjMZ9PXv2lN1uP+P7NOfBBx/UjBkz3M8bz1QB6Px81cYBQOAwJVQ1uu666/Tpp5+adrzVq1dr1apVev755zVo0CCVl5crJydHCQkJmjhxomnv017Cw8MVHh7u7zIAAIAPeBWqtm3bdsb9l112mVfFnO6BBx7QrFmzNG7cOEnS4MGD9fnnn2vBggWaOHGibDabJGn//v2Kj//2tPr+/fs1ZMgQSQ2LPx84cMDjuN98842qq6vdr7fZbNq/f7/HmMbnZxvTuB8AAAQ3r0LVkCFDZLFYPFobND43s/nnsWPHmrRuCA0NlcvlkiQlJSXJZrNp3bp17hDldDpVXFysKVOmSJLS0tJ0+PBhlZaW6oorrpAkrV+/Xi6XS6mpqe4xDz30kE6ePKmuXbtKkgoLC9W/f3/17NnTPWbdunXKyclx11JYWKi0tDRTPisAAOjYvL78V1xcrAsuuMDMWprIzMzU/Pnz1bt3bw0aNEhbt27VH//4R915552SGoJcTk6OHn74YfXr109JSUmaPXu2EhIS3F3fBw4cqDFjxuiuu+7SsmXLdPLkSU2bNk3jxo1TQkKCJOmnP/2p5s2bp8mTJ2vmzJmqqKjQ4sWL9ac//cldy/Tp03XttdfqiSee0NixY/Xiiy9qy5YtHm0XAABAEDO8YLFYjP3793vz0jZxOp3G9OnTjd69exsRERHGd77zHeOhhx4y6urq3GNcLpcxe/ZsIy4uzggPDzduuOEGY9euXR7HOXjwoDF+/Hije/fuRnR0tDFp0iSjpqbGY8z7779vjBo1yggPDzcuvPBC49FHH21Sz+rVq41LL73UCAsLMwYNGmS88cYbbfo8DofDkGQ4HI42vQ4AAPhPa3+/vepTFRIS0uxddTiz1va5AAAAgaNd+1RZLBZZLHQEBgAAaOTVnCrDMHTppZe2GKyqq6vPqSgAAICOxqtQ9de//tXsOgAAADo0r0JVR2i8CQAA4Etet1Sor6/Xq6++qp07d0qSkpOTdcstt6hLF1ObtAMAAHQIXiWg7du36wc/+IHsdrv69+8vSVq4cKEuuOAC5efnKyUlxdQiAQAAAp1Xd//94he/0KBBg/TFF1+orKxMZWVl2rt3ry677DLdfffdZtcIAAAQ8Lw6U1VeXq4tW7a4l3CRpJ49e2r+/Pn67ne/a1pxAAAAHYVXZ6ouvfTSJosLS9KBAwd0ySWXnHNRAAAAHY1XoWrBggW655579Morr+iLL77QF198oVdeeUU5OTlauHChnE6n+wEAABAMvF6mxn2A/2sA2niYU59bLBbV19ebUWenwDI1AAB0PK39/fZqTtXbb7/tdWEAAACdkVeh6tprrzW7DgAAgA7tnDp1Hjt2THv27NGJEyc8tl922WXnVBQAAEBH41Wo+uqrrzRp0iS99dZbze5nHhUAAAg2Xt39l5OTo8OHD6u4uFiRkZEqKCjQ3/72N/Xr10+vv/662TUCAAAEPK/OVK1fv16vvfaahg8frpCQEPXp00ejR49WdHS0FixYoLFjx5pdJwAAQEDz6kzV0aNHFRsbK6mhk/pXX30lSRo8eLDKysrMqw4AAKCD8CpU9e/fX7t27ZIkXX755Xr22We1b98+LVu2TPHx8aYWCAAA0BF4dflv+vTpqqqqkiTl5uZqzJgxWrlypcLCwvS3v/3N1AIBAAA6Aq86qp/u2LFj+vDDD9W7d2+df/75ZtTVKdFRHQCAjqe1v99tvvy3fPlyTZgwQatWrXI/HzJkiG677TbOUgEAgKDVpst/q1at0n333acbb7xRDzzwgD7++GM9+eSTuv/+++VyufT73/9eSUlJ+tGPftRe9QIAAASkNoWqpUuXKi8vTxMmTFBpaalSU1OVl5enu+66S5KUkJCgp556ilAFAACCTpsu/+3cuVNpaWmSpCuuuEIhISFKTU1177/mmmv0wQcfmFshAABAB9CmUFVXV6fzzjvP/Tw8PFzdu3d3P4+MjGSJGgAAEJTaFKouvPBCffzxx+7nK1eu9OhLtWvXLl188cWmFQcAANBRtClUXXvttXrzzTfdz2+55RZFRka6ny9fvlxXXXWVedUBAAB0EKb0qWpUU1OjiIgIde3a1axDdir0qQIAoONp7e+3Vx3VWxIVFWXm4QAAADoMr9b+AwAAgCdCFQAAgAkIVQAAACYgVAEAAJiAUAUAAGACU+/+AwCz1LsMlVRW60BNrWKjIjQiKUahIRZ/lwUALSJUAQg4BRVVmpe/Q1WOWve2eGuEcjOTNSYl/gyvBAD/4fIfgIBSUFGlKSvLPAKVJNkdtZqyskwFFVV+qgwAzoxQBSBg1LsMzcvfoeaWeWjcNi9/h+pdpi0EAQCmIVQBCBglldVNzlCdypBU5ahVSWW174oCgFYiVAEIGAdqWg5U3owDAF8iVAEIGLFREaaOAwBfIlQBCBgjkmIUb41QS40TLGq4C3BEUowvywKAViFUAQgYoSEW5WYmS1KTYNX4PDcz2d2vqt5lqOiTg3qtfJ+KPjnIBHYAfkWfKgABZUxKvPImDGvSp8p2Wp8qelkBCDQWwzD4q52POJ1OWa1WORwORUdH+7scIKCdqaN6Yy+r0//wajyblTdhGMEKgGla+/vNmSoAASk0xKK0vr2abD9bLyuLGnpZjU62sawNAJ9iThWADoVeVgACFaEKQIdCLysAgYrLf4DJzjQXCOeOXlYAAhWhCjARd6S1v8ZeVnZHbbPzqixquFOQXlYAfI3Lf4BJGu9IO32+j91Rqykry1RQUeWnyjqXtvayAgBfIVQBJjjbHWlSwx1pNKc0R2MvK5vV8xKfzRpBOwUAfsPlP8AEbbkjrbk2AWi7MSnxGp1sY/4agIBBqAJMEIh3pAXDhPmWelkBgD8QqgATBNodaUyYBwDfY04VYILGO9JaOg9kUUOo8cUdaUyYBwD/IFQBJgiUO9KYMA8A/kOoAkwSCHeksYQLAPgPc6oAE/n7jrRAnDAPAMGCUAWYzJ93pAXahHkACCZc/gM6kUCaMA8AwYZQBXQi/p4wX+8yVPTJQb1Wvk9FnxxkQjyAoMLlP6CTaZwwf3qfKls796miNxaAYGcxDIO/SvqI0+mU1WqVw+FQdHS0v8tBJ+fLjuqNvbFO/8Ok8d1Yjw9AR9ba32/OVAGdlK8mzJ+tN5ZFDb2xRifbOt0yOQBwKuZUAW3AnKGm6I0FAA04UwW0EnOGmkdvLABoEPBnqvbt26cJEyaoV69eioyM1ODBg7Vlyxb3fsMwNGfOHMXHxysyMlLp6enavXu3xzGqq6uVnZ2t6Oho9ejRQ5MnT9aRI0c8xmzbtk1XX321IiIilJiYqEWLFjWp5eWXX9aAAQMUERGhwYMH680332yfD42Aw3p6LaM3FgA0COhQdejQIY0cOVJdu3bVW2+9pR07duiJJ55Qz5493WMWLVqkJUuWaNmyZSouLla3bt2UkZGh2tpvf/yys7O1fft2FRYWau3atdqwYYPuvvtu936n06kbb7xRffr0UWlpqR577DHNnTtXy5cvd4959913NX78eE2ePFlbt25VVlaWsrKyVFFR4ZsvA37DenpnRm8sAGgQ0Hf/zZo1S5s2bdJ///vfZvcbhqGEhATdd999uv/++yVJDodDcXFxWrFihcaNG6edO3cqOTlZmzdv1vDhwyVJBQUFuummm/TFF18oISFBeXl5euihh2S32xUWFuZ+7zVr1ujDDz+UJN1+++06evSo1q5d637/K6+8UkOGDNGyZcta9Xm4+69jKvrkoMY/995Zx71w15V+66Tub41n8iR5hE/u/gPQGbT29zugz1S9/vrrGj58uH7yk58oNjZWQ4cO1XPPPefeX1lZKbvdrvT0dPc2q9Wq1NRUFRUVSZKKiorUo0cPd6CSpPT0dIWEhKi4uNg95pprrnEHKknKyMjQrl27dOjQIfeYU9+ncUzj+zSnrq5OTqfT44GOhzlDZxcIi0kDgL8F9ET1Tz/9VHl5eZoxY4Z++9vfavPmzbrnnnsUFhamiRMnym63S5Li4uI8XhcXF+feZ7fbFRsb67G/S5cuiomJ8RiTlJTU5BiN+3r27Cm73X7G92nOggULNG/ePC8+OQIJc4Zax9+LSQOAvwV0qHK5XBo+fLgeeeQRSdLQoUNVUVGhZcuWaeLEiX6u7uwefPBBzZgxw/3c6XQqMTHRjxXBG41zhuyO2mbnVVnUcEaGOUP+XUwaAPwtoC//xcfHKzk52WPbwIEDtWfPHkmSzWaTJO3fv99jzP79+937bDabDhw44LH/m2++UXV1tceY5o5x6nu0NKZxf3PCw8MVHR3t8UDH4+/19AAAHUNAh6qRI0dq165dHts++ugj9enTR5KUlJQkm82mdevWufc7nU4VFxcrLS1NkpSWlqbDhw+rtLTUPWb9+vVyuVxKTU11j9mwYYNOnjzpHlNYWKj+/fu77zRMS0vzeJ/GMY3vg86NOUMAgLMyAlhJSYnRpUsXY/78+cbu3buNVatWGeedd56xcuVK95hHH33U6NGjh/Haa68Z27ZtM2655RYjKSnJOH78uHvMmDFjjKFDhxrFxcXGxo0bjX79+hnjx4937z98+LARFxdn3HHHHUZFRYXx4osvGuedd57x7LPPusds2rTJ6NKli/H4448bO3fuNHJzc42uXbsaH3zwQas/j8PhMCQZDofjHL8Z+Ms39S7j3Y+/NtZs/cJ49+OvjW/qXf4uCQDQzlr7+x3QocowDCM/P99ISUkxwsPDjQEDBhjLly/32O9yuYzZs2cbcXFxRnh4uHHDDTcYu3bt8hhz8OBBY/z48Ub37t2N6OhoY9KkSUZNTY3HmPfff98YNWqUER4eblx44YXGo48+2qSW1atXG5deeqkRFhZmDBo0yHjjjTfa9FkIVQAAdDyt/f0O6D5VnQ19qmCGepdh2h12Zh4LADqr1v5+B/TdfwA8nev6g6eGqM++PqYXSvbI7mQtQwAwA2eqfIgzVR1LoJ3Faexafvp/sK3tWt5cIDsdHdABoCnOVAHn4FzPCJntbOsPWtSw/uDoZFuzwa+lQObNsQAAzQvolgqAPzQGkNPP6NgdtZqyskwFFVU+r6mksvqMZ5gMSVWOWpVUVjfZd6ZA1tZjAQBaRqgCTnG2M0JSw1mcepdvr5qfy/qDZwtk5/qeAIAGhCrgFOdyRqg9ncv6g96Go2BfyxAA2opQBZziXM4ItafG9QdbmuFkUcOcr+bWH2xrODrTsQAALSNUAac4lzNC7elc1h+8ok9PtXa+OWsZAoD3CFXAKc7ljFB783b9wdLPD6m1U8BYyxAAvEdLBeAUjWeEpqwsk0XymLAeCGdxxqTEa3SyrU39s1p7qXLadX117+j+nKECAC8RqoDTNJ4ROr1Pla2Vfarau2loaIhFaX17tXp8ay9VjrzkAgIVAJwDQhXQDG/OCEmB1zRU+vaSpt1R22yrCIsaAiMT0wHg3DCnCmhB4xmhW4ZcqLS+vVoVqAKtaah0bpPcAQCtR6gCTBCoTUMbeTvJHQDQelz+A0zQlqahbZkPZSZvL2kCAFqHUAWYIFCbhp6urZPcAQCtx+U/wASB2jQUAOA7hCrABIHcNBQA4BuEKsAE3GEHACBUASbhDjsACG5MVAdMxB12ABC8CFWAybjDDgCCE5f/AAAATECoAgAAMAGhCgAAwASEKgAAABMQqgAAAExAqAIAADABoQoAAMAEhCoAAAATEKoAAABMQKgCAAAwAaEKAADABIQqAAAAExCqAAAATECoAgAAMAGhCgAAwASEKgAAABMQqgAAAExAqAIAADABoQoAAMAEhCoAAAATdPF3AfCNepehkspqHaipVWxUhEYkxSg0xOLvsgAA6DQIVUGgoKJK8/J3qMpR694Wb41QbmayxqTE+7EyAAA6Dy7/dXIFFVWasrLMI1BJkt1Rqykry1RQUeWnygAA6FwIVZ1YvcvQvPwdMprZ17htXv4O1buaGwEAANqCUNWJlVRWNzlDdSpDUpWjViWV1b4rCgCATopQ1YkdqGk5UHkzDgAAtIxQ1YnFRkWYOg4AALSMUNWJjUiKUbw1Qi01TrCo4S7AEUkxviwLAIBOiVDViYWGWJSbmSxJTYJV4/PczGT6VQEAYAJCVSc3JiVeeROGyWb1vMRns0Yob8Iw+lQBAGASmn8GgTEp8RqdbKOjOgAA7YhQFSRCQyxK69vL32WwXA4AoNMiVMFnWC4HANCZMacKPsFyOQCAzo5QhXbHcjkAgGBAqEK7Y7kcAEAwIFSh3bFcDgAgGBCq0O5YLgcAEAwIVWh3LJcDAAgGhCq0O5bLAQAEA0IVfILlcgAAnR3NP+EzLJcDAOjMCFXwqUBZLgcAALNx+Q8AAMAEhCoAAAATcPkPAafeZTDvCgDQ4XSoM1WPPvqoLBaLcnJy3Ntqa2s1depU9erVS927d9ett96q/fv3e7xuz549Gjt2rM477zzFxsbqgQce0DfffOMx5j//+Y+GDRum8PBwXXLJJVqxYkWT93/mmWd08cUXKyIiQqmpqSopKWmPjxnUCiqqNGrheo1/7j1Nf7Fc4597T6MWrmfBZQBAwOswoWrz5s169tlnddlll3lsv/fee5Wfn6+XX35Z77zzjr788kv96Ec/cu+vr6/X2LFjdeLECb377rv629/+phUrVmjOnDnuMZWVlRo7dqyuu+46lZeXKycnR7/4xS/0r3/9yz3mpZde0owZM5Sbm6uysjJdfvnlysjI0IEDB9r/wweJgooqTVlZ1mSdQLujVlNWlhGsAAABzWIYhuHvIs7myJEjGjZsmJYuXaqHH35YQ4YM0ZNPPimHw6ELLrhAzz//vH784x9Lkj788EMNHDhQRUVFuvLKK/XWW2/p5ptv1pdffqm4uDhJ0rJlyzRz5kx99dVXCgsL08yZM/XGG2+ooqLC/Z7jxo3T4cOHVVBQIElKTU3Vd7/7XT399NOSJJfLpcTERP3617/WrFmzWvU5nE6nrFarHA6HoqOjTfluOsulsnqXoVEL17e48LJFDT2tNs68vkN+PgBAx9Xa3+8OcaZq6tSpGjt2rNLT0z22l5aW6uTJkx7bBwwYoN69e6uoqEiSVFRUpMGDB7sDlSRlZGTI6XRq+/bt7jGnHzsjI8N9jBMnTqi0tNRjTEhIiNLT091jmlNXVyen0+nxMFNnulRWUlndYqCSJENSlaNWJZXVvisKAIA2CPhQ9eKLL6qsrEwLFixoss9utyssLEw9evTw2B4XFye73e4ec2qgatzfuO9MY5xOp44fP66vv/5a9fX1zY5pPEZzFixYIKvV6n4kJia27kO3Qme7VHagpuVA5c04AAB8LaBD1d69ezV9+nStWrVKERERZ39BgHnwwQflcDjcj71795py3HqXoXn5O9TcddvGbfPyd6jeFfBXdt1io1r3z7e14wAA8LWADlWlpaU6cOCAhg0bpi5duqhLly565513tGTJEnXp0kVxcXE6ceKEDh8+7PG6/fv3y2azSZJsNluTuwEbn59tTHR0tCIjI3X++ecrNDS02TGNx2hOeHi4oqOjPR5m6IyXykYkxSjeGtFkweVGFknx1oY5YwAABKKADlU33HCDPvjgA5WXl7sfw4cPV3Z2tvv/d+3aVevWrXO/ZteuXdqzZ4/S0tIkSWlpafrggw887tIrLCxUdHS0kpOT3WNOPUbjmMZjhIWF6YorrvAY43K5tG7dOvcYX+qMl8pCQyzKzWz453F6sGp8npuZzCR1AEDACujmn1FRUUpJSfHY1q1bN/Xq1cu9ffLkyZoxY4ZiYmIUHR2tX//610pLS9OVV14pSbrxxhuVnJysO+64Q4sWLZLdbtfvfvc7TZ06VeHh4ZKk//f//p+efvpp/eY3v9Gdd96p9evXa/Xq1XrjjTfc7ztjxgxNnDhRw4cP14gRI/Tkk0/q6NGjmjRpko++jW+156Uyf95NOCYlXnkThmle/g6PM3E2a4RyM5M1JiXeJ3UAAOCNgA5VrfGnP/1JISEhuvXWW1VXV6eMjAwtXbrUvT80NFRr167VlClTlJaWpm7dumnixIn6/e9/7x6TlJSkN954Q/fee68WL16siy66SH/+85+VkZHhHnP77bfrq6++0pw5c2S32zVkyBAVFBQ0mbzuC42XyuyO2mbnVTW2H2jrpbKCiqomgSbex4FmTEq8RifbOkWbCABAcOkQfao6CzP7VDXe/SfJI1g1Ro+8CcPaFIQaj3f6vwzeHg8AgM6iU/WpQlONl8psVs9LfDZrRJsDUGe8mxAAAF/r8Jf/gplZl8racjdhWt9e51g1AACdE6GqgwsNsZxz0OmMdxMCAOBrXP4DjTcBADABoQo03gQAwASEKtB4EwAAExCqIMncuwkBAAhGTFSHG403AQDwHqEKHsy4mxAAgGDE5T8AAAATEKoAAABMQKgCAAAwAaEKAADABIQqAAAAExCqAAAATECoAgAAMAGhCgAAwASEKgAAABPQUd2HDMOQJDmdTj9XAgAAWqvxd7vxd7wlhCofqqmpkSQlJib6uRIAANBWNTU1slqtLe63GGeLXTCNy+XSl19+qaioKFkswbtIsdPpVGJiovbu3avo6Gh/lxN0+P79h+/ev/j+/asjf/+GYaimpkYJCQkKCWl55hRnqnwoJCREF110kb/LCBjR0dEd7j+szoTv33/47v2L79+/Our3f6YzVI2YqA4AAGACQhUAAIAJCFXwufDwcOXm5io8PNzfpQQlvn//4bv3L75//wqG75+J6gAAACbgTBUAAIAJCFUAAAAmIFQBAACYgFAFAABgAkIVfGLBggX67ne/q6ioKMXGxiorK0u7du3yd1lB69FHH5XFYlFOTo6/Swka+/bt04QJE9SrVy9FRkZq8ODB2rJli7/LCgr19fWaPXu2kpKSFBkZqb59++oPf/jDWddxg3c2bNigzMxMJSQkyGKxaM2aNR77DcPQnDlzFB8fr8jISKWnp2v37t3+KdZkhCr4xDvvvKOpU6fqvffeU2FhoU6ePKkbb7xRR48e9XdpQWfz5s169tlnddlll/m7lKBx6NAhjRw5Ul27dtVbb72lHTt26IknnlDPnj39XVpQWLhwofLy8vT0009r586dWrhwoRYtWqSnnnrK36V1SkePHtXll1+uZ555ptn9ixYt0pIlS7Rs2TIVFxerW7duysjIUG1trY8rNR8tFeAXX331lWJjY/XOO+/ommuu8Xc5QePIkSMaNmyYli5dqocfflhDhgzRk08+6e+yOr1Zs2Zp06ZN+u9//+vvUoLSzTffrLi4OP3lL39xb7v11lsVGRmplStX+rGyzs9isejVV19VVlaWpIazVAkJCbrvvvt0//33S5IcDofi4uK0YsUKjRs3zo/VnjvOVMEvHA6HJCkmJsbPlQSXqVOnauzYsUpPT/d3KUHl9ddf1/Dhw/WTn/xEsbGxGjp0qJ577jl/lxU0rrrqKq1bt04fffSRJOn999/Xxo0b9f3vf9/PlQWfyspK2e12jz+DrFarUlNTVVRU5MfKzMGCyvA5l8ulnJwcjRw5UikpKf4uJ2i8+OKLKisr0+bNm/1dStD59NNPlZeXpxkzZui3v/2tNm/erHvuuUdhYWGaOHGiv8vr9GbNmiWn06kBAwYoNDRU9fX1mj9/vrKzs/1dWtCx2+2SpLi4OI/tcXFx7n0dGaEKPjd16lRVVFRo48aN/i4laOzdu1fTp09XYWGhIiIi/F1O0HG5XBo+fLgeeeQRSdLQoUNVUVGhZcuWEap8YPXq1Vq1apWef/55DRo0SOXl5crJyVFCQgLfP0zF5T/41LRp07R27Vq9/fbbuuiii/xdTtAoLS3VgQMHNGzYMHXp0kVdunTRO++8oyVLlqhLly6qr6/3d4mdWnx8vJKTkz22DRw4UHv27PFTRcHlgQce0KxZszRu3DgNHjxYd9xxh+69914tWLDA36UFHZvNJknav3+/x/b9+/e793VkhCr4hGEYmjZtml599VWtX79eSUlJ/i4pqNxwww364IMPVF5e7n4MHz5c2dnZKi8vV2hoqL9L7NRGjhzZpIXIRx99pD59+vipouBy7NgxhYR4/tyFhobK5XL5qaLglZSUJJvNpnXr1rm3OZ1OFRcXKy0tzY+VmYPLf/CJqVOn6vnnn9drr72mqKgo97Vzq9WqyMhIP1fX+UVFRTWZv9atWzf16tWLeW0+cO+99+qqq67SI488ottuu00lJSVavny5li9f7u/SgkJmZqbmz5+v3r17a9CgQdq6dav++Mc/6s477/R3aZ3SkSNH9PHHH7ufV1ZWqry8XDExMerdu7dycnL08MMPq1+/fkpKStLs2bOVkJDgvkOwQzMAH5DU7OOvf/2rv0sLWtdee60xffp0f5cRNPLz842UlBQjPDzcGDBggLF8+XJ/lxQ0nE6nMX36dKN3795GRESE8Z3vfMd46KGHjLq6On+X1im9/fbbzf55P3HiRMMwDMPlchmzZ8824uLijPDwcOOGG24wdu3a5d+iTUKfKgAAABMwpwoAAMAEhCoAAAATEKoAAABMQKgCAAAwAaEKAADABIQqAAAAExCqAAAATECoAgAAMAGhCgAAwASEKgAw0R133KFHHnnE32W0qKCgQEOGDGExYaAdEKoABLS9e/fqzjvvVEJCgsLCwtSnTx9Nnz5dBw8e9HdpTbz//vt68803dc899/i7lBaNGTNGXbt21apVq/xdCtDpEKoABKxPP/1Uw4cP1+7du/XCCy/o448/1rJly7Ru3TqlpaWpurra3yV6eOqpp/STn/xE3bt393cpZ/Tzn/9cS5Ys8XcZQKdDqAIQsKZOnaqwsDD97//+r6699lr17t1b3//+9/Xvf/9b+/bt00MPPeQee/HFF8tisTR5ZGVlucd873vfU05OTrPvlZOTo+9973uSGkJHc8eyWCz6+c9/3uzr6+vr9corrygzM9Nje3N13X///e79eXl56tu3r8LCwtS/f3/94x//aHLsuXPnnvFzrVixQj169Gi2rvLyclksFn322WfubZmZmdqyZYs++eSTZl8DwDuEKgABqbq6Wv/617/0q1/9SpGRkR77bDabsrOz9dJLL8kwDPf23//+96qqqnI/brvtNq/ee/HixR7HuO2229zPFy9e3Oxrtm3bJofDoeHDhzfZd3pdubm5kqRXX31V06dP13333aeKigr98pe/1KRJk/T22283OcagQYPO+XM16t27t+Li4vTf//73nI4DwFMXfxcAAM3ZvXu3DMPQwIEDm90/cOBAHTp0SF999ZViY2MlSVFRUbLZbO4xkZGRqqura/N7W61WWa1W9zEkeRy3OZ9//rlCQ0PdtZzq9LoaPf744/r5z3+uX/3qV5KkGTNm6L333tPjjz+u6667zj2urq5OkZGR7mN4+7lOlZCQoM8///ycjgHAE2eqAAS0U89EmWHp0qXq3r27evXqpdTUVOXn55ty3OPHjys8PFwWi6XVr9m5c6dGjhzpsW3kyJHauXOnx7aDBw8qOjr6jMdyOBzq3r27oqOj1a9fP91///06efJki+MjIyN17NixVtcK4OwIVQAC0iWXXCKLxdIkYDTauXOnevbsqQsuuKBNx83OzlZ5ebk2bNigq6++Wj/+8Y+1b9++c673/PPP17Fjx3TixIlzPtbpPv30UyUlJZ1xTFRUlMrLy1VaWqrHH39cf/7zn1u8VCk1XF5t63cH4MwIVQACUq9evTR69GgtXbpUx48f99hnt9u1atUq3X777W06MyQ1XNq75JJLNGjQIM2bN08nTpxoMbi1xZAhQyRJO3bsaPVrBg4cqE2bNnls27Rpk5KTk93Pa2trVVJSoquvvvqMxwoJCdEll1yifv366ZZbbtHo0aNVXl7e7Nja2lp98sknGjp0aKtrBXB2hCoAAevpp59WXV2dMjIytGHDBu3du1cFBQUaPXq0LrzwQs2fP7/Nx6yvr1dtba0cDoeeffZZde3aVf379z/nWi+44AINGzZMGzdubPVrHnjgAa1YsUJ5eXnavXu3/vjHP+qf//yn++7AI0eOaM6cOZKkUaNGyW63y2636/jx46qrq5PD4fA4Xm1trY4fP67S0lJt3LhRKSkpzb7ve++9p/DwcKWlpXn5aQE0h1AFIGD169dPW7Zs0Xe+8x3ddttt6tu3r+6++25dd911KioqUkxMTJuP+fTTTysyMlKxsbH6n//5H61atUqJiYmm1PuLX/yiTU01s7KytHjxYj3++OMaNGiQnn32Wf31r391t3Z4/PHH9dhjj6mmpkaXXHKJ4uPjFR8fr9WrV6ugoEDTp093H8vhcCgyMlLdunXTzTffrB/+8IeaMWNGs+/7wgsvKDs7W+edd945fV4AniyG2bNAASBIHT9+XP3799dLL71kylmguXPnevzvqdasWaM1a9ZoxYoVbTrm119/rf79+2vLli1nnacFoG1oqQAAJomMjNTf//53ff3116Yc70yd2SMiItxtH9ris88+09KlSwlUQDvgTBUAAIAJmFMFAABgAkIVAACACQhVAAAAJiBUAQAAmIBQBQAAYAJCFQAAgAkIVQAAACYgVAEAAJjg/wME22ZhLfk8rQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(ds['YearsExperience'], ds['Salary'])\n", + "plt.xlabel('Опыт (годы)')\n", + "plt.ylabel('Зарплата')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 493, + "metadata": {}, + "outputs": [], + "source": [ + "X = ds.iloc[:, :-1].values\n", + "y = ds.iloc[:, 1].values\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 494, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "26780.099150628157\n", + "[9312.57512673]\n" + ] + } + ], + "source": [ + "regressor = LinearRegression()\n", + "regressor.fit(X_train, y_train)\n", + "\n", + "print(regressor.intercept_)\n", + "print(regressor.coef_)" + ] + }, + { + "cell_type": "code", + "execution_count": 495, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred = regressor.predict(X_test)\n", + "df = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})" + ] + }, + { + "cell_type": "code", + "execution_count": 496, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.plot(kind='bar')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 497, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X_test, y_test)\n", + "plt.plot(X_test, y_pred, c='r')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.2 Задание\n", + "\n", + "Постройте модель множественной линейной регрессии для произвольных \n", + "данных из нескольких столбцов. Для примера можно взять потребления \n", + "газа (в миллионах галлонов) в 48 штатах США или набор данных о \n", + "качестве красного вина (1) и (2) соответственно. Найдите коэффициенты \n", + "множественной регрессии. Постройте прогноз. " + ] + }, + { + "cell_type": "code", + "execution_count": 498, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
fixed acidityvolatile aciditycitric acidresidual sugarchloridesfree sulfur dioxidetotal sulfur dioxidedensitypHsulphatesalcoholquality
count1599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.000000
mean8.3196370.5278210.2709762.5388060.08746715.87492246.4677920.9967473.3111130.65814910.4229835.636023
std1.7410960.1790600.1948011.4099280.04706510.46015732.8953240.0018870.1543860.1695071.0656680.807569
min4.6000000.1200000.0000000.9000000.0120001.0000006.0000000.9900702.7400000.3300008.4000003.000000
25%7.1000000.3900000.0900001.9000000.0700007.00000022.0000000.9956003.2100000.5500009.5000005.000000
50%7.9000000.5200000.2600002.2000000.07900014.00000038.0000000.9967503.3100000.62000010.2000006.000000
75%9.2000000.6400000.4200002.6000000.09000021.00000062.0000000.9978353.4000000.73000011.1000006.000000
max15.9000001.5800001.00000015.5000000.61100072.000000289.0000001.0036904.0100002.00000014.9000008.000000
\n", + "
" + ], + "text/plain": [ + " fixed acidity volatile acidity citric acid residual sugar \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", + "mean 8.319637 0.527821 0.270976 2.538806 \n", + "std 1.741096 0.179060 0.194801 1.409928 \n", + "min 4.600000 0.120000 0.000000 0.900000 \n", + "25% 7.100000 0.390000 0.090000 1.900000 \n", + "50% 7.900000 0.520000 0.260000 2.200000 \n", + "75% 9.200000 0.640000 0.420000 2.600000 \n", + "max 15.900000 1.580000 1.000000 15.500000 \n", + "\n", + " chlorides free sulfur dioxide total sulfur dioxide density \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", + "mean 0.087467 15.874922 46.467792 0.996747 \n", + "std 0.047065 10.460157 32.895324 0.001887 \n", + "min 0.012000 1.000000 6.000000 0.990070 \n", + "25% 0.070000 7.000000 22.000000 0.995600 \n", + "50% 0.079000 14.000000 38.000000 0.996750 \n", + "75% 0.090000 21.000000 62.000000 0.997835 \n", + "max 0.611000 72.000000 289.000000 1.003690 \n", + "\n", + " pH sulphates alcohol quality \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \n", + "mean 3.311113 0.658149 10.422983 5.636023 \n", + "std 0.154386 0.169507 1.065668 0.807569 \n", + "min 2.740000 0.330000 8.400000 3.000000 \n", + "25% 3.210000 0.550000 9.500000 5.000000 \n", + "50% 3.310000 0.620000 10.200000 6.000000 \n", + "75% 3.400000 0.730000 11.100000 6.000000 \n", + "max 4.010000 2.000000 14.900000 8.000000 " + ] + }, + "execution_count": 498, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/aniruddhachoudhury/Red-Wine-Quality/master/winequality-red.csv'\n", + "\n", + "ds = pd.read_csv(url)\n", + "\n", + "ds.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 499, + "metadata": {}, + "outputs": [], + "source": [ + "X = ds[['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol']]\n", + "y = ds['quality']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 500, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "34.99871062872134\n", + "[ 4.12835075e-02 -1.14952802e+00 -1.77927063e-01 2.78700036e-02\n", + " -1.87340739e+00 2.68362616e-03 -2.77748370e-03 -3.15166657e+01\n", + " -2.54486051e-01 9.24040106e-01 2.67797417e-01]\n" + ] + } + ], + "source": [ + "regressor = LinearRegression()\n", + "regressor.fit(X_train, y_train)\n", + "\n", + "print(regressor.intercept_)\n", + "print(regressor.coef_)" + ] + }, + { + "cell_type": "code", + "execution_count": 501, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Coefficient
fixed acidity0.041284
volatile acidity-1.149528
citric acid-0.177927
residual sugar0.027870
chlorides-1.873407
free sulfur dioxide0.002684
total sulfur dioxide-0.002777
density-31.516666
pH-0.254486
sulphates0.924040
alcohol0.267797
\n", + "
" + ], + "text/plain": [ + " Coefficient\n", + "fixed acidity 0.041284\n", + "volatile acidity -1.149528\n", + "citric acid -0.177927\n", + "residual sugar 0.027870\n", + "chlorides -1.873407\n", + "free sulfur dioxide 0.002684\n", + "total sulfur dioxide -0.002777\n", + "density -31.516666\n", + "pH -0.254486\n", + "sulphates 0.924040\n", + "alcohol 0.267797" + ] + }, + "execution_count": 501, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(regressor.coef_, X.columns, columns=['Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 502, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ActualPredicted
110965.782930
103255.036193
100276.596989
48765.339126
97955.939529
.........
79466.559757
81346.017576
132256.251291
70445.163926
102366.367205
\n", + "

320 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " Actual Predicted\n", + "1109 6 5.782930\n", + "1032 5 5.036193\n", + "1002 7 6.596989\n", + "487 6 5.339126\n", + "979 5 5.939529\n", + "... ... ...\n", + "794 6 6.559757\n", + "813 4 6.017576\n", + "1322 5 6.251291\n", + "704 4 5.163926\n", + "1023 6 6.367205\n", + "\n", + "[320 rows x 2 columns]" + ] + }, + "execution_count": 502, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pred = regressor.predict(X_test)\n", + "df = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Средняя квадратичная ошибка" + ] + }, + { + "cell_type": "code", + "execution_count": 503, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.38447119782012573" + ] + }, + "execution_count": 503, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics.mean_squared_error(y_test,y_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.2 Задание*\n", + "\n", + "Экспериментально получены N − значений величины Y при \n", + "различных значениях величины X. Построить полиномы первой и второй \n", + "степени, аппроксимирующие результаты эксперимента, с применением \n", + "метода наименьших квадратов. Результаты выводятся в виде таблиц \n", + "значений и графиков, полученных полиномов. \n", + "\n", + "*Вариант:* 2" + ] + }, + { + "cell_type": "code", + "execution_count": 504, + "metadata": {}, + "outputs": [], + "source": [ + "# Линейная функция\n", + "def linear_func(x, b0, b1):\n", + " return b0 + b1 * x\n", + "\n", + "# Квадратичная функция\n", + "def quadratic_func(x, b0, b1, b2):\n", + " return b0 + b1 * x + b2 * x**2" + ] + }, + { + "cell_type": "code", + "execution_count": 505, + "metadata": {}, + "outputs": [], + "source": [ + "xdata = np.linspace(0, 1, 6)\n", + "ydata = np.asarray([5.0, 5.0, 4.0, 4.0, 6.0, 6.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 506, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.42857143 1.14285715]\n", + " x y\n", + "0 0.0 4.428571\n", + "1 0.2 4.657143\n", + "2 0.4 4.885714\n", + "3 0.6 5.114286\n", + "4 0.8 5.342857\n", + "5 1.0 5.571429\n" + ] + } + ], + "source": [ + "beta_opt, beta_cov = curve_fit(linear_func, xdata, ydata, method='lm')\n", + "print(beta_opt)\n", + "df = pd.DataFrame({\"x\": xdata, \"y\": linear_func(xdata, *beta_opt)});\n", + "#df.columns=['xdata', 'ydata']\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 507, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, linear_func(xdata, *beta_opt), 'b', lw=2)\n", + "plt.xlabel('x')\n", + "plt.ylabel('linear')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 508, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 5.14285714 -4.2142857 5.35714285]\n", + " x y\n", + "0 0.0 5.142857\n", + "1 0.2 4.514286\n", + "2 0.4 4.314286\n", + "3 0.6 4.542857\n", + "4 0.8 5.200000\n", + "5 1.0 6.285714\n" + ] + } + ], + "source": [ + "beta_opt, beta_cov = curve_fit(quadratic_func, xdata, ydata, method='lm')\n", + "print(beta_opt)\n", + "df = pd.DataFrame({\"x\": xdata, \"y\": quadratic_func(xdata, *beta_opt)});\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 509, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(xdata, ydata)\n", + "ax.plot(xdata, quadratic_func(xdata, *beta_opt), 'b', lw=2)\n", + "plt.xlabel('x')\n", + "plt.ylabel('linear')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Third term/Artificial intelligence systems and big data/5.ipynb b/Third term/Artificial intelligence systems and big data/5.ipynb new file mode 100644 index 0000000..89c3daa --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/5.ipynb @@ -0,0 +1,1422 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Рабочая тетрадь No 5" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn import tree, metrics\n", + "from sklearn.tree import DecisionTreeRegressor\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import classification_report, confusion_matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.3 Задание\n", + "\n", + "Создайте класс по работе с тригонометрическими функциями. В классе \n", + "должны быть реализованы функции вычисления: \n", + "- косинуса; \n", + "- синуса; \n", + "- тангенса; \n", + "- арксинуса; \n", + "- арккосинуса; \n", + "- арктангенса; \n", + "- перевода из градусов в радианы." + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "class TrigFunctions:\n", + " def __init__(self, precision=10):\n", + " # Константа для pi\n", + " self.pi = 3.141592653589793\n", + " # Переменная точности для вычислений\n", + " self.precision = precision\n", + "\n", + " # Факториал для ряда Тейлора\n", + " def factorial(self, n):\n", + " result = 1\n", + " for i in range(2, n + 1):\n", + " result *= i\n", + " return result\n", + "\n", + " # Приближенное вычисление синуса с помощью ряда Тейлора\n", + " def sin(self, angle_radians):\n", + " sin_approx = 0\n", + " \n", + " for n in range(self.precision):\n", + " sign = (-1) ** n\n", + " term = (angle_radians ** (2 * n + 1)) / self.factorial(2 * n + 1)\n", + " sin_approx += sign * term\n", + " \n", + " return sin_approx\n", + "\n", + " # Приближенное вычисление косинуса с помощью ряда Тейлора\n", + " def cos(self, angle_radians):\n", + " cos_approx = 0\n", + " \n", + " for n in range(self.precision):\n", + " sign = (-1) ** n\n", + " term = (angle_radians ** (2 * n)) / self.factorial(2 * n)\n", + " cos_approx += sign * term\n", + " \n", + " return cos_approx\n", + "\n", + " # Приближенное вычисление тангенса как sin/cos\n", + " def tan(self, angle_radians):\n", + " return self.sin(angle_radians) / self.cos(angle_radians)\n", + "\n", + " # Приближенное вычисление арксинуса с использованием метода Ньютона\n", + " def arcsin(self, value):\n", + " if value < -1 or value > 1:\n", + " return None # Арксинус определен только на отрезке [-1, 1]\n", + " \n", + " x = value\n", + " \n", + " for _ in range(self.precision):\n", + " x -= (self.sin(x) - value) / self.cos(x)\n", + " \n", + " return x\n", + "\n", + " # Арккосинус как pi/2 - арксинус\n", + " def arccos(self, value):\n", + " return self.pi / 2 - self.arcsin(value)\n", + "\n", + " # Приближенное вычисление арктангенса с использованием метода Ньютона\n", + " def arctan(self, value):\n", + " x = value\n", + " \n", + " for _ in range(self.precision):\n", + " x -= (self.tan(x) - value) / (1 + value ** 2)\n", + " \n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Угол (рад): 0.7853981633974483\n", + "sin: 0.7071067811865475\n", + "cos: 0.7071067811865475\n", + "tan: 1.0\n", + "arcsin (рад): 0.7853981633974483\n", + "arccos (рад): 0.7853981633974483\n", + "arctan (рад): 0.7853981633974483\n" + ] + } + ], + "source": [ + "trig_functions = TrigFunctions(precision=10)\n", + "\n", + "angle = 3.141592653589793 / 4 # pi/4 радиан (45 градусов)\n", + "\n", + "sin_value = trig_functions.sin(angle)\n", + "cos_value = trig_functions.cos(angle)\n", + "tan_value = trig_functions.tan(angle)\n", + "arcsin_value = trig_functions.arcsin(sin_value)\n", + "arccos_value = trig_functions.arccos(cos_value)\n", + "arctan_value = trig_functions.arctan(tan_value)\n", + "\n", + "print(\"Угол (рад):\", angle)\n", + "print(\"sin:\", sin_value)\n", + "print(\"cos:\", cos_value)\n", + "print(\"tan:\", tan_value)\n", + "print(\"arcsin (рад):\", arcsin_value)\n", + "print(\"arccos (рад):\", arccos_value)\n", + "print(\"arctan (рад):\", arctan_value)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.2 Задание 1\n", + "\n", + "Представьте дерево показанное на рисунке с использованием списка из \n", + "списков. Выведите на печать корень дерева, а также его левое и правое \n", + "поддеревья." + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Корень: a\n", + "Левое поддерево: ['b', ['d', []], ['e', []]]\n", + "Правое поддерево: ['c', ['f', []]]\n" + ] + } + ], + "source": [ + "tr = ['a', ['b', ['d', []], ['e', []]], ['c', ['f', []]]]\n", + "\n", + "print(f\"Корень: {tr[0]}\")\n", + "print(f\"Левое поддерево: {tr[1]}\")\n", + "print(f\"Правое поддерево: {tr[2]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2.2 Задание 2\n", + "\n", + "Дан класс, описывающий бинарное дерево. \n", + "\n", + "\n", + "```python\n", + "class Tree: \n", + " def __init__(self, data): \n", + " self.left = None \n", + " self.right = None \n", + " self.data = data \n", + " def PrintTree(self): \n", + " print(self.data) \n", + "```\n", + "Реализуйте в классе функцию для вставки нового элемента в дерево по \n", + "следующим правилам: \n", + " \n", + "- Левое поддерево узла содержит только узлы со значениями меньше, \n", + "чем значение в узле. \n", + "- Правое поддерево узла содержит только узлы со значениями меньше, \n", + "чем значение в узле. \n", + "- Каждое из левого и правого поддеревьев также должно быть \n", + "бинарным деревом поиска. \n", + "- Не должно быть повторяющихся узлов. \n", + "\n", + "Метод вставки сравнивает значение узла с родительским узлом и решает \n", + "куда доваить элемент (в левое или правое поддерево). Перепишите, метод \n", + "PrintTree для печати полной версии дерева." + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [], + "source": [ + "class BinaryTree: \n", + " def __init__(self, data): \n", + " self.left = None \n", + " self.right = None \n", + " self.data = data\n", + "\n", + " def insert(self, data):\n", + " if data < self.data:\n", + " if self.left is None:\n", + " self.left = BinaryTree(data)\n", + " else:\n", + " self.left.insert(data)\n", + " elif data > self.data:\n", + " if self.right is None:\n", + " self.right = BinaryTree(data)\n", + " else:\n", + " self.right.insert(data)\n", + "\n", + " def Print(self, level=0):\n", + " if self.right:\n", + " self.right.Print(level + 1)\n", + " \n", + " print(' ' * 4 * level + '->', self.data)\n", + " if self.left:\n", + " self.left.Print(level + 1) " + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " -> 17\n", + " -> 15\n", + " -> 12\n", + "-> 10\n", + " -> 7\n", + " -> 5\n", + " -> 3\n" + ] + } + ], + "source": [ + "root = BinaryTree(10)\n", + "root.insert(5)\n", + "root.insert(15)\n", + "root.insert(3)\n", + "root.insert(7)\n", + "root.insert(12)\n", + "root.insert(17)\n", + "\n", + "root.Print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3.1 Задание\n", + "\n", + "Постройте классификатор на основе дерева принятия решений следующего датасета:\n", + "\n", + "```python\n", + "X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])\n", + "target = [0, 0, 0, 1, 1, 1]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "ds = pd.DataFrame(np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]))\n", + "target = [0, 0, 0, 1, 1, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [], + "source": [ + "x_train, x_test, y_train, y_test = train_test_split(ds, target, test_size=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 0.75, 'x[1] <= -0.5\\ngini = 0.375\\nsamples = 4\\nvalue = [1, 3]'),\n", + " Text(0.25, 0.25, 'gini = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n", + " Text(0.375, 0.5, 'True '),\n", + " Text(0.75, 0.25, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 3]'),\n", + " Text(0.625, 0.5, ' False')]" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "classifier = DecisionTreeClassifier()\n", + "classifier.fit(x_train, y_train)\n", + "\n", + "tree.plot_tree(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 0]\n", + "[[2]]\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 2\n", + "\n", + " accuracy 1.00 2\n", + " macro avg 1.00 1.00 1.00 2\n", + "weighted avg 1.00 1.00 1.00 2\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nktkln/.pyenv/versions/3.11.0/lib/python3.11/site-packages/sklearn/metrics/_classification.py:409: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "y_pred = classifier.predict(x_test)\n", + "\n", + "print(y_pred)\n", + "print(confusion_matrix(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.4.1 Задание\n", + "\n", + "Задание. Постройте модель регрессии для данных из предыдущей рабочей \n", + "тетради.Для примера можно взять потребления газа (в миллионах \n", + "галлонов) в 48 штатах США или набор данных о качестве красного вина: \n", + "https://raw.githubusercontent.com/likarajo/petrol_consumption/master/data/petrol_consumption.csv \n", + "https://raw.githubusercontent.com/aniruddhachoudhury/Red-Wine-Quality/master/winequality-red.csv \n", + "\n", + "Постройте прогноз. Оцените точность модели." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
fixed acidityvolatile aciditycitric acidresidual sugarchloridesfree sulfur dioxidetotal sulfur dioxidedensitypHsulphatesalcoholquality
count1599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.000000
mean8.3196370.5278210.2709762.5388060.08746715.87492246.4677920.9967473.3111130.65814910.4229835.636023
std1.7410960.1790600.1948011.4099280.04706510.46015732.8953240.0018870.1543860.1695071.0656680.807569
min4.6000000.1200000.0000000.9000000.0120001.0000006.0000000.9900702.7400000.3300008.4000003.000000
25%7.1000000.3900000.0900001.9000000.0700007.00000022.0000000.9956003.2100000.5500009.5000005.000000
50%7.9000000.5200000.2600002.2000000.07900014.00000038.0000000.9967503.3100000.62000010.2000006.000000
75%9.2000000.6400000.4200002.6000000.09000021.00000062.0000000.9978353.4000000.73000011.1000006.000000
max15.9000001.5800001.00000015.5000000.61100072.000000289.0000001.0036904.0100002.00000014.9000008.000000
\n", + "
" + ], + "text/plain": [ + " fixed acidity volatile acidity citric acid residual sugar \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", + "mean 8.319637 0.527821 0.270976 2.538806 \n", + "std 1.741096 0.179060 0.194801 1.409928 \n", + "min 4.600000 0.120000 0.000000 0.900000 \n", + "25% 7.100000 0.390000 0.090000 1.900000 \n", + "50% 7.900000 0.520000 0.260000 2.200000 \n", + "75% 9.200000 0.640000 0.420000 2.600000 \n", + "max 15.900000 1.580000 1.000000 15.500000 \n", + "\n", + " chlorides free sulfur dioxide total sulfur dioxide density \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", + "mean 0.087467 15.874922 46.467792 0.996747 \n", + "std 0.047065 10.460157 32.895324 0.001887 \n", + "min 0.012000 1.000000 6.000000 0.990070 \n", + "25% 0.070000 7.000000 22.000000 0.995600 \n", + "50% 0.079000 14.000000 38.000000 0.996750 \n", + "75% 0.090000 21.000000 62.000000 0.997835 \n", + "max 0.611000 72.000000 289.000000 1.003690 \n", + "\n", + " pH sulphates alcohol quality \n", + "count 1599.000000 1599.000000 1599.000000 1599.000000 \n", + "mean 3.311113 0.658149 10.422983 5.636023 \n", + "std 0.154386 0.169507 1.065668 0.807569 \n", + "min 2.740000 0.330000 8.400000 3.000000 \n", + "25% 3.210000 0.550000 9.500000 5.000000 \n", + "50% 3.310000 0.620000 10.200000 6.000000 \n", + "75% 3.400000 0.730000 11.100000 6.000000 \n", + "max 4.010000 2.000000 14.900000 8.000000 " + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/aniruddhachoudhury/Red-Wine-Quality/master/winequality-red.csv'\n", + "\n", + "ds = pd.read_csv(url)\n", + "\n", + "ds.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [], + "source": [ + "X = ds.iloc[:, :-1].values\n", + "y = ds.iloc[:, -1].values\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.49800740259424797, 0.9722222222222222, 'x[10] <= 10.525\\nsquared_error = 0.671\\nsamples = 1279\\nvalue = 5.647'),\n", + " Text(0.214837677322192, 0.9166666666666666, 'x[9] <= 0.575\\nsquared_error = 0.431\\nsamples = 789\\nvalue = 5.373'),\n", + " Text(0.35642253995822, 0.9444444444444444, 'True '),\n", + " Text(0.10466867469879518, 0.8611111111111112, 'x[4] <= 0.251\\nsquared_error = 0.329\\nsamples = 323\\nvalue = 5.164'),\n", + " Text(0.101559463661096, 0.8055555555555556, 'x[1] <= 0.587\\nsquared_error = 0.316\\nsamples = 322\\nvalue = 5.171'),\n", + " Text(0.07267780800621843, 0.75, 'x[10] <= 10.05\\nsquared_error = 0.338\\nsamples = 148\\nvalue = 5.284'),\n", + " Text(0.04508356004663817, 0.6944444444444444, 'x[4] <= 0.08\\nsquared_error = 0.267\\nsamples = 114\\nvalue = 5.175'),\n", + " Text(0.027982899339292655, 0.6388888888888888, 'x[7] <= 0.996\\nsquared_error = 0.38\\nsamples = 58\\nvalue = 5.293'),\n", + " Text(0.01554605518849592, 0.5833333333333334, 'x[8] <= 3.365\\nsquared_error = 0.196\\nsamples = 15\\nvalue = 4.933'),\n", + " Text(0.009327633113097552, 0.5277777777777778, 'x[1] <= 0.44\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 5.091'),\n", + " Text(0.006218422075398368, 0.4722222222222222, 'x[6] <= 91.0\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.003109211037699184, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.009327633113097552, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.012436844150796735, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", + " Text(0.021764477263894286, 0.5277777777777778, 'x[5] <= 13.5\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 4.5'),\n", + " Text(0.018655266226195105, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.02487368830159347, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.04041974349008939, 0.5833333333333334, 'x[2] <= 0.075\\nsquared_error = 0.383\\nsamples = 43\\nvalue = 5.419'),\n", + " Text(0.034201321414691024, 0.5277777777777778, 'x[4] <= 0.073\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 6.2'),\n", + " Text(0.03109211037699184, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.03731053245239021, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.046638165565487756, 0.5277777777777778, 'x[8] <= 3.375\\nsquared_error = 0.321\\nsamples = 38\\nvalue = 5.316'),\n", + " Text(0.04352895452778857, 0.4722222222222222, 'x[4] <= 0.058\\nsquared_error = 0.298\\nsamples = 34\\nvalue = 5.235'),\n", + " Text(0.04041974349008939, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.046638165565487756, 0.4166666666666667, 'x[3] <= 3.9\\nsquared_error = 0.259\\nsamples = 33\\nvalue = 5.273'),\n", + " Text(0.04352895452778857, 0.3611111111111111, 'x[7] <= 1.0\\nsquared_error = 0.215\\nsamples = 32\\nvalue = 5.312'),\n", + " Text(0.04041974349008939, 0.3055555555555556, 'x[7] <= 0.996\\nsquared_error = 0.196\\nsamples = 30\\nvalue = 5.267'),\n", + " Text(0.034201321414691024, 0.25, 'x[8] <= 3.31\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", + " Text(0.03109211037699184, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.03731053245239021, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.046638165565487756, 0.25, 'x[5] <= 5.5\\nsquared_error = 0.139\\nsamples = 24\\nvalue = 5.167'),\n", + " Text(0.04352895452778857, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.04974737660318694, 0.19444444444444445, 'x[0] <= 7.25\\nsquared_error = 0.113\\nsamples = 23\\nvalue = 5.13'),\n", + " Text(0.046638165565487756, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.052856587640886125, 0.1388888888888889, 'x[6] <= 77.5\\nsquared_error = 0.083\\nsamples = 22\\nvalue = 5.091'),\n", + " Text(0.04974737660318694, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 15\\nvalue = 5.0'),\n", + " Text(0.05596579867858531, 0.08333333333333333, 'x[6] <= 116.5\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 5.286'),\n", + " Text(0.052856587640886125, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.059075009716284495, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.046638165565487756, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.04974737660318694, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.04974737660318694, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.06218422075398368, 0.6388888888888888, 'x[6] <= 14.5\\nsquared_error = 0.122\\nsamples = 56\\nvalue = 5.054'),\n", + " Text(0.059075009716284495, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.06529343179168286, 0.5833333333333334, 'x[10] <= 9.75\\nsquared_error = 0.104\\nsamples = 55\\nvalue = 5.073'),\n", + " Text(0.059075009716284495, 0.5277777777777778, 'x[10] <= 9.025\\nsquared_error = 0.06\\nsamples = 50\\nvalue = 5.02'),\n", + " Text(0.05596579867858531, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.06218422075398368, 0.4722222222222222, 'x[10] <= 9.075\\nsquared_error = 0.041\\nsamples = 49\\nvalue = 5.0'),\n", + " Text(0.059075009716284495, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.06529343179168286, 0.4166666666666667, 'x[8] <= 3.36\\nsquared_error = 0.02\\nsamples = 48\\nvalue = 5.021'),\n", + " Text(0.06218422075398368, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 41\\nvalue = 5.0'),\n", + " Text(0.06840264282938205, 0.3611111111111111, 'x[5] <= 14.0\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 5.143'),\n", + " Text(0.06529343179168286, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.07151185386708123, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", + " Text(0.07151185386708123, 0.5277777777777778, 'x[0] <= 7.45\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.6'),\n", + " Text(0.06840264282938205, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.07462106490478042, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.10027205596579868, 0.6944444444444444, 'x[2] <= 0.015\\nsquared_error = 0.405\\nsamples = 34\\nvalue = 5.647'),\n", + " Text(0.0971628449280995, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.10338126700349787, 0.6388888888888888, 'x[1] <= 0.565\\nsquared_error = 0.309\\nsamples = 32\\nvalue = 5.562'),\n", + " Text(0.0948309366498251, 0.5833333333333334, 'x[10] <= 10.45\\nsquared_error = 0.226\\nsamples = 29\\nvalue = 5.655'),\n", + " Text(0.08705790905557714, 0.5277777777777778, 'x[3] <= 1.85\\nsquared_error = 0.166\\nsamples = 19\\nvalue = 5.789'),\n", + " Text(0.08083948698017877, 0.4722222222222222, 'x[10] <= 10.35\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.0777302759424796, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.08394869801787797, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.09327633113097551, 0.4722222222222222, 'x[9] <= 0.535\\nsquared_error = 0.109\\nsamples = 16\\nvalue = 5.875'),\n", + " Text(0.09016712009327633, 0.4166666666666667, 'x[1] <= 0.465\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", + " Text(0.08705790905557714, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.09327633113097551, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.0963855421686747, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", + " Text(0.10260396424407307, 0.5277777777777778, 'x[8] <= 3.305\\nsquared_error = 0.24\\nsamples = 10\\nvalue = 5.4'),\n", + " Text(0.09949475320637388, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", + " Text(0.10571317528177225, 0.4722222222222222, 'x[4] <= 0.08\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", + " Text(0.10260396424407307, 0.4166666666666667, 'x[2] <= 0.485\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.09949475320637388, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.10571317528177225, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.10882238631947143, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.11193159735717062, 0.5833333333333334, 'x[5] <= 15.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.667'),\n", + " Text(0.10882238631947143, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.1150408083948698, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.13044111931597357, 0.75, 'x[3] <= 1.25\\nsquared_error = 0.276\\nsamples = 174\\nvalue = 5.075'),\n", + " Text(0.1273319082782744, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.13355033035367275, 0.6944444444444444, 'x[7] <= 0.994\\nsquared_error = 0.256\\nsamples = 173\\nvalue = 5.064'),\n", + " Text(0.13044111931597357, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", + " Text(0.13665954139137193, 0.6388888888888888, 'x[5] <= 3.5\\nsquared_error = 0.24\\nsamples = 170\\nvalue = 5.082'),\n", + " Text(0.12436844150796736, 0.5833333333333334, 'x[10] <= 10.25\\nsquared_error = 1.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.12125923047026817, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", + " Text(0.12747765254566654, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.14895064127477653, 0.5833333333333334, 'x[9] <= 0.495\\nsquared_error = 0.217\\nsamples = 168\\nvalue = 5.095'),\n", + " Text(0.1336960746210649, 0.5277777777777778, 'x[0] <= 8.85\\nsquared_error = 0.126\\nsamples = 47\\nvalue = 4.957'),\n", + " Text(0.12747765254566654, 0.4722222222222222, 'x[1] <= 0.752\\nsquared_error = 0.09\\nsamples = 40\\nvalue = 4.9'),\n", + " Text(0.12436844150796736, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 25\\nvalue = 5.0'),\n", + " Text(0.13058686358336571, 0.4166666666666667, 'x[2] <= 0.265\\nsquared_error = 0.196\\nsamples = 15\\nvalue = 4.733'),\n", + " Text(0.12747765254566654, 0.3611111111111111, 'x[2] <= 0.015\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 4.846'),\n", + " Text(0.12436844150796736, 0.3055555555555556, 'x[4] <= 0.095\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.333'),\n", + " Text(0.12125923047026817, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.12747765254566654, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.13058686358336571, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 10\\nvalue = 5.0'),\n", + " Text(0.1336960746210649, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.13991449669646328, 0.4722222222222222, 'x[0] <= 9.1\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 5.286'),\n", + " Text(0.1368052856587641, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.14302370773416245, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.16420520792848814, 0.5277777777777778, 'x[4] <= 0.062\\nsquared_error = 0.242\\nsamples = 121\\nvalue = 5.149'),\n", + " Text(0.15235134084726001, 0.4722222222222222, 'x[6] <= 30.0\\nsquared_error = 1.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.14924212980956084, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.1554605518849592, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", + " Text(0.1760590750097163, 0.4722222222222222, 'x[2] <= 0.23\\nsquared_error = 0.207\\nsamples = 119\\nvalue = 5.168'),\n", + " Text(0.16167897396035755, 0.4166666666666667, 'x[8] <= 3.345\\nsquared_error = 0.186\\nsamples = 81\\nvalue = 5.247'),\n", + " Text(0.1531286436066848, 0.3611111111111111, 'x[8] <= 3.305\\nsquared_error = 0.232\\nsamples = 41\\nvalue = 5.366'),\n", + " Text(0.14535561601243685, 0.3055555555555556, 'x[8] <= 3.245\\nsquared_error = 0.175\\nsamples = 31\\nvalue = 5.226'),\n", + " Text(0.14224640497473767, 0.25, 'x[0] <= 8.1\\nsquared_error = 0.249\\nsamples = 15\\nvalue = 5.467'),\n", + " Text(0.1360279828993393, 0.19444444444444445, 'x[5] <= 10.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.833'),\n", + " Text(0.1329187718616401, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.13913719393703847, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.14846482705013603, 0.19444444444444445, 'x[10] <= 9.8\\nsquared_error = 0.173\\nsamples = 9\\nvalue = 5.222'),\n", + " Text(0.14535561601243685, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 7\\nvalue = 5.0'),\n", + " Text(0.1515740380878352, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.14846482705013603, 0.25, 'squared_error = 0.0\\nsamples = 16\\nvalue = 5.0'),\n", + " Text(0.16090167120093277, 0.3055555555555556, 'x[9] <= 0.535\\nsquared_error = 0.16\\nsamples = 10\\nvalue = 5.8'),\n", + " Text(0.1577924601632336, 0.25, 'x[2] <= 0.02\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.15468324912553438, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.16090167120093277, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.16401088223863194, 0.25, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", + " Text(0.17022930431403033, 0.3611111111111111, 'x[1] <= 0.595\\nsquared_error = 0.109\\nsamples = 40\\nvalue = 5.125'),\n", + " Text(0.16712009327633112, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.1733385153517295, 0.3055555555555556, 'x[10] <= 10.25\\nsquared_error = 0.073\\nsamples = 38\\nvalue = 5.079'),\n", + " Text(0.17022930431403033, 0.25, 'x[3] <= 9.3\\nsquared_error = 0.051\\nsamples = 37\\nvalue = 5.054'),\n", + " Text(0.16712009327633112, 0.19444444444444445, 'x[7] <= 0.998\\nsquared_error = 0.027\\nsamples = 36\\nvalue = 5.028'),\n", + " Text(0.16401088223863194, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 33\\nvalue = 5.0'),\n", + " Text(0.17022930431403033, 0.1388888888888889, 'x[7] <= 0.999\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.16712009327633112, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.1733385153517295, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.1733385153517295, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.17644772638942868, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.190439176059075, 0.4166666666666667, 'x[6] <= 59.5\\nsquared_error = 0.211\\nsamples = 38\\nvalue = 5.0'),\n", + " Text(0.18266614846482704, 0.3611111111111111, 'x[5] <= 10.0\\nsquared_error = 0.247\\nsamples = 9\\nvalue = 4.556'),\n", + " Text(0.17955693742712786, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.18577535950252624, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 4\\nvalue = 4.0'),\n", + " Text(0.19821220365332298, 0.3611111111111111, 'x[5] <= 17.5\\nsquared_error = 0.119\\nsamples = 29\\nvalue = 5.138'),\n", + " Text(0.1919937815779246, 0.3055555555555556, 'x[6] <= 92.0\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", + " Text(0.18888457054022542, 0.25, 'x[0] <= 8.2\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.75'),\n", + " Text(0.18577535950252624, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.1919937815779246, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.19510299261562378, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.20443062572872134, 0.3055555555555556, 'x[10] <= 10.05\\nsquared_error = 0.042\\nsamples = 23\\nvalue = 5.043'),\n", + " Text(0.20132141469102216, 0.25, 'squared_error = 0.0\\nsamples = 21\\nvalue = 5.0'),\n", + " Text(0.20753983676642052, 0.25, 'x[5] <= 23.5\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.20443062572872134, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.2106490478041197, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.10777788573649437, 0.8055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", + " Text(0.3250066799455888, 0.8611111111111112, 'x[1] <= 0.365\\nsquared_error = 0.451\\nsamples = 466\\nvalue = 5.517'),\n", + " Text(0.19976680917217257, 0.8055555555555556, 'x[9] <= 0.65\\nsquared_error = 0.457\\nsamples = 72\\nvalue = 5.958'),\n", + " Text(0.18266614846482704, 0.75, 'x[1] <= 0.355\\nsquared_error = 0.249\\nsamples = 17\\nvalue = 5.471'),\n", + " Text(0.17955693742712786, 0.6944444444444444, 'x[8] <= 3.17\\nsquared_error = 0.213\\nsamples = 13\\nvalue = 5.308'),\n", + " Text(0.17644772638942868, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.18266614846482704, 0.6388888888888888, 'x[1] <= 0.23\\nsquared_error = 0.149\\nsamples = 11\\nvalue = 5.182'),\n", + " Text(0.17955693742712786, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.18577535950252624, 0.5833333333333334, 'x[5] <= 19.5\\nsquared_error = 0.09\\nsamples = 10\\nvalue = 5.1'),\n", + " Text(0.18266614846482704, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", + " Text(0.18888457054022542, 0.5277777777777778, 'x[10] <= 9.45\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", + " Text(0.18577535950252624, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.1919937815779246, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.18577535950252624, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.21686746987951808, 0.75, 'x[10] <= 9.75\\nsquared_error = 0.424\\nsamples = 55\\nvalue = 6.109'),\n", + " Text(0.20753983676642052, 0.6944444444444444, 'x[0] <= 14.65\\nsquared_error = 0.332\\nsamples = 24\\nvalue = 5.792'),\n", + " Text(0.20443062572872134, 0.6388888888888888, 'x[10] <= 9.45\\nsquared_error = 0.217\\nsamples = 22\\nvalue = 5.682'),\n", + " Text(0.19821220365332298, 0.5833333333333334, 'x[2] <= 0.395\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 5.917'),\n", + " Text(0.19510299261562378, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.20132141469102216, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", + " Text(0.2106490478041197, 0.5833333333333334, 'x[1] <= 0.33\\nsquared_error = 0.24\\nsamples = 10\\nvalue = 5.4'),\n", + " Text(0.20753983676642052, 0.5277777777777778, 'x[9] <= 0.74\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 5.25'),\n", + " Text(0.20443062572872134, 0.4722222222222222, 'x[4] <= 0.087\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", + " Text(0.20132141469102216, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.20753983676642052, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.2106490478041197, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.2137582588418189, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.2106490478041197, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.22619510299261564, 0.6944444444444444, 'x[1] <= 0.245\\nsquared_error = 0.358\\nsamples = 31\\nvalue = 6.355'),\n", + " Text(0.21997668091721725, 0.6388888888888888, 'x[10] <= 10.45\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 5.875'),\n", + " Text(0.21686746987951808, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", + " Text(0.22308589195491643, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.232413525068014, 0.6388888888888888, 'x[5] <= 4.0\\nsquared_error = 0.336\\nsamples = 23\\nvalue = 6.522'),\n", + " Text(0.22930431403031482, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.23552273610571317, 0.5833333333333334, 'x[2] <= 0.515\\nsquared_error = 0.248\\nsamples = 22\\nvalue = 6.455'),\n", + " Text(0.22930431403031482, 0.5277777777777778, 'x[7] <= 0.998\\nsquared_error = 0.215\\nsamples = 16\\nvalue = 6.312'),\n", + " Text(0.22619510299261564, 0.4722222222222222, 'x[7] <= 0.998\\nsquared_error = 0.248\\nsamples = 11\\nvalue = 6.455'),\n", + " Text(0.22308589195491643, 0.4166666666666667, 'x[3] <= 1.5\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 6.25'),\n", + " Text(0.21997668091721725, 0.3611111111111111, 'x[1] <= 0.315\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.667'),\n", + " Text(0.21686746987951808, 0.3055555555555556, 'x[8] <= 3.39\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", + " Text(0.2137582588418189, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.21997668091721725, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.22308589195491643, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.22619510299261564, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.22930431403031482, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", + " Text(0.232413525068014, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.24174115818111155, 0.5277777777777778, 'x[7] <= 0.998\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", + " Text(0.23863194714341235, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", + " Text(0.24485036921881073, 0.4722222222222222, 'x[4] <= 0.075\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", + " Text(0.24174115818111155, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.2479595802565099, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.45024655071900505, 0.8055555555555556, 'x[6] <= 55.5\\nsquared_error = 0.408\\nsamples = 394\\nvalue = 5.437'),\n", + " Text(0.4111810143801011, 0.75, 'x[8] <= 3.535\\nsquared_error = 0.463\\nsamples = 249\\nvalue = 5.558'),\n", + " Text(0.3800767586474932, 0.6944444444444444, 'x[5] <= 33.0\\nsquared_error = 0.43\\nsamples = 227\\nvalue = 5.617'),\n", + " Text(0.33963272444617176, 0.6388888888888888, 'x[9] <= 0.685\\nsquared_error = 0.393\\nsamples = 222\\nvalue = 5.64'),\n", + " Text(0.2921686746987952, 0.5833333333333334, 'x[3] <= 1.85\\nsquared_error = 0.348\\nsamples = 142\\nvalue = 5.528'),\n", + " Text(0.2635056354450058, 0.5277777777777778, 'x[4] <= 0.083\\nsquared_error = 0.227\\nsamples = 30\\nvalue = 5.2'),\n", + " Text(0.25728721336960747, 0.4722222222222222, 'x[7] <= 0.998\\nsquared_error = 0.141\\nsamples = 21\\nvalue = 5.048'),\n", + " Text(0.2541780023319083, 0.4166666666666667, 'x[7] <= 0.996\\nsquared_error = 0.09\\nsamples = 20\\nvalue = 5.1'),\n", + " Text(0.2510687912942091, 0.3611111111111111, 'x[10] <= 9.65\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", + " Text(0.2479595802565099, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.2541780023319083, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.25728721336960747, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 15\\nvalue = 5.0'),\n", + " Text(0.26039642440730665, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.2697240575204042, 0.4722222222222222, 'x[4] <= 0.094\\nsquared_error = 0.247\\nsamples = 9\\nvalue = 5.556'),\n", + " Text(0.266614846482705, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.27283326855810336, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", + " Text(0.32083171395258453, 0.5277777777777778, 'x[3] <= 2.65\\nsquared_error = 0.344\\nsamples = 112\\nvalue = 5.616'),\n", + " Text(0.29731830547998445, 0.4722222222222222, 'x[4] <= 0.076\\nsquared_error = 0.349\\nsamples = 94\\nvalue = 5.67'),\n", + " Text(0.27905169063350177, 0.4166666666666667, 'x[5] <= 26.5\\nsquared_error = 0.358\\nsamples = 37\\nvalue = 5.514'),\n", + " Text(0.2759424795958026, 0.3611111111111111, 'x[6] <= 25.5\\nsquared_error = 0.245\\nsamples = 35\\nvalue = 5.429'),\n", + " Text(0.26506024096385544, 0.3055555555555556, 'x[10] <= 9.25\\nsquared_error = 0.18\\nsamples = 17\\nvalue = 5.765'),\n", + " Text(0.25884181888845703, 0.25, 'x[1] <= 0.46\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.25573260785075785, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.26195102992615626, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.2712786630392538, 0.25, 'x[7] <= 0.996\\nsquared_error = 0.122\\nsamples = 14\\nvalue = 5.857'),\n", + " Text(0.2681694520015546, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.274387874076953, 0.19444444444444445, 'x[9] <= 0.625\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 5.923'),\n", + " Text(0.2712786630392538, 0.1388888888888889, 'x[8] <= 3.15\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", + " Text(0.2681694520015546, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.274387874076953, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.27749708511465215, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", + " Text(0.2868247182277497, 0.3055555555555556, 'x[2] <= 0.135\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 5.111'),\n", + " Text(0.2837155071900505, 0.25, 'x[3] <= 2.15\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", + " Text(0.28060629615235133, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.2868247182277497, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.2899339292654489, 0.25, 'squared_error = 0.0\\nsamples = 13\\nvalue = 5.0'),\n", + " Text(0.28216090167120095, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.3155849203264672, 0.4166666666666667, 'x[10] <= 10.45\\nsquared_error = 0.316\\nsamples = 57\\nvalue = 5.772'),\n", + " Text(0.312475709288768, 0.3611111111111111, 'x[7] <= 0.997\\nsquared_error = 0.299\\nsamples = 54\\nvalue = 5.815'),\n", + " Text(0.29926156237854645, 0.3055555555555556, 'x[8] <= 3.475\\nsquared_error = 0.094\\nsamples = 19\\nvalue = 6.105'),\n", + " Text(0.2961523513408473, 0.25, 'x[7] <= 0.997\\nsquared_error = 0.052\\nsamples = 18\\nvalue = 6.056'),\n", + " Text(0.2930431403031481, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", + " Text(0.29926156237854645, 0.19444444444444445, 'x[6] <= 37.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.333'),\n", + " Text(0.2961523513408473, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.30237077341624563, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.30237077341624563, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.3256898561989895, 0.3055555555555556, 'x[5] <= 14.5\\nsquared_error = 0.34\\nsamples = 35\\nvalue = 5.657'),\n", + " Text(0.3225806451612903, 0.25, 'x[0] <= 9.7\\nsquared_error = 0.302\\nsamples = 29\\nvalue = 5.793'),\n", + " Text(0.31480761756704234, 0.19444444444444445, 'x[8] <= 3.265\\nsquared_error = 0.231\\nsamples = 22\\nvalue = 5.636'),\n", + " Text(0.308589195491644, 0.1388888888888889, 'x[0] <= 7.75\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", + " Text(0.3054799844539448, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.31169840652934316, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.32102603964244075, 0.1388888888888889, 'x[2] <= 0.33\\nsquared_error = 0.152\\nsamples = 16\\nvalue = 5.812'),\n", + " Text(0.3179168286047415, 0.08333333333333333, 'x[2] <= 0.085\\nsquared_error = 0.066\\nsamples = 14\\nvalue = 5.929'),\n", + " Text(0.31480761756704234, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.32102603964244075, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 13\\nvalue = 6.0'),\n", + " Text(0.32413525068013993, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.3303536727555383, 0.19444444444444445, 'x[6] <= 43.0\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 6.286'),\n", + " Text(0.3272444617178391, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.33346288379323746, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.32879906723668867, 0.25, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", + " Text(0.31869413136416636, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.3443451224251846, 0.4722222222222222, 'x[10] <= 10.35\\nsquared_error = 0.222\\nsamples = 18\\nvalue = 5.333'),\n", + " Text(0.33812670034978626, 0.4166666666666667, 'x[3] <= 7.45\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 5.154'),\n", + " Text(0.3350174893120871, 0.3611111111111111, 'x[7] <= 0.999\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 5.083'),\n", + " Text(0.33190827827438785, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 8\\nvalue = 5.0'),\n", + " Text(0.33812670034978626, 0.3055555555555556, 'x[4] <= 0.094\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", + " Text(0.3350174893120871, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.34123591138748544, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.34123591138748544, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.35056354450058297, 0.4166666666666667, 'x[3] <= 3.3\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 5.8'),\n", + " Text(0.3474543334628838, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.35367275553828215, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.3870967741935484, 0.5833333333333334, 'x[10] <= 9.85\\nsquared_error = 0.411\\nsamples = 80\\nvalue = 5.838'),\n", + " Text(0.3692188107267781, 0.5277777777777778, 'x[7] <= 0.997\\nsquared_error = 0.287\\nsamples = 44\\nvalue = 5.591'),\n", + " Text(0.3598911776136805, 0.4722222222222222, 'x[1] <= 0.385\\nsquared_error = 0.312\\nsamples = 16\\nvalue = 5.25'),\n", + " Text(0.3567819665759813, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.36300038865137974, 0.4166666666666667, 'x[10] <= 9.15\\nsquared_error = 0.116\\nsamples = 15\\nvalue = 5.133'),\n", + " Text(0.3598911776136805, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.3661095996890789, 0.3611111111111111, 'x[8] <= 3.41\\nsquared_error = 0.066\\nsamples = 14\\nvalue = 5.071'),\n", + " Text(0.36300038865137974, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 13\\nvalue = 5.0'),\n", + " Text(0.3692188107267781, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.3785464438398756, 0.4722222222222222, 'x[10] <= 9.45\\nsquared_error = 0.168\\nsamples = 28\\nvalue = 5.786'),\n", + " Text(0.37543723280217645, 0.4166666666666667, 'x[7] <= 0.998\\nsquared_error = 0.24\\nsamples = 15\\nvalue = 5.6'),\n", + " Text(0.37232802176447727, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.3785464438398756, 0.3611111111111111, 'x[2] <= 0.27\\nsquared_error = 0.188\\nsamples = 12\\nvalue = 5.75'),\n", + " Text(0.37543723280217645, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", + " Text(0.3816556548775748, 0.3055555555555556, 'x[8] <= 3.075\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", + " Text(0.3785464438398756, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.384764865915274, 0.25, 'x[6] <= 54.5\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", + " Text(0.3816556548775748, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.38787407695297316, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.3816556548775748, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 13\\nvalue = 6.0'),\n", + " Text(0.4049747376603187, 0.5277777777777778, 'x[3] <= 3.05\\nsquared_error = 0.397\\nsamples = 36\\nvalue = 6.139'),\n", + " Text(0.39720171006607075, 0.4722222222222222, 'x[1] <= 0.412\\nsquared_error = 0.333\\nsamples = 30\\nvalue = 6.0'),\n", + " Text(0.3909832879906724, 0.4166666666666667, 'x[10] <= 10.15\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 6.5'),\n", + " Text(0.38787407695297316, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", + " Text(0.39409249902837157, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.4034201321414691, 0.4166666666666667, 'x[5] <= 3.5\\nsquared_error = 0.24\\nsamples = 22\\nvalue = 5.818'),\n", + " Text(0.4003109211037699, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.4065293431791683, 0.3611111111111111, 'x[2] <= 0.465\\nsquared_error = 0.181\\nsamples = 21\\nvalue = 5.762'),\n", + " Text(0.4003109211037699, 0.3055555555555556, 'x[9] <= 1.09\\nsquared_error = 0.109\\nsamples = 16\\nvalue = 5.875'),\n", + " Text(0.39720171006607075, 0.25, 'x[8] <= 3.49\\nsquared_error = 0.062\\nsamples = 15\\nvalue = 5.933'),\n", + " Text(0.39409249902837157, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 14\\nvalue = 6.0'),\n", + " Text(0.4003109211037699, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4034201321414691, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.41274776525456663, 0.3055555555555556, 'x[1] <= 0.455\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", + " Text(0.40963855421686746, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.4158569762922658, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.41274776525456663, 0.4722222222222222, 'x[5] <= 16.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", + " Text(0.40963855421686746, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", + " Text(0.4158569762922658, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.4205207928488146, 0.6388888888888888, 'x[2] <= 0.25\\nsquared_error = 1.04\\nsamples = 5\\nvalue = 4.6'),\n", + " Text(0.41430237077341625, 0.5833333333333334, 'x[5] <= 41.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.4111931597357171, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.41741158181111543, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.42673921492421296, 0.5833333333333334, 'x[4] <= 0.146\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 3.5'),\n", + " Text(0.4236300038865138, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", + " Text(0.42984842596191214, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.4422852701127089, 0.6944444444444444, 'x[9] <= 0.635\\nsquared_error = 0.407\\nsamples = 22\\nvalue = 4.955'),\n", + " Text(0.43606684803731055, 0.6388888888888888, 'x[10] <= 9.975\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 3.667'),\n", + " Text(0.4329576369996114, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", + " Text(0.43917605907500973, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.44850369218810726, 0.6388888888888888, 'x[9] <= 0.875\\nsquared_error = 0.133\\nsamples = 19\\nvalue = 5.158'),\n", + " Text(0.4453944811504081, 0.5833333333333334, 'x[7] <= 0.995\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 5.059'),\n", + " Text(0.4422852701127089, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.44850369218810726, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 16\\nvalue = 5.0'),\n", + " Text(0.45161290322580644, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.4893120870579091, 0.75, 'x[6] <= 105.5\\nsquared_error = 0.245\\nsamples = 145\\nvalue = 5.228'),\n", + " Text(0.4760979401476875, 0.6944444444444444, 'x[10] <= 10.35\\nsquared_error = 0.286\\nsamples = 106\\nvalue = 5.302'),\n", + " Text(0.46832491255343955, 0.6388888888888888, 'x[1] <= 0.855\\nsquared_error = 0.27\\nsamples = 94\\nvalue = 5.245'),\n", + " Text(0.4621064904780412, 0.5833333333333334, 'x[4] <= 0.539\\nsquared_error = 0.245\\nsamples = 90\\nvalue = 5.278'),\n", + " Text(0.458997279440342, 0.5277777777777778, 'x[5] <= 18.5\\nsquared_error = 0.229\\nsamples = 89\\nvalue = 5.292'),\n", + " Text(0.4407306645938593, 0.4722222222222222, 'x[9] <= 0.75\\nsquared_error = 0.245\\nsamples = 35\\nvalue = 5.429'),\n", + " Text(0.43451224251846093, 0.4166666666666667, 'x[6] <= 91.5\\nsquared_error = 0.248\\nsamples = 24\\nvalue = 5.542'),\n", + " Text(0.43140303148076176, 0.3611111111111111, 'x[5] <= 13.0\\nsquared_error = 0.227\\nsamples = 20\\nvalue = 5.65'),\n", + " Text(0.4251846094053634, 0.3055555555555556, 'x[3] <= 2.05\\nsquared_error = 0.234\\nsamples = 8\\nvalue = 5.375'),\n", + " Text(0.4220753983676642, 0.25, 'x[5] <= 10.5\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.75'),\n", + " Text(0.41896618732996505, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.4251846094053634, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4282938204430626, 0.25, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", + " Text(0.4376214535561601, 0.3055555555555556, 'x[3] <= 1.7\\nsquared_error = 0.139\\nsamples = 12\\nvalue = 5.833'),\n", + " Text(0.43451224251846093, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4407306645938593, 0.25, 'x[8] <= 3.54\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 5.909'),\n", + " Text(0.4376214535561601, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", + " Text(0.44383987563155847, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4376214535561601, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", + " Text(0.4469490866692577, 0.4166666666666667, 'x[8] <= 2.95\\nsquared_error = 0.149\\nsamples = 11\\nvalue = 5.182'),\n", + " Text(0.44383987563155847, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.4500582977069569, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", + " Text(0.4772638942868247, 0.4722222222222222, 'x[10] <= 9.55\\nsquared_error = 0.199\\nsamples = 54\\nvalue = 5.204'),\n", + " Text(0.4640497473766032, 0.4166666666666667, 'x[10] <= 9.45\\nsquared_error = 0.226\\nsamples = 32\\nvalue = 5.344'),\n", + " Text(0.45627671978235523, 0.3611111111111111, 'x[7] <= 1.003\\nsquared_error = 0.094\\nsamples = 19\\nvalue = 5.105'),\n", + " Text(0.45316750874465606, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 17\\nvalue = 5.0'),\n", + " Text(0.4593859308200544, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.4718227749708511, 0.3611111111111111, 'x[4] <= 0.076\\nsquared_error = 0.213\\nsamples = 13\\nvalue = 5.692'),\n", + " Text(0.46560435289545277, 0.3055555555555556, 'x[1] <= 0.405\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", + " Text(0.4624951418577536, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.46871356393315194, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.47804119704624953, 0.3055555555555556, 'x[0] <= 9.05\\nsquared_error = 0.099\\nsamples = 9\\nvalue = 5.889'),\n", + " Text(0.47493198600855036, 0.25, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", + " Text(0.4811504080839487, 0.25, 'x[1] <= 0.52\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.47804119704624953, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4842596191216479, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.49047804119704624, 0.4166666666666667, 'x[2] <= 0.435\\nsquared_error = 0.091\\nsamples = 22\\nvalue = 5.0'),\n", + " Text(0.48736883015934707, 0.3611111111111111, 'x[0] <= 9.95\\nsquared_error = 0.045\\nsamples = 21\\nvalue = 5.048'),\n", + " Text(0.4842596191216479, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 19\\nvalue = 5.0'),\n", + " Text(0.49047804119704624, 0.3055555555555556, 'x[8] <= 3.2\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.48736883015934707, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.4935872522347454, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.4935872522347454, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.4652157015157404, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.4745433346288379, 0.5833333333333334, 'x[8] <= 3.285\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 4.5'),\n", + " Text(0.47143412359113873, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.47765254566653714, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.4838709677419355, 0.6388888888888888, 'x[3] <= 5.5\\nsquared_error = 0.188\\nsamples = 12\\nvalue = 5.75'),\n", + " Text(0.4807617567042363, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 9\\nvalue = 6.0'),\n", + " Text(0.4869801787796347, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.5025262339681306, 0.6944444444444444, 'x[8] <= 2.985\\nsquared_error = 0.076\\nsamples = 39\\nvalue = 5.026'),\n", + " Text(0.4963078118927322, 0.6388888888888888, 'x[3] <= 1.95\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", + " Text(0.49319860085503303, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.4994170229304314, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.5087446560435289, 0.6388888888888888, 'x[3] <= 1.65\\nsquared_error = 0.027\\nsamples = 36\\nvalue = 4.972'),\n", + " Text(0.5056354450058298, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.5118538670812282, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 35\\nvalue = 5.0'),\n", + " Text(0.7811771278663039, 0.9166666666666666, 'x[9] <= 0.645\\nsquared_error = 0.741\\nsamples = 490\\nvalue = 6.088'),\n", + " Text(0.6395922652302759, 0.9444444444444444, ' False'),\n", + " Text(0.6822046249514185, 0.8611111111111112, 'x[1] <= 1.015\\nsquared_error = 0.726\\nsamples = 215\\nvalue = 5.712'),\n", + " Text(0.6318013991449669, 0.8055555555555556, 'x[10] <= 11.45\\nsquared_error = 0.583\\nsamples = 206\\nvalue = 5.791'),\n", + " Text(0.5764671589584143, 0.75, 'x[1] <= 0.635\\nsquared_error = 0.527\\nsamples = 108\\nvalue = 5.528'),\n", + " Text(0.5524679362611737, 0.6944444444444444, 'x[8] <= 3.475\\nsquared_error = 0.439\\nsamples = 70\\nvalue = 5.7'),\n", + " Text(0.5378935095219588, 0.6388888888888888, 'x[4] <= 0.067\\nsquared_error = 0.427\\nsamples = 60\\nvalue = 5.8'),\n", + " Text(0.5180722891566265, 0.5833333333333334, 'x[4] <= 0.059\\nsquared_error = 0.61\\nsamples = 10\\nvalue = 6.3'),\n", + " Text(0.5118538670812282, 0.5277777777777778, 'x[9] <= 0.53\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 5.5'),\n", + " Text(0.5087446560435289, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.5149630781189273, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.5242907112320249, 0.5277777777777778, 'x[8] <= 3.43\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", + " Text(0.5211815001943257, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", + " Text(0.5273999222697241, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.5577147298872911, 0.5833333333333334, 'x[9] <= 0.585\\nsquared_error = 0.33\\nsamples = 50\\nvalue = 5.7'),\n", + " Text(0.5445005829770696, 0.5277777777777778, 'x[10] <= 11.05\\nsquared_error = 0.402\\nsamples = 26\\nvalue = 5.462'),\n", + " Text(0.5336183443451225, 0.4722222222222222, 'x[10] <= 10.85\\nsquared_error = 0.277\\nsamples = 16\\nvalue = 5.188'),\n", + " Text(0.5273999222697241, 0.4166666666666667, 'x[9] <= 0.525\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 5.571'),\n", + " Text(0.5242907112320249, 0.3611111111111111, 'x[0] <= 8.25\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", + " Text(0.5211815001943257, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.5273999222697241, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.5305091333074232, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.5398367664205208, 0.4166666666666667, 'x[2] <= 0.04\\nsquared_error = 0.099\\nsamples = 9\\nvalue = 4.889'),\n", + " Text(0.5367275553828216, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.5429459774582199, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 8\\nvalue = 5.0'),\n", + " Text(0.5553828216090168, 0.4722222222222222, 'x[0] <= 9.45\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 5.9'),\n", + " Text(0.5522736105713175, 0.4166666666666667, 'x[9] <= 0.575\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 6.125'),\n", + " Text(0.5491643995336184, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", + " Text(0.5553828216090168, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.5584920326467159, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.5709288767975126, 0.5277777777777778, 'x[3] <= 2.9\\nsquared_error = 0.123\\nsamples = 24\\nvalue = 5.958'),\n", + " Text(0.5678196657598135, 0.4722222222222222, 'x[1] <= 0.34\\nsquared_error = 0.079\\nsamples = 23\\nvalue = 5.913'),\n", + " Text(0.5647104547221142, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.5709288767975126, 0.4166666666666667, 'x[1] <= 0.61\\nsquared_error = 0.043\\nsamples = 22\\nvalue = 5.955'),\n", + " Text(0.5678196657598135, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 20\\nvalue = 6.0'),\n", + " Text(0.5740380878352118, 0.3611111111111111, 'x[8] <= 3.375\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.5709288767975126, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.577147298872911, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.5740380878352118, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.5670423630003887, 0.6388888888888888, 'x[7] <= 0.996\\nsquared_error = 0.09\\nsamples = 10\\nvalue = 5.1'),\n", + " Text(0.5639331519626894, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", + " Text(0.5701515740380878, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.6004663816556549, 0.6944444444444444, 'x[5] <= 6.5\\nsquared_error = 0.535\\nsamples = 38\\nvalue = 5.211'),\n", + " Text(0.5864749319860085, 0.6388888888888888, 'x[1] <= 0.81\\nsquared_error = 0.222\\nsamples = 12\\nvalue = 4.667'),\n", + " Text(0.5802565099106102, 0.5833333333333334, 'x[6] <= 10.0\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 4.875'),\n", + " Text(0.577147298872911, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.5833657209483094, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 7\\nvalue = 5.0'),\n", + " Text(0.5926933540614069, 0.5833333333333334, 'x[7] <= 0.996\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 4.25'),\n", + " Text(0.5895841430237078, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.5958025650991061, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", + " Text(0.6144578313253012, 0.6388888888888888, 'x[6] <= 45.5\\nsquared_error = 0.479\\nsamples = 26\\nvalue = 5.462'),\n", + " Text(0.6051301982122037, 0.5833333333333334, 'x[2] <= 0.08\\nsquared_error = 0.312\\nsamples = 16\\nvalue = 5.75'),\n", + " Text(0.6020209871745045, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", + " Text(0.6082394092499028, 0.5277777777777778, 'x[9] <= 0.505\\nsquared_error = 0.56\\nsamples = 5\\nvalue = 5.2'),\n", + " Text(0.6051301982122037, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.6113486202876021, 0.4722222222222222, 'x[7] <= 0.996\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.667'),\n", + " Text(0.6082394092499028, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.6144578313253012, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.6237854644383988, 0.5833333333333334, 'x[3] <= 3.0\\nsquared_error = 0.4\\nsamples = 10\\nvalue = 5.0'),\n", + " Text(0.6206762534006995, 0.5277777777777778, 'x[8] <= 3.48\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 5.25'),\n", + " Text(0.6175670423630004, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.6237854644383988, 0.4722222222222222, 'x[5] <= 13.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", + " Text(0.6206762534006995, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.6268946754760979, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.6268946754760979, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", + " Text(0.6871356393315197, 0.75, 'x[1] <= 0.485\\nsquared_error = 0.483\\nsamples = 98\\nvalue = 6.082'),\n", + " Text(0.6634279051690634, 0.6944444444444444, 'x[8] <= 3.275\\nsquared_error = 0.436\\nsamples = 50\\nvalue = 6.38'),\n", + " Text(0.6502137582588419, 0.6388888888888888, 'x[0] <= 10.1\\nsquared_error = 0.38\\nsamples = 29\\nvalue = 6.586'),\n", + " Text(0.6393315196268947, 0.5833333333333334, 'x[1] <= 0.245\\nsquared_error = 0.28\\nsamples = 23\\nvalue = 6.739'),\n", + " Text(0.6362223085891955, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.6424407306645938, 0.5277777777777778, 'x[1] <= 0.32\\nsquared_error = 0.228\\nsamples = 20\\nvalue = 6.85'),\n", + " Text(0.6362223085891955, 0.4722222222222222, 'x[0] <= 9.95\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 7.083'),\n", + " Text(0.6331130975514964, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 11\\nvalue = 7.0'),\n", + " Text(0.6393315196268947, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.6486591527399922, 0.4722222222222222, 'x[1] <= 0.4\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 6.5'),\n", + " Text(0.6455499417022931, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.6517683637776914, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", + " Text(0.661095996890789, 0.5833333333333334, 'x[2] <= 0.72\\nsquared_error = 0.333\\nsamples = 6\\nvalue = 6.0'),\n", + " Text(0.6579867858530898, 0.5277777777777778, 'x[1] <= 0.265\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 5.8'),\n", + " Text(0.6548775748153906, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.661095996890789, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.6642052079284881, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.6766420520792849, 0.6388888888888888, 'x[3] <= 6.1\\nsquared_error = 0.372\\nsamples = 21\\nvalue = 6.095'),\n", + " Text(0.6735328410415857, 0.5833333333333334, 'x[0] <= 5.8\\nsquared_error = 0.16\\nsamples = 20\\nvalue = 6.2'),\n", + " Text(0.6704236300038865, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.6766420520792849, 0.5277777777777778, 'x[3] <= 5.25\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.111'),\n", + " Text(0.6735328410415857, 0.4722222222222222, 'x[6] <= 9.5\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.059'),\n", + " Text(0.6704236300038865, 0.4166666666666667, 'x[4] <= 0.066\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", + " Text(0.6673144189661874, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.6735328410415857, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.6766420520792849, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", + " Text(0.6797512631169841, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.6797512631169841, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.7108433734939759, 0.6944444444444444, 'x[4] <= 0.058\\nsquared_error = 0.343\\nsamples = 48\\nvalue = 5.771'),\n", + " Text(0.6984065293431791, 0.6388888888888888, 'x[1] <= 0.68\\nsquared_error = 0.373\\nsamples = 15\\nvalue = 5.4'),\n", + " Text(0.6921881072677808, 0.5833333333333334, 'x[6] <= 102.5\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 5.0'),\n", + " Text(0.6890788962300817, 0.5277777777777778, 'x[2] <= 0.03\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 4.857'),\n", + " Text(0.6859696851923824, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.6921881072677808, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", + " Text(0.69529731830548, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.7046249514185775, 0.5833333333333334, 'x[3] <= 2.45\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 5.857'),\n", + " Text(0.7015157403808784, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", + " Text(0.7077341624562767, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.7232802176447727, 0.6388888888888888, 'x[10] <= 12.85\\nsquared_error = 0.239\\nsamples = 33\\nvalue = 5.939'),\n", + " Text(0.7201710066070734, 0.5833333333333334, 'x[9] <= 0.525\\nsquared_error = 0.194\\nsamples = 31\\nvalue = 6.0'),\n", + " Text(0.7139525845316751, 0.5277777777777778, 'x[9] <= 0.515\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", + " Text(0.7108433734939759, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.7170617955693742, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", + " Text(0.7263894286824718, 0.5277777777777778, 'x[4] <= 0.059\\nsquared_error = 0.106\\nsamples = 25\\nvalue = 6.12'),\n", + " Text(0.7232802176447727, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.729498639720171, 0.4722222222222222, 'x[5] <= 4.0\\nsquared_error = 0.076\\nsamples = 24\\nvalue = 6.083'),\n", + " Text(0.7263894286824718, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.7326078507578702, 0.4166666666666667, 'x[4] <= 0.091\\nsquared_error = 0.042\\nsamples = 23\\nvalue = 6.043'),\n", + " Text(0.729498639720171, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 20\\nvalue = 6.0'),\n", + " Text(0.7357170617955694, 0.3611111111111111, 'x[6] <= 15.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.333'),\n", + " Text(0.7326078507578702, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.7388262728332685, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.7263894286824718, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.7326078507578702, 0.8055555555555556, 'x[3] <= 1.9\\nsquared_error = 0.543\\nsamples = 9\\nvalue = 3.889'),\n", + " Text(0.729498639720171, 0.75, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.7357170617955694, 0.75, 'x[2] <= 0.04\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 3.571'),\n", + " Text(0.7326078507578702, 0.6944444444444444, 'x[0] <= 6.85\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 3.25'),\n", + " Text(0.729498639720171, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.7357170617955694, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 3.0'),\n", + " Text(0.7388262728332685, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", + " Text(0.8801496307811892, 0.8611111111111112, 'x[10] <= 11.55\\nsquared_error = 0.556\\nsamples = 275\\nvalue = 6.382'),\n", + " Text(0.8251068791294209, 0.8055555555555556, 'x[1] <= 0.395\\nsquared_error = 0.559\\nsamples = 158\\nvalue = 6.171'),\n", + " Text(0.7784687135639331, 0.75, 'x[8] <= 3.255\\nsquared_error = 0.605\\nsamples = 73\\nvalue = 6.466'),\n", + " Text(0.7481539059463661, 0.6944444444444444, 'x[9] <= 0.705\\nsquared_error = 0.37\\nsamples = 31\\nvalue = 6.871'),\n", + " Text(0.7419354838709677, 0.6388888888888888, 'x[4] <= 0.079\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 7.5'),\n", + " Text(0.7388262728332685, 0.5833333333333334, 'x[10] <= 10.8\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 7.75'),\n", + " Text(0.7357170617955694, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.7419354838709677, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 8.0'),\n", + " Text(0.7450446949086669, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.7543723280217645, 0.6388888888888888, 'x[7] <= 0.995\\nsquared_error = 0.282\\nsamples = 25\\nvalue = 6.72'),\n", + " Text(0.7512631169840653, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.7574815390594637, 0.5833333333333334, 'x[2] <= 0.345\\nsquared_error = 0.222\\nsamples = 24\\nvalue = 6.667'),\n", + " Text(0.7543723280217645, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.7605907500971628, 0.5277777777777778, 'x[1] <= 0.375\\nsquared_error = 0.181\\nsamples = 21\\nvalue = 6.762'),\n", + " Text(0.7574815390594637, 0.4722222222222222, 'x[10] <= 11.3\\nsquared_error = 0.133\\nsamples = 19\\nvalue = 6.842'),\n", + " Text(0.7543723280217645, 0.4166666666666667, 'x[5] <= 23.5\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.889'),\n", + " Text(0.7512631169840653, 0.3611111111111111, 'x[9] <= 1.055\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.941'),\n", + " Text(0.7481539059463661, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 16\\nvalue = 7.0'),\n", + " Text(0.7543723280217645, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.7574815390594637, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.7605907500971628, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.763699961134862, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.8087835211815002, 0.6944444444444444, 'x[6] <= 52.0\\nsquared_error = 0.567\\nsamples = 42\\nvalue = 6.167'),\n", + " Text(0.7916828604741547, 0.6388888888888888, 'x[2] <= 0.47\\nsquared_error = 0.444\\nsamples = 28\\nvalue = 6.357'),\n", + " Text(0.779246016323358, 0.5833333333333334, 'x[7] <= 0.994\\nsquared_error = 0.349\\nsamples = 18\\nvalue = 6.611'),\n", + " Text(0.7730275942479595, 0.5277777777777778, 'x[1] <= 0.185\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", + " Text(0.7699183832102604, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.7761368052856588, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.7854644383987563, 0.5277777777777778, 'x[2] <= 0.335\\nsquared_error = 0.16\\nsamples = 15\\nvalue = 6.8'),\n", + " Text(0.7823552273610571, 0.4722222222222222, 'x[1] <= 0.315\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 6.4'),\n", + " Text(0.779246016323358, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.7854644383987563, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.7885736494364555, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 10\\nvalue = 7.0'),\n", + " Text(0.8041197046249514, 0.5833333333333334, 'x[10] <= 10.65\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 5.9'),\n", + " Text(0.7979012825495531, 0.5277777777777778, 'x[7] <= 0.997\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.7947920715118538, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8010104935872522, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.8103381267003498, 0.5277777777777778, 'x[5] <= 5.5\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 6.143'),\n", + " Text(0.8072289156626506, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.813447337738049, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", + " Text(0.8258841818888457, 0.6388888888888888, 'x[0] <= 8.05\\nsquared_error = 0.597\\nsamples = 14\\nvalue = 5.786'),\n", + " Text(0.8196657598134474, 0.5833333333333334, 'x[10] <= 11.35\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", + " Text(0.8165565487757481, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.8227749708511465, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8321026039642441, 0.5833333333333334, 'x[2] <= 0.56\\nsquared_error = 0.438\\nsamples = 8\\nvalue = 6.25'),\n", + " Text(0.8289933929265448, 0.5277777777777778, 'x[1] <= 0.345\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 6.429'),\n", + " Text(0.8258841818888457, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", + " Text(0.8321026039642441, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", + " Text(0.8352118150019433, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.8717450446949087, 0.75, 'x[4] <= 0.093\\nsquared_error = 0.381\\nsamples = 85\\nvalue = 5.918'),\n", + " Text(0.8585308977846872, 0.6944444444444444, 'x[6] <= 73.5\\nsquared_error = 0.279\\nsamples = 68\\nvalue = 6.015'),\n", + " Text(0.8507578701904391, 0.6388888888888888, 'x[10] <= 11.45\\nsquared_error = 0.235\\nsamples = 62\\nvalue = 6.081'),\n", + " Text(0.8445394481150408, 0.5833333333333334, 'x[4] <= 0.09\\nsquared_error = 0.206\\nsamples = 58\\nvalue = 6.034'),\n", + " Text(0.8414302370773417, 0.5277777777777778, 'x[8] <= 3.57\\nsquared_error = 0.179\\nsamples = 56\\nvalue = 6.0'),\n", + " Text(0.8383210260396424, 0.4722222222222222, 'x[10] <= 10.575\\nsquared_error = 0.147\\nsamples = 54\\nvalue = 5.963'),\n", + " Text(0.8352118150019433, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.8414302370773417, 0.4166666666666667, 'x[7] <= 1.0\\nsquared_error = 0.129\\nsamples = 53\\nvalue = 5.943'),\n", + " Text(0.8328799067236689, 0.3611111111111111, 'x[2] <= 0.29\\nsquared_error = 0.104\\nsamples = 48\\nvalue = 5.979'),\n", + " Text(0.8251068791294209, 0.3055555555555556, 'x[6] <= 36.5\\nsquared_error = 0.09\\nsamples = 30\\nvalue = 5.9'),\n", + " Text(0.8219976680917217, 0.25, 'x[0] <= 7.7\\nsquared_error = 0.152\\nsamples = 16\\nvalue = 5.812'),\n", + " Text(0.8157792460163233, 0.19444444444444445, 'x[10] <= 10.7\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 5.923'),\n", + " Text(0.8126700349786242, 0.1388888888888889, 'x[7] <= 0.995\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", + " Text(0.809560823940925, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8157792460163233, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.8188884570540226, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", + " Text(0.8282160901671201, 0.19444444444444445, 'x[1] <= 0.762\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", + " Text(0.8251068791294209, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.8313253012048193, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8282160901671201, 0.25, 'squared_error = 0.0\\nsamples = 14\\nvalue = 6.0'),\n", + " Text(0.8406529343179169, 0.3055555555555556, 'x[2] <= 0.315\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.111'),\n", + " Text(0.8375437232802176, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.843762145355616, 0.25, 'x[7] <= 0.996\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.059'),\n", + " Text(0.8406529343179169, 0.19444444444444445, 'x[4] <= 0.076\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", + " Text(0.8375437232802176, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.843762145355616, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8468713563933152, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", + " Text(0.8499805674310144, 0.3611111111111111, 'x[7] <= 1.0\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.6'),\n", + " Text(0.8468713563933152, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.8530897784687136, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.8445394481150408, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.84764865915274, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.8569762922658375, 0.5833333333333334, 'x[0] <= 10.05\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 6.75'),\n", + " Text(0.8538670812281384, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", + " Text(0.8600855033035367, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8663039253789351, 0.6388888888888888, 'x[9] <= 0.69\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.333'),\n", + " Text(0.863194714341236, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.8694131364166343, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", + " Text(0.8849591916051301, 0.6944444444444444, 'x[10] <= 11.15\\nsquared_error = 0.602\\nsamples = 17\\nvalue = 5.529'),\n", + " Text(0.8787407695297318, 0.6388888888888888, 'x[0] <= 8.0\\nsquared_error = 0.286\\nsamples = 7\\nvalue = 5.0'),\n", + " Text(0.8756315584920327, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", + " Text(0.881849980567431, 0.5833333333333334, 'x[5] <= 7.5\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", + " Text(0.8787407695297318, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.8849591916051301, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", + " Text(0.8911776136805286, 0.6388888888888888, 'x[6] <= 18.0\\nsquared_error = 0.49\\nsamples = 10\\nvalue = 5.9'),\n", + " Text(0.8880684026428294, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", + " Text(0.8942868247182277, 0.5833333333333334, 'x[1] <= 0.782\\nsquared_error = 0.359\\nsamples = 8\\nvalue = 6.125'),\n", + " Text(0.8911776136805286, 0.5277777777777778, 'x[8] <= 3.055\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 6.286'),\n", + " Text(0.8880684026428294, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.8942868247182277, 0.4722222222222222, 'x[4] <= 0.119\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.167'),\n", + " Text(0.8911776136805286, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.897396035755927, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.897396035755927, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.9351923824329577, 0.8055555555555556, 'x[7] <= 0.993\\nsquared_error = 0.41\\nsamples = 117\\nvalue = 6.667'),\n", + " Text(0.9036144578313253, 0.75, 'x[1] <= 0.4\\nsquared_error = 0.438\\nsamples = 13\\nvalue = 7.154'),\n", + " Text(0.9005052467936261, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", + " Text(0.9067236688690244, 0.6944444444444444, 'x[0] <= 5.45\\nsquared_error = 0.231\\nsamples = 11\\nvalue = 7.364'),\n", + " Text(0.9036144578313253, 0.6388888888888888, 'x[4] <= 0.054\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 7.125'),\n", + " Text(0.9005052467936261, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 7\\nvalue = 7.0'),\n", + " Text(0.9067236688690244, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.9098328799067237, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 8.0'),\n", + " Text(0.96677030703459, 0.75, 'x[6] <= 56.5\\nsquared_error = 0.373\\nsamples = 104\\nvalue = 6.606'),\n", + " Text(0.9397590361445783, 0.6944444444444444, 'x[9] <= 0.685\\nsquared_error = 0.352\\nsamples = 90\\nvalue = 6.678'),\n", + " Text(0.9191605130198213, 0.6388888888888888, 'x[6] <= 17.5\\nsquared_error = 0.216\\nsamples = 19\\nvalue = 6.316'),\n", + " Text(0.9129420909444228, 0.5833333333333334, 'x[1] <= 0.328\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", + " Text(0.9098328799067237, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.916051301982122, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", + " Text(0.9253789350952196, 0.5833333333333334, 'x[3] <= 5.05\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 6.077'),\n", + " Text(0.9222697240575204, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 12\\nvalue = 6.0'),\n", + " Text(0.9284881461329187, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.9603575592693354, 0.6388888888888888, 'x[10] <= 12.45\\nsquared_error = 0.344\\nsamples = 71\\nvalue = 6.775'),\n", + " Text(0.9455888068402643, 0.5833333333333334, 'x[6] <= 34.5\\nsquared_error = 0.304\\nsamples = 50\\nvalue = 6.66'),\n", + " Text(0.9347065682083171, 0.5277777777777778, 'x[5] <= 5.5\\nsquared_error = 0.228\\nsamples = 36\\nvalue = 6.778'),\n", + " Text(0.9284881461329187, 0.4722222222222222, 'x[6] <= 10.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.167'),\n", + " Text(0.9253789350952196, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.931597357170618, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", + " Text(0.9409249902837155, 0.4722222222222222, 'x[9] <= 0.695\\nsquared_error = 0.157\\nsamples = 30\\nvalue = 6.9'),\n", + " Text(0.9378157792460163, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.9440342013214147, 0.4166666666666667, 'x[3] <= 1.65\\nsquared_error = 0.119\\nsamples = 29\\nvalue = 6.862'),\n", + " Text(0.9409249902837155, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.9471434123591139, 0.3611111111111111, 'x[4] <= 0.053\\nsquared_error = 0.096\\nsamples = 28\\nvalue = 6.893'),\n", + " Text(0.9440342013214147, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.950252623396813, 0.3055555555555556, 'x[4] <= 0.161\\nsquared_error = 0.069\\nsamples = 27\\nvalue = 6.926'),\n", + " Text(0.9471434123591139, 0.25, 'x[7] <= 0.998\\nsquared_error = 0.037\\nsamples = 26\\nvalue = 6.962'),\n", + " Text(0.9440342013214147, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 22\\nvalue = 7.0'),\n", + " Text(0.950252623396813, 0.19444444444444445, 'x[7] <= 0.998\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 6.75'),\n", + " Text(0.9471434123591139, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.9533618344345123, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", + " Text(0.9533618344345123, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.9564710454722114, 0.5277777777777778, 'x[6] <= 47.0\\nsquared_error = 0.372\\nsamples = 14\\nvalue = 6.357'),\n", + " Text(0.9533618344345123, 0.4722222222222222, 'x[4] <= 0.06\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 6.1'),\n", + " Text(0.950252623396813, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.9564710454722114, 0.4166666666666667, 'x[3] <= 2.35\\nsquared_error = 0.173\\nsamples = 9\\nvalue = 6.222'),\n", + " Text(0.9533618344345123, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", + " Text(0.9595802565099106, 0.3611111111111111, 'x[5] <= 19.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.667'),\n", + " Text(0.9564710454722114, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", + " Text(0.9626894675476098, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", + " Text(0.9595802565099106, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", + " Text(0.9751263116984066, 0.5833333333333334, 'x[9] <= 0.695\\nsquared_error = 0.331\\nsamples = 21\\nvalue = 7.048'),\n", + " Text(0.9720171006607073, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 8.0'),\n", + " Text(0.9782355227361057, 0.5277777777777778, 'x[0] <= 8.75\\nsquared_error = 0.26\\nsamples = 19\\nvalue = 6.947'),\n", + " Text(0.9720171006607073, 0.4722222222222222, 'x[9] <= 0.85\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 7.154'),\n", + " Text(0.9689078896230081, 0.4166666666666667, 'x[6] <= 44.0\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 7.083'),\n", + " Text(0.965798678585309, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 11\\nvalue = 7.0'),\n", + " Text(0.9720171006607073, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.9751263116984066, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", + " Text(0.9844539448115041, 0.4722222222222222, 'x[5] <= 8.5\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 6.5'),\n", + " Text(0.9813447337738049, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", + " Text(0.9875631558492033, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", + " Text(0.9937815779246016, 0.6944444444444444, 'x[2] <= 0.69\\nsquared_error = 0.265\\nsamples = 14\\nvalue = 6.143'),\n", + " Text(0.9906723668869024, 0.6388888888888888, 'x[10] <= 13.9\\nsquared_error = 0.167\\nsamples = 12\\nvalue = 6.0'),\n", + " Text(0.9875631558492033, 0.5833333333333334, 'x[0] <= 9.15\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 6.091'),\n", + " Text(0.9844539448115041, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", + " Text(0.9906723668869024, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", + " Text(0.9937815779246016, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", + " Text(0.9968907889623008, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0')]" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "regressor = DecisionTreeRegressor()\n", + "regressor.fit(X_train, y_train)\n", + "tree.plot_tree(regressor)" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Actual Predicted\n", + "0 6 5.0\n", + "1 5 6.0\n", + "2 7 7.0\n", + "3 6 5.0\n", + "4 5 5.0\n", + ".. ... ...\n", + "315 6 6.0\n", + "316 4 7.0\n", + "317 5 5.0\n", + "318 4 5.0\n", + "319 6 7.0\n", + "\n", + "[320 rows x 2 columns]\n" + ] + } + ], + "source": [ + "y_pred = regressor.predict(X_test)\n", + "df = pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 0.709375\n", + "MAE: 0.465625\n" + ] + }, + { + "data": { + "text/plain": [ + "8.261588715046605" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print('MSE:', metrics.mean_squared_error(y_test, y_pred))\n", + "print('MAE:', metrics.mean_absolute_error(y_test, y_pred))\n", + "\n", + "metrics.mean_absolute_error(y_test, y_pred) / np.average(y) * 100" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Third term/Artificial intelligence systems and big data/README.md b/Third term/Artificial intelligence systems and big data/README.md new file mode 100755 index 0000000..e17c219 --- /dev/null +++ b/Third term/Artificial intelligence systems and big data/README.md @@ -0,0 +1,11 @@ +# Artificial intelligence systems and big data + +number | grade +:----: | :---: +1 | ✅ +2 | ❓ +3 | ❓ +4 | ❓ +5 | ❓ + +[Back](/NKTKLN/mirea-projects) diff --git a/Third term/Discrete math/1.ipynb b/Third term/Discrete math/1.ipynb new file mode 100755 index 0000000..f57190f --- /dev/null +++ b/Third term/Discrete math/1.ipynb @@ -0,0 +1,245 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import string\n", + "from collections import Counter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 1: Чтение текста из файла" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "with open('some_text.txt', 'r', encoding='utf-8') as file:\n", + " text = file.read()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 2: Привести все слова к нижнему регистру, удалить знаки препинания и пробелы" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "text = text.lower() # Приведение к нижнему регистру\n", + "text = text.translate(str.maketrans('', '', string.punctuation + '\\n')) # Удаление знаков препинания\n", + "text = text.replace(\" \", \"\") # Удаление пробелов" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "with open('new_text.txt', 'w', encoding='utf-8') as file:\n", + " file.write(text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 3: Подсчитать частоту появления однобуквенных и двухбуквенных сочетаний" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_frequencies(text):\n", + " single_char_freq = Counter(text) # Частоты однобуквенных сочетаний\n", + " bigrams = [text[i:i+2] for i in range(len(text)-1)] # Двухбуквенные сочетания\n", + " bigram_freq = Counter(bigrams)\n", + " return single_char_freq, bigram_freq" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "single_char_freq, bigram_freq = calculate_frequencies(text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 4: Определение энтропии" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_entropy(freq_dict, total_count):\n", + " entropy = 0\n", + " for freq in freq_dict.values():\n", + " p = freq / total_count\n", + " entropy -= p * math.log2(p)\n", + " return entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Энтропия на одну букву: 3.9961505474490147\n", + "Энтропия на двухбуквенное сочетание: 7.389736513198184\n" + ] + } + ], + "source": [ + "single_char_entropy = calculate_entropy(single_char_freq, len(text))\n", + "bigram_entropy = calculate_entropy(bigram_freq, len(text)-1)\n", + "\n", + "print(f\"Энтропия на одну букву: {single_char_entropy}\")\n", + "print(f\"Энтропия на двухбуквенное сочетание: {bigram_entropy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 5: Длина кода и избыточность" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Длина кода при равномерном кодировании: 4.459431618637297\n", + "Избыточность: 0.46328107118828266\n" + ] + } + ], + "source": [ + "alphabet_size = len(single_char_freq)\n", + "uniform_code_length = math.log2(alphabet_size)\n", + "redundancy = uniform_code_length - single_char_entropy\n", + "\n", + "print(f\"Длина кода при равномерном кодировании: {uniform_code_length}\")\n", + "print(f\"Избыточность: {redundancy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 6: Удаление 20% наиболее частых символов" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Энтропия после удаления 20% самых частых символов: 3.7022435891926633\n" + ] + } + ], + "source": [ + "num_to_remove = int(len(single_char_freq) * 0.2)\n", + "most_common = [char for char, _ in single_char_freq.most_common(num_to_remove)]\n", + "text_without_frequent = ''.join([char for char in text if char not in most_common])\n", + "\n", + "new_single_char_freq, _ = calculate_frequencies(text_without_frequent)\n", + "new_single_char_entropy = calculate_entropy(new_single_char_freq, len(text_without_frequent))\n", + "\n", + "print(f\"Энтропия после удаления 20% самых частых символов: {new_single_char_entropy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Этап 7: Удаление 20% наиболее редких символов" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Энтропия после удаления 20% самых редких символов: 3.9045244598725413\n" + ] + } + ], + "source": [ + "num_to_remove = int(len(single_char_freq) * 0.2)\n", + "least_common = [char for char, _ in single_char_freq.most_common()[:-num_to_remove-1:-1]]\n", + "text_without_rare = ''.join([char for char in text if char not in least_common])\n", + "\n", + "new_single_char_freq, _ = calculate_frequencies(text_without_rare)\n", + "new_single_char_entropy = calculate_entropy(new_single_char_freq, len(text_without_rare))\n", + "\n", + "print(f\"Энтропия после удаления 20% самых редких символов: {new_single_char_entropy}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Third term/Discrete math/README.md b/Third term/Discrete math/README.md new file mode 100755 index 0000000..47df3b9 --- /dev/null +++ b/Third term/Discrete math/README.md @@ -0,0 +1,7 @@ +# Artificial intelligence systems and big data + +number | grade +:----: | :---: +1 | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Third term/Discrete math/new_text.txt b/Third term/Discrete math/new_text.txt new file mode 100755 index 0000000..7fb7edd --- /dev/null +++ b/Third term/Discrete math/new_text.txt @@ -0,0 +1 @@ +loremipsumdolorsitametconsecteturadipiscingelitmorbieterosmaurisnullamnecloremfermentumviverranuncnecaccumsanerataliquamlaciniavelitnibhmorbivariusrhoncusvelitettempusnullainterdumetvestibulumegeteniminrisusfaucibustinciduntduistelluselitornareacorcieueuismodscelerisqueauguecrasvitaearcuinterdumconvallisliberoquisegestasarcuproinachendreritsemintemporenimcurabitursollicitudinerosinnullamalesuadarutrumcurabiturlacusanterutrumquisquamidcommodolaoreetnullaproinnonvehiculaenimphasellustemporcommododiamullamcorperpellentesquemetusblanditquispellentesquenisienimultriciesquissagittisvitaeornareetjustovestibulumpretiumrutrumrutrumnullafacilisinamipsumtellustincidunteumalesuadaetimperdietvitaemaurismorbicondimentumnisisitametmagnamattiscondimentumrhoncusnibheleifendproingravidaliberoblanditnislconsequatefficitursuspendisseidmagnaetauguebibendumpharetravitaenonduivivamusipsumsapiensollicitudinsitamettempusavehiculaatleomauristempormetusutgravidascelerisqueproinintristiqueodiointerdumetmalesuadafamesacanteipsumprimisinfaucibusquisqueconsectetursagittisenimettinciduntnamconsequatnullaestaconvallismassafacilisisacproinnuncmassaegestasaexvitaeimperdietpellentesquepurusintegersempermagnanibhsedcommodomiplaceratinpellentesqueullamcorperblanditnulladuisfeugiatpurusatcursustinciduntphasellusaliquamtellusatvelitefficiturcursusuteuauctorelitidsollicitudinnibhloremipsumdolorsitametconsecteturadipiscingelitintegerquisefficiturelitegetfaucibusexmorbiefficiturpurussitametpurusplaceratornarealiquaminsuscipiteroscrasultriciesnisiquisposuereiaculisfelisurnavestibulummiquisvolutpatmetusveliteuerosmaurisinrutrumligulaquisvolutpatliguladuisininterdumduidonecaligulavelitpraesentdictumloremleovelplaceratmivehiculanecvestibulumlectusestpretiumagravidasitametvehiculavitaenislduisnecultricesmaurisacvestibulumtellusutlacuselitullamcorpereurisusvelcursusposuerelectusduissitametlaoreetmetusnullamvolutpatconsecteturpurussedfaucibussuspendissenecullamcorperloremduisnequenislvolutpatinantesemperfinibusfeugiatlacusmorbiidestantevivamusattinciduntsapienatmaximuseratphaselluscongueetaugueeuismodtinciduntnuncorciquamvestibulumfermentumsemperasuscipitaantesuspendisseeratmetusornareegetpretiumeuvestibulumnonmassacurabiturarcuerategestasetturpisetdapibussuscipitorcietiamlobortisligulamaurisvitaemolestieelittristiquesedfusceipsumloremluctussitametdiamsedcondimentumtinciduntelitnullatinciduntelementumarcumaurislaoreeteliteuerosfaucibuslobortisvestibulumleoorciinterdumuttinciduntetplacerateunisinamaliquetaccumsanloremvelpharetrainsemmetusaliquetaquamsedvehiculapellentesquefelisfuscecursusduinisiintempororcibibendumsitametintegervelsuscipitnibhsedlobortisinmetusutefficiturproinduiauguefinibusacvolutpatinportaegetorcivestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraenuncsemperipsumsitametcongueviverrasedullamcorperfelisvitaelobortisvariusvestibulumidlacusacquamlobortispretiumclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosutscelerisquefermentumnuncquisvolutpatutinliberoaccumsaninterdumfelissitametinterdummaurisdonecnonvulputatesemmaecenaspellentesquefelisutmollispellentesquerisusnislelementumliberoatblanditligulanisiatdiamsedeuhendreritnequenullaporttitorlacusvitaerisusefficitursuscipitetetestetiamauctorposueresapieneumalesuadalectuseleifendetaliquamscelerisquesollicitudinnibhidfaucibusenimaccumsanutpraesentsitametdolornislmaurispulvinartinciduntnequeeulobortisdoneclobortisdapibusauguevelultriciesdiamornareanullamloremduiaccumsannecmollisaegestasutnisinullatempusinterdumligulaphasellussedmagnaligulautpellentesquelectusacexsodalesmaximussedlaoreetnibheumattispretiumnullamineratfaucibusimperdietturpisatvenenatisauguepellentesquehabitantmorbitristiquesenectusetnetusetmalesuadafamesacturpisegestasmorbiegetmattisauguenullamidodiodiamvestibulumetnislquislacussodalesviverraquisquehendreritauctorloremsedmolestiedoloretauguemaximusegetluctusnequerhoncusvestibulumvolutpatluctusvestibulumvivamusmollismassaasapienrutrumpulvinarnuncsitamettortororcinullatinciduntloremaliquetvariuseleifendaliquameratvolutpatmorbiuturnaauguepellentesquefeugiateratatfringillaconguemassaarcuullamcorperfelisingravidaliberoloremutodiopellentesqueegetorcisedlectustempuslaciniaaeneansitametgravidamaurisquisinterdumestintegereuplaceratligulamaurisdapibusaliqueturnasemperhendreritnunclaciniaeuvivamuspellentesquerisusetarcudapibusacposuereorcisagittisintegermolestiediamacmollisullamcorpersedtinciduntpretiumlectusutconvallisdoneceuismodquamneclaciniaeleifendnamgravidamassaorcisitametbibendumquamconsequateuduisegetdapibusdiamutullamcorperleomorbijustoduilobortisveldapibusinblanditsednislvestibulumfaucibusmaurisetnunclobortispellentesqueaeneaninbibendumdiamdonecfinibusaligulaaimperdietmaurissodalesnibhsempraesentaauctornislmaecenasantemaurissuscipitidpurusegetmattistinciduntaugueintegernondiamegetenimviverraiaculisquisquenecestnecleocondimentumconsecteturmaurisaccumsanvitaediamidfacilisissedfermentumvenenatislobortiscurabiturvelpellentesqueurnavivamusvestibulummivelvariusmollispraesentconvallislacusidipsumvariusquissuscipitmipellentesquequisqueetlectusantefuscesedpurusmetusquisquedapibusfelisvelnequeplaceratultricesnonquissemcrasidcongueantenamtemporvolutpatlaoreetintegermalesuadaerosegetsodalesaliquamveliturnafaucibusjustononvariusturpisligulanecmetuspraesentsedenimornarevehiculaenimatfeugiatvelitmaecenassuscipitinterdumfacilisisinhachabitasseplateadictumstfuscelobortiseufelisaccumsanconsecteturvivamusdictumultriciesfacilisispellentesquenisiturpisrhoncusutlacuseuvehiculadictumdiamquisquemattisacnequeaviverranullaporttitorfaucibuselitamolestieanteinterdumnonduisnullanislelementumetinterdumetsodalessollicitudinurnavestibulumsedfelisaexfaucibuslobortisnamfaucibusnibhegetfaucibuslobortisetiamhendreritmaurisatfinibusluctusdonecetipsumaccumsanaliquetdoloregetfermentumjustoinhachabitasseplateadictumstaeneanfaucibusquamaclacusvenenatissitametbibendumestaliquamfuscepulvinarornareenimutconvallisfusceultriciesmassamollisiaculiseuismoddonecviverraligulauttristiquedapibusjustopurusfinibusturpisvelfacilisisnisidiamacduinuncidduiinmagnafermentumornarefusceidpulvinarliberosuspendissenequeeratfringillaetbibendumvitaeplaceratvolutpatanteutposueredignissimantevitaecondimentuminterdumetmalesuadafamesacanteipsumprimisinfaucibusinhachabitasseplateadictumstduisiaculisexaclaciniafringillaexligulafermentumjustoveltempusnequeligulaidmetuspraesentnecaliquamrisusdonecinloremporttitorfringillaleoacconsequattellusfusceultricesmetusutultriciesrutrumfusceutantenonmagnascelerisqueinterduminvehiculaexarcuvelcursussapieniaculisavivamusblanditlacussedaliquammollisnullamcondimentumtellusnecvestibulumtinciduntutsuscipitturpisacaliquetauctorurnaelitinterdumsemataliquetenimdiamutleointegerdignissimmassasedblanditdapibusvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraephasellusfringillafelisutfacilisismollismiduiegestastortorvelfacilisismidiamactellusnametmaximuselitsitametlaoreettellussuspendissetempormattiselitidmolestieaeneanvestibulumtortoraccommodoelementumaeneanvitaedolornecliberoviverratempusquisnonelitpellentesquefeugiatlacusnecnuncrhoncuseuimperdietipsumfeugiatnullamcommodoestatsuscipitporttitornamsuscipitrisusattortorporttitorbibendumpraesentidfinibuserosprointempusenimodiovitaecondimentumanteconvallisegetdonecmalesuadanisietvelitbibendumaccumsanvestibulumluctusvelitvelauguevenenatisgravidaullamcorperexcommododuisvulputatelaciniavariusinhachabitasseplateadictumstnunccondimentumantediamutultricesarcuegestasvitaecrassitametnisifeugiatfermentumurnasitametultricesquamaliquamsedligulaeteratpellentesqueimperdietphasellusnecvelitsitametnibhconsequatscelerisquequisutestproinnequemassabibendumnecvariusaccongueinanteutnonsemfaucibussollicitudinenimidfacilisisleocurabiturporttitorfaucibusorciinbibendumvelitgravidaetquisquepharetravehiculaduisedplaceratnisieleifendsitametcrasmattismaurisetelitporttitoraliquammorbiegetpellentesqueipsumdonecgravidaeratdiameuvenenatisenimconsequategetorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusetiamnecpretiumnequeproinvitaeorcisemetiampulvinarenimvitaeorcivehiculaquisconguetelluslobortisseddapibustincidunteratatsemperrisusmattisegetdonecconsecteturmassadapibusauguetemporidsollicitudintortorfinibusetiamegestaspharetramaximusetiamidconsequatdiamettristiqueurnamaurissitametpurusetrisuscondimentumvestibulumdonecelementumultriciesurnavitaeultricesduisfacilisisnonseminsuscipitetiaminterdumtortorsitamettellusegestasconsecteturproinnonsuscipitarcuetpharetraloremcrascursusligulanecdiampulvinarnecconsequatnullavulputatequisquealiquamdapibusmaximusphasellusinfinibusaugueaeneanfermentumnislatmaurisrhoncuslaciniaaliquameratvolutpatvivamusutegestasmiphaselluslaoreetfinibuspurussitametmolestiesuspendisseconsecteturnequesitamethendreritinterdumorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusutattellusacmimolestiefinibuscrasegetvariusmagnaduiseleifendpurusutmetusvulputateaccumsanvitaeatleointegeraliquetvariusarcuintegeracvehiculaantenecplaceratjustonunccursusmaximusurnasedconguemauriseumaximusmaurispraesentfringillautdiamlobortisullamcorperutelementumnibhvitaenisisodaleshendreritproineuismodnibhquispurusimperdietrutrumquisquevelscelerisqueantesedplaceratnisisuspendisseaccumsanliberoetmaurisfacilisisposuereimperdietnisidignissimintegervestibulumsapieninnullaconsectetureuscelerisquefelisportavestibulumvitaejustoluctusposuerearcueufermentumurnaproinullamcorpernequealiquamnibhegestasidinterdumloremlaoreetetiamidtemporduivivamuscongueiaculisfelisacmaximuselitfeugiatquisaeneanestmassacondimentumvelvariusinvenenatisapurussedpellentesqueiaculissemeualiquamurnalobortisnonmorbimagnaarcuelementumeuorciutvenenatisaliquetlectusproinbibendumsuscipitsemidsagittisduistemporsagittisluctuspraesentetelementumdolorsitametaliquetnullanuncvitaevolutpatipsumpraesenteuleocondimentumfacilisisliberointinciduntleosuspendissevestibulumipsumnonnuncfinibusidvestibulumligulaullamcorperduisposueremattismassaidfermentumnullafacilisifuscesapiennequeporttitorquisporttitorinmaximusidquamdonecegestasmaximusmassainfaucibusnunctemporelitnonmassadapibuseudignissimestpellentesquedonecpharetraconsequataliquamquisqueatduiquiseratgravidavulputateanonexcurabiturornaremassaactinciduntplacerateratmetussuscipitdiamidconsecteturenimrisusquiseratmaurisligulamaurisvehiculautliberoinvulputatescelerisquenisidonecacipsumvitaeorciconvallisvestibulumegeteununcmaecenassitametmolestiepurusvelauctornullaaeneaniaculismaurisatrisusdictumrutrumsuspendissesempersemperturpisegetsempernibhpellentesqueligulasemporttitorutleosedtemporposuerearcuvivamusatodiotortorcurabitureuismodinterdumpuruseuconvalliscraseleifenddapibusturpisduiserosnislgravidanecbibendumutlacinianonquamcurabiturvenenatisloremsuscipiteuismodvelitcommodotristiquefelisvivamuseteniminterdumposuereenimatmaximusnuncquisquelobortisfringillaenimaornaremagnavulputateataeneanarcunullafringillavitaeenimsitametporttitoraliqueteratquisquesollicitudinpharetrapurusidvestibulumetiamegetplaceratvelitetiamfacilisisligulavitaeullamcorperfringillavestibulumvolutpatligulaeuluctusdignissimmagnanibhcursusodionecimperdietenimsapienquisturpissedaccumsannuncsitametipsumdictummattismorbietultriciesturpiscrasvulputatedolorutsemvestibulumnonsemperenimbibendumdonecfringillanisinecelitvestibulumfaucibusmaecenasnonlaciniasapienutporttitoreratcurabitureterosanisiaccumsanfacilisiseueuurnamaurisbibendumsagittisfelisutmattisnullafaucibusegetsuspendisseinelitutnibhhendreritpharetraintegernisidolormollisinturpisavehiculadictumnisletiamposuerelaciniadolorsedaliquetmetusconsecteturnecmaecenasquistinciduntorcidoneceuismodegestasmassavitaealiquamquammalesuadaegetdonecnonnisiodiomauristristiqueettellusnonfringillaintegertemporatnislvelconvallismaecenasconvallisaliquamjustovelultricesaliquamgravidaplaceratrisusvitaevenenatissuspendissealiquetsagittistortordignissimaliquetsedetmattisliberomaecenasauctortortornibhegettemporfelisbibendumvelmorbimollisarcumieuplaceratmassafermentumsitametetiamsollicitudinrhoncusurnanontristiquemassaconsequatsagittisduissagittisportaipsumnecullamcorperturpiseleifendacquisquepellentesqueimperdietduiegettempusaliquameleifendegestasmaximusaliquamefficiturenimquistelluspellentesquepulvinaridanulladuisnonpharetrasapiennullamporttitormagnamaurisvitaemollisturpisvestibulumquisdonecdignissimnislnonloremplacerategetcondimentumarcucommodosuspendissepotentivivamusconsecteturarcuutnibhviverraidsagittistellusegestasproinnonmattisdiamutinnibhnonleoplaceratfinibusaeneanconsecteturdictumnullaquisultriciescurabiturpulvinarmaximusgravidaproinvestibulumquamsedmagnasagittisegestascurabituranisimaximusenimsodalesvulputateutidloremmorbiullamcorperfringillamattisvivamuspellentesqueconsequatnibhmaurisaliqueturnaeumattismaximusleoelitconguearcuegetullamcorpernibherosidmisuspendissesempersuscipitnullaetiamaccumsannequeleointerdumetmalesuadafamesacanteipsumprimisinfaucibusquisquevulputatenibhnonmalesuadasuscipitexlacussodaleseratnecultriciesmaurisnullagravidapuruspellentesquehabitantmorbitristiquesenectusetnetusetmalesuadafamesacturpisegestasclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosmorbimattisnunceuconsecteturfeugiatmetusturpisconsecteturfeliseupulvinaripsumpurusetloremintegerelementumnullavitaetinciduntcondimentumorcijustofringillavelitacposuereestestnecduiutornarequamvariustinciduntinterdumfelisligulasempermetusvelmollisdiamdolorsedloremproinauctorauguenislnonlobortisvelitlacinialuctuscurabituractellusexdonecdignissimnecurnaidposuerefusceeratjustofermentumutelitutefficiturpretiumodiosuspendisseultriciessitametjustovelconguesedlaoreetconsequatnuncnonscelerisquetortorporttitornonnullamliberorisusporttitorvelvelitluctusdapibusrutrumnislmaurisutporttitorrisussuspendissefinibuselementumvelitvelimperdiettelluselementumsitametetiamafaucibusnislutmaximusodiocurabituridnislacnibhmalesuadasemperinquispurusnullautelementumsemvestibulumquisenimsedlacuspretiumtempusvelrhoncuserosmorbimattissodalesmetusvitaealiquamnequescelerisquesedphasellusatvolutpatlectusachendreritfelisnullamconsecteturcursusipsumquisaliquamorciluctusegetcurabiturefficiturconsecteturpurusidsuscipitlectusmaurissagittisposueredoloravestibulumlectusconsecteturveletiamaliquamconvallisipsumacondimentumlacusaccumsannecintegertortortellustinciduntnontortoratdignissimeleifendnullaetiamaligulaacmetusfeugiatpretiumnonetrisuscurabiturfinibussollicitudinipsumetornarenislcondimentumeuprointristiquenonerategetbibendumnuncfringillaexutgravidavulputatepurusfeliselementumelitidfermentummassamassaatturpiscurabituraliqueteuloremutgravidasedauctornonaugueutconsequatmorbisodalesdiamvitaevestibulumiaculisnullamatnunctortordonecnecconsequatjustoneclobortisodiophasellussitameturnaduivivamustinciduntpurusacaliquetlacinianullalacuseuismodelitvelegestasdoloraugueacjustovivamusvitaetortorscelerisqueexsagittisrhoncusinnecenimsuspendissemagnaerosfeugiatquisconsequateudictumquisnequesedvelloremdiamsuspendisseultricesidlacusvelvenenatisutetconvallisauguesedidnislurnaproinfaucibusimperdieterathendreritfaucibustortorsodalesfeugiatvivamuscommodonibhvitaeinterdumtristiquefelisnislmolestiediamsitametdapibusmimaurisegetlectusduispharetraerategetmaurismaximuseleifendpellentesqueporttitortellusutexhendreritvehiculanullamidfaucibusdoloratmollisnunccrasacmalesuadarisusquisluctusmiinefficiturcondimentummolestienunchendreritvelitidsodalesultriceslacusfelistemporlacussedauctorloremnislatexvivamusvitaeauguealiquetsuscipitnequeidvenenatissapienetiamidfacilisisnibhmaurisquisnullaeunibhtinciduntmollisutacjustonullamsemperdapibusturpisaeuismodaeneanpulvinarvestibulumodiosedvehiculamauriseuismodetcrasconsequatvariusmaximusaliquammalesuadaaliquamarcuquistristiquearcuegestasetaeneanconsecteturnullavelfeugiatultriciesantenibhvehiculaanteamattismaurisnibhsitametleosednecturpissemintegersedpharetramiduisgravidaodioquisposueretincidunttellusnibhfermentumexvitaeviverranibhlacusacloremvivamusviverrapharetraconguemaurisvestibulumvenenatisliberoegettempordonecetimperdietlacusnamsedporttitorarcuetiamaliquetestnonposuereullamcorperliguladuieleifendurnasitametposuerenisinibhatelitnullafacilisiintegertempusdiamauguequisqueullamcorpertortorvelegestassagittispurustellustemporvelitsedtemporipsumlacusacturpisdonecegetjustolobortispulvinarelitatauctorvelitcrasporttitorfermentumconsequatsuspendisseetvestibulumelitetiamutliberoetodiomattiscommodovestibulumfinibusquisnislinhendreritfusceinnislturpispraesentsodalesfaucibusturpisaaccumsanpurusrhoncuslobortiscrassitametportasapiendonecarculiberovariusegetodiositametultricesviverraenimloremipsumdolorsitametconsecteturadipiscingelitnullamnecantesitametestlaciniaultricesduisfacilisismolestiemollisutconsequatiaculispuruseudapibusnullatempusfelistellusidconguevelittinciduntvitaeinvehiculaviverralectusetconvallisdonechendreriturnasitametorcitemporfinibusaeneanlaoreetjustoaliquetelementumorciegetconvallisminullamneclectusquamaliquamegestassapienetvenenatisdignissimutmalesuadaantenislatinciduntleomaximusapellentesqueiaculisnisietportatempusproinluctusnullaaurnaultriciesvitaelaoreetmagnascelerisquenamfeugiatposuereenimnonvenenatisnullarhoncussapienaeleifendblanditcraspretiumdolorvitaeornarevulputatevelitmagnalaoreetantesitametrhoncussemmagnaquislacusmorbiauctorplaceratnequenectinciduntpraesenttempustelluseusollicitudinhendreritaugueenimfacilisisarcuegetefficiturleomaurisatortordonecpellentesquenibhvelvelitscelerisqueornarenulladuisemconvallisnecantenecpellentesqueimperdietnisinuncmolestieiaculisleonecfinibuspellentesquealuctuseratcurabitursednullavulputateconsequatenimidpulvinararcuproinporttitorexlacussitametviverralectusfinibusacutcursusconguelaoreetintegerimperdietleonecelitultricesatimperdietnislbibendumsuspendissesuscipitleoacdolorlobortissagittisvivamusullamcorperdictumerosconvallisaliquamdolorhendreritetdonecmalesuadarhoncuspharetraclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosvivamuspretiumnequenecdictumtristiquelacusnibhtemporligulavitaeultriciesmetuselitegetfelisduisquismattissempraesentegetnibhuttelluspretiumefficituracutmagnanamurnaurnavehiculainfelisidluctussollicitudinligulavestibulumaliquetligulaideleifendultriciessapienleovenenatisdolorapretiumeratmetusnonlacusinhachabitasseplateadictumstmaecenasconguemagnaauguenecsodalesestfeugiataproinsempersodalesplaceratutmalesuadaanteutjustoscelerisquesempernullafacilisidonecacleomaurisintegercursustortoregetvelitlobortisdapibusaliquameuismodfringillaenimacportatelluslacinianonnunciaculisantesitamettortordapibuslobortisultricesleomaximusinconguelacusatodiosemperplaceratdignissimliguladapibuspellentesqueullamcorpernecnuncquismalesuadasedconvallisrutrumporttitormaurisegestasquisligulasitametaliquampraesentegettristiqueanteprointristiquelacusvitaeantetinciduntegetpellentesquesemtinciduntutaestrutrumaccumsanloremidultriceserosduisposuerealiquetpurusidvestibulummaurisaeneanvehiculametusnectristiqueconvalliseroselitcongueanteutimperdietipsumturpisquistortorpellentesqueiddictumfelisinhachabitasseplateadictumstquisquenonrisusodionullamaliquettellusquispuruspharetravolutpatmorbiaccumsandiamlectusutrhoncuslectusdictumacpraesentligulamassacondimentumsitametpretiumidelementumacarcunampulvinarsednislinlacinianullasitametsapiennecligulaefficiturtristiquequissitametmetuspellentesquenisienimelementumacmassasedultricesornarelacusetiamauctortellusquiseratmaximusnecfaucibusnequemaximusnullamtempornuncsedfelisaccumsandictumcurabituruterostellusaliquamegetfacilisislacusacornareminamrutrumliberoinestpulvinarsollicitudinetiamegestaspharetramagnaaliquamvolutpatfelisacondimentumconsequattellusnisllacinialeononinterdumjustolectusegetestintegereuismodlacusidipsumtempornoncondimentumliberosodalesphasellussagittissedexapellentesquevivamusluctusfeugiatmassasitamettinciduntenimphasellusjustosemeleifendaconvallisutfeugiatvellectusduisbibendumnuncacommododictumproineupurusnisiphasellusnonsemperodiosuspendisselectusurnaporttitorsedauctoretdictumetnuncetiamlaoreetmollisantequisportaaeneaneleifenddoloracdictumaliquetrisuslectushendreritnunceurhoncusloremmagnanonmaurisquisqueelementumorcietposuereblanditarcuquamrhoncusestsitameteleifendmassafelisnonurnapraesentquisnequetristiquefinibusdolorneclaoreetmetusdonecconvallisleovitaeodioscelerisqueatpharetraturpisviverrasedidduiidarcufermentumfinibuseueuexcurabituratpretiumelitfuscehendreritmiinurnasollicitudinacrhoncusmaurismattispellentesquecursusturpisligulainfringillanislviverraatincondimentumsitametfelisinluctusetiamtinciduntodioetjustolaciniaetvehiculaelitlobortisphasellusvolutpatfinibusmagnaaporttitornisltinciduntinpellentesqueetorcivelloremefficiturdignissimnecnecmagnaduisatorciidtortorcondimentumpulvinarvitaevelmassapellentesquetinciduntmaurisquamacdignissimsapiencondimentumegetfusceaccumsannislloremegetluctustortoraccumsanegetquisqueultricesegetduivitaeconvallisphasellusconsequatvelitnonloremefficituridporttitorantelaciniavestibulumacnibhatorcirutrumplaceratidetloremnamfinibusullamcorpernibhscelerisqueluctusleoultriciesetdonecidlectusligulaaeneansedegestasnullaintegersedvelittristiqueeuismodmassaidsollicitudinliguladonecurnasapienblanditatloremsitametsempermolestieleosedloremurnaluctusdictumpharetrasitamettemporetmaurisnullainefficiturloremattempusleoutullamcorpertortorexaaccumsanmetusconsequatutnuncnecdolorvelquamfermentuminterdumeuquisenimphaselluspulvinarlacusetmimolestiedapibuscurabiturdolorquammattisacauguenontinciduntultricesarcupraesenttemporsemacmiluctuspellentesqueutluctustincidunttellusarutrumnullamaximusporttitornullaegetdapibusligulautsodalesdiamvivamusdapibusdictumloremsitametscelerisqueestlaoreetvitaevivamusaccumsanrhoncusestnonconguenamlacusnisivulputateegettinciduntimperdietsagittisidorcidoneceleifendlectuseublanditvulputateintegeraccumsanrisuslacusvitaerhoncusjustopretiumvitaeintegervariusnecauguesitametvolutpatphasellusinterdumeratsitametvehiculaconsecteturodioduitinciduntquamvitaeegestasligularisusquisvelitproinfacilisisnullaquissodalesvestibulumcurabitursagittistortorvelmassafermentumsedgravidaquamtinciduntetiampulvinarfelisidtincidunteuismodestarcuviverranuncvitaeviverranibhenimvelorcimaurisportaerosvelhendrerittinciduntduismaximusiderosvitaeblanditetiamporttitornislquamnonconsecteturodiomolestienonmorbivelcondimentumlacussedutipsumnisicrasconguejustoeulaoreetvolutpatfusceeuismodelitaliquamliberoluctusacaccumsanmaurisultricespraesentauguenislfacilisisapulvinarsitametmollissitametquammaecenaselementumeleifendmattisinvitaepharetraturpisintegerinmassatinciduntmaximuselitsedvariusmassacurabituridsodalessemaeneannullanunctinciduntetscelerisqueutimperdietindiamdoneclaoreetnibharcuacullamcorperanteporttitoranuncfacilisisturpissedsollicitudinbibendumduissagittisodioipsumquispharetradolormaximusnecphasellusnonlaoreetmassaetimperdietsapiencurabiturenimdiameuismodeuporttitoregettristiqueuturnafuscefinibusquismassamaximusvehiculasedfringillasodalesrisusullamcorperlaoreetodiotincidunteunullammaximusnisieuportaconsequatligulatortorvolutpatenimquisscelerisquedolorsapienaorcimaurisnibhurnafaucibusnecaccumsannecsagittisegetmetuscurabiturveltortorleointegerenimquamconvallisutorcinecmollispretiumnuncaeneanvelantenibhnampurusarcufinibusettempornonvolutpatvelpurusaliquamvitaenislidsemeleifendbibendumetquismiduisporttitormalesuadaaliquammaecenasvariusinterdumnuncegetcursussuspendissepotentinullamtellusnisiullamcorpersedodioapulvinarlobortisligulaaliquamposuerelectusaexpellentesqueinporttitorjustosodalessednonquaminduiultricesscelerisquenonnectortordoneceupellentesquesapiensagittistemporestcrasscelerisquenisinuncinfringilladuicursuseuaeneanpretiumeuismodnisiuttinciduntproinportavelitegetnisivolutpatviverradonecmileosodalesintristiqueidsollicitudinquisaugueinhachabitasseplateadictumstsedantelectusdictumvitaeexvolutpatfringillarutrumleoutleoauguefacilisistempormagnaquistemporvolutpatnequesuspendisseeumiamaurisfringillaaliquetnecvelurnaphasellustemporpharetramagnautfaucibussemultriciesegetdoneceleifendipsumegeterossemperinefficiturmaurispulvinaraliquambibendumligulaeuvestibulumvolutpatsednuncmassaconvallisvitaecondimentumuteuismodeleifendleophaselluscongueatmagnaconvallislobortisintegerpretiumexetportatinciduntleomaurissodalesmaurissitametblanditnislenimvelquamduisbibendumleoseddapibussollicitudinorcimaurissagittisfelisavariuselitnullaegetmaurisaeneanmassaestconvallisaccommodositametfeugiatidnisinullafacilisiquisqueapurusetmagnagravidaegestasquisidliberomaecenasidvulputaterisusuttempusinipsumsitametvariussedeuismodesteudignissimhendreriteratduiplaceratduinonconsecteturlectustellusaligulaaliquamvelenimleodonecvitaepuruspurusnullamrhoncusrisusidsollicitudinvehiculasedeupharetraligulavestibulumeuvenenatisnuncsedutnullaeuismoddignissimjustoetposuereipsumpellentesqueviverratortornecjustoaliquetinterdumvivamusvulputateattortorsitamettemporaeneanconsequatpretiumrisussitametornareesttemporsitametnullaeratloremsodalesaceroseuluctuslacinialectusmorbitempusliberoactellusconguehendreritnuncodioestmolliseurisusaultricieslaoreetorcicraslacusmaurisvehiculaegettortoretfinibusaliquammaurisfuscepretiuminfelisacornarenuncsemvelitmattisetodioaefficiturdictumsemaeneandapibuspulvinarmassaeupretiumphasellusimperdieteuliberoquisullamcorpernuncidmisuscipitvariusnequeinelementumduiproinsempererosutpulvinarultriciestelluslacusconguenibharhoncusliberolectussitameterosutnecblanditlacusnullafacilisiintegernecplaceratorcimaecenassapiendiampellentesquesitametultricesvitaefringilladictumsemnullarhoncusblanditbibendumproinquamtortorpellentesqueinvestibulumetimperdietacestsednecnislpurusfusceurnaauguesuscipitsedfinibusvelfermentumetexcrasullamcorpersapienneclacusvulputateinterduminhachabitasseplateadictumstaliquameratvolutpatsedhendreritfelisatrisussempervulputatenullaplacerategetquamnonvariusintegerinvenenatispurusveltristiqueleointempusexsedliberomattisveltempusmetusvulputateetiamimperdietauguevitaetinciduntvariusphasellussitametelitbibendumdapibusantevelefficiturtortornullatempusduiasollicitudinsollicitudinaugueurnahendreritdolorpharetratincidunttellusturpisvelliberoduisquisvelitatelitsodalesbibendumsedvelliberophaselluseueleifendnisisedconsequatquisfelisidegestaspellentesqueliberomaurisullamcorpervitaeporttitorquispharetraeuipsumfusceatviverralacusmaurislobortiselitvelurnapulvinarlaciniaquisquelaoreetmagnasitametnullaluctusaconsequatnullaviverrasedgravidasitametorciatpharetraduisvitaemassaconguenuncdapibusfacilisisnullafacilisiaeneanegetblanditestpellentesquesapientortortemporsedfaucibusnecpharetraattortorpellentesqueultricespellentesquemolestiepellentesqueelementumnibhidpulvinarcommodoetiameufringillanuncegetsemperpurusvestibulumfaucibusplaceratantenecullamcorperpurusultricieseufuscequiscommodoeratidtempusmassaaeneannonliberoegetmaurisvenenatisfinibusdoneccommodoeueratidmattispraesentvolutpatpurusnuncclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosdonecportanequeetiaculismaximusturpiserataliquammaurisquisposueremilectusvitaeligulasuspendissemalesuadaduiinmagnafacilisisrhoncuseuseddolorduisconsequatliberoatconsequatsemperutantediampretiumaenimnonullamcorpersodalesauguedonecegetvolutpatquamnullasollicitudinmetusvitaemagnaelementumrutrumauctoripsumaliquamnamaliquetelementumlobortismaurispellentesquesapienaodioaliquamultriciesaliquamsedturpispellentesquelectussollicitudinaliquamvelsedsemquisqueinsodalessapienmaurisestorcitinciduntnontellusfaucibusfaucibusvariusturpisnunclaciniarisusetliberovehiculahendreritmaurisinpellentesqueurnasedlobortisnunccrastinciduntvariuseliteuvestibulumsapienblanditegetpellentesquetinciduntelitsapienatfaucibussapienlobortisutdonecrhoncuspurusutvulputatelaoreetnibherosbibendumleoavolutpateratfelissedlectuspellentesqueegetsapienmicrasatmaurissitametestpharetraporttitorproinpellentesquesollicitudintortornecsollicitudinmaurisaccumsansagittismattisaeneancommodosuscipitauctorutvelrisussagittisefficiturnuncamaximusnisivestibulumegetexsollicitudinelementumelitegetaliquetorcisedaodionecsemtemporvulputateamattisnislmaecenasodiofelisconvallisegetdoloreuscelerisquemaximuslectusaliquamconvallisenimnecanterutrumatvolutpatestfaucibusdonecvitaeleofinibusefficiturrisusetconvallisestutateleifenderatacconsequatexnullametliberouteniminterdumlaciniavitaeatnunccurabiturutgravidatellusacommodotortoraliquamaccumsansemsitametvulputatebibendumodioexluctusenimutlaoreetarcujustoacelitintegerornareanteligulasitametelementumenimcursusetaeneanimperdietmolestieenimutelementumnullapellentesquesollicitudinligulautdapibuscrasultriciesrhoncusanteablanditpurusvehiculafermentumcurabiturvelsapienquisloremgravidaultricesinidarcuintegervestibulumminonmetusrhoncusauctorloremipsumdolorsitametconsecteturadipiscingelitmaecenasetaccumsanligulaaliquamdignissimauctordiamvitaesagittisenimtemporornarecurabiturvitaeelitutlectusegestasaliquetmorbiinterdumnislaaliquammattismorbisitametconguerisusnullavenenatisultricesturpisquistinciduntcurabituregetvestibulummassanullamiddolormattiselementummaurisvelaliquamnullaproinmattisturpisinnislscelerisqueeurutrumipsumultricesmaurissodalesviverrasemegetfinibuscrasluctusetnequeetcondimentumsuspendisseleoerattinciduntsedvenenatisvitaegravidaacpuruscrascommodotempormetusetpharetraorcieuismodvitaealiquammaximusposuerequamutfermentumvestibulumaliquamlectusinposuerefringillasedaccumsanorcifelisnecmollisdolorluctussitametnuncerosipsumeleifendutlectusatfacilisisvulputatelacusnunceuultriciestellusvestibulumscelerisquevulputateanteidefficiturmiblanditfacilisisaliquamsodalesmetusutnequesempervestibulummolestieeratvenenatisfuscevitaeodiodolornullamconsecteturtincidunteleifendsedeumaurisrutrumornareurnaatiaculisleonuncinterdumporttitorquamaelementumproinquisduiplaceratvulputatedoloracauctorestvivamusfermentumfacilisisliberouttinciduntsedsedlaciniatellussednecnislsitametpurusposueresemperduisidduilectusaeneanportasodalesquamegettempussedidmagnaacjustoplaceratlaciniasuspendisseatvenenatisjustoproinvitaeipsumgravidatortorauctordictumutetpurusrhoncusauctorloremquisauctornullanullamhendreritportaexsitametdapibusjustocondimentumetphaselluscondimentumaccumsanexnecsodalesdiamvariusatvestibulumelementumgravidaturpissagittisfringillaintegervitaepurusmaurissedinrhoncusenimpellentesqueamaximuslacussuspendisserhoncusestestutconsequatnisibibendumaquisqueaccumsanidleoornareconvallisdoneceuiaculisorciinlaciniamidonecatinciduntauguemaurismaximusfermentummieucommodosapienfringillablanditnamfeugiatmivelgravidatinciduntvivamusposuereblandittortorquisegestasmagnaconsectetursedaliquamnecipsumacpurustempuscursusfinibusutodioututturpisvelrisusmattisrutrumconsecteturacmetusmaurisetpellentesquetellussitametconvallismetussedidtemportellusduisconguenequearcueucommodovelittinciduntatcrasnonelitquisnullalacinialaoreetinetpurusdonecidsapienquamnullarhoncussematrisustristiqueinpretiumvelitlaoreetmaurisvitaequamidipsumeuismodaliquetsedconsecteturantequiselementumpulvinarmaurisnisiconsequatsapiengravidaultriciesjustodiamidturpisfuscenecfermentumeratsednecfacilisisexetiaminmagnaleoaliquamdictumnislsedlaoreetaliquetdonectempusvitaelectusquisimperdietnunceuismodtortormassaegetdignissimauguemaximusacmorbisitametloremturpisinmaximusfringillaorciseddictumdiamullamcorpersemperinmollismalesuadadiamatmollisvivamusornarenullaenimquistemporliguladapibuslaoreetaeneanblanditnislatligulafeugiatfermentumcrasgravidarutrumnullanecullamcorperduisgravidanislfelisasuscipitnislblanditaquisquevariusullamcorpervelitidtemporipsumeuismodnecsuspendissevitaecondimentumturpisnuncvitaesemperrisusnuncsemjustointerduminestatvestibulumtinciduntestsedegetlectusnonmassalaoreetpulvinarorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusaliquamdolordolorblanditegetportaquisportanonnislquisquemollisfaucibusorciinmalesuadaenimtinciduntvelnullaaugueleotristiquesitametpulvinarsedornaresedtellusquisqueacpuruslacusnuncpretiummalesuadapretiumdonecfinibustellusnecarcuvulputateutvestibulumnuncvulputateinhachabitasseplateadictumstcurabiturviverracondimentumpulvinarnamvehiculanuncsedtincidunttemporfelisextinciduntnequeacmalesuadanibheroseumagnanullamaciaculisdiamquisquedignissimorciquisorcivolutpatatultriciesleomalesuadanamfaucibusrisusettinciduntsollicitudinmorbipellentesqueodiovitaedignissimconsequatmorbimollisloreminlectusiaculispharetracraslaoreetaliqueteleifendvestibulumetliberosodalescongueantevelvariussempraesentaliquetfacilisisenimutluctusmaurisvulputatetinciduntnibhegetultricesurnalobortisnonnullacongueeuvelitegetportamaecenasaliquamurnaatvariuspretiumaeneancommododiamidvariusefficiturduimagnacongueleoiddignissimestligulainleonuncexmagnatristiquenontinciduntvelplaceratatortorvestibulumloremquamfinibusaliberoutportaultriciesurnaprointinciduntlacusduinecimperdieterosornarenonproinvitaeelitpurusaliquaminultriceserospretiumdictumurnasedeuloremloremcurabiturposuereantevelelementumtristiquetellusipsumpharetramassalaoreetfeugiatnequefelisnonsapiensedtristiquediamatsempretiumacdictumenimvariusmaecenasquiseleifendquamloremipsumdolorsitametconsecteturadipiscingelitpraesentsitametcommodonuncetiaminorcianuncullamcorperlaoreetsuscipitanulladuissednislrisussuspendisseultriciesmollisvelitnecpellentesquesuspendisseornaresedtortorsedfacilisisaeneansitametmetuseuismodjustotinciduntpretiumphasellusconsequatultricieselitetlaciniaetiamfringillaturpissitametmetusaliquetcommodoaeneansagittisnibhapretiumvariusnuncmaurismollisloremetrhoncusvelitnullaateratsedidpharetraerosacpretiumenimnamnonaccumsannibhquisqueconsecteturtemporipsumnonmattissembibendumegetaeneangravidainlacusimperdietfeugiatnullamitortormolestieetpretiumelementumbibendumtinciduntquamintegersitametmiutnullasollicitudinbibendumutquisvelitsedetfaucibusleotemporauctorlectusnamnonloremanteduiseujustosodalesnibhinterdumaliquammorbivariusultricesaliquamnullamcommodoloremutsemperscelerisquevivamusatnibhegestaslectusaliquambibendumsuspendissesitametvelitpulvinarmollisturpisidplaceratnibhdonecatmalesuadaarcuvestibulumaccumsanquamvitaelaoreetaliquetmaecenassemperornarebibendumpellentesqueidluctusaugueacgravidadiamcurabiturutnuncnecmetustristiquepellentesquequisnecligulasedfacilisisrisusegetmollisfermentumnunctellusplaceratturpissedconsecteturnibhnisiutquamsuspendisseluctusconsecteturexsitametscelerisqueetiaminexacorciimperdietrhoncusintegersitametipsumnecduimollisauctorinincommodoanteetiamsuscipitdapibustinciduntvivamusutcondimentumsemsitametviverraestmaurissollicitudinarcurisusinfeugiatnequeegestasnecquisquevehiculaorciajustotempussitamettinciduntduiplaceratutfringillasollicitudinurnaetconsecteturrisuslaoreetnecetiamidpharetraipsumnullamvenenatisestdiamvitaevestibulumipsumultricessedaeneancommodoipsumblanditmetuspulvinarataliqueturnasuscipitpellentesqueluctusdapibussemeleifendultricieslectussodalesacnullamtinciduntnisinibhinblanditduipharetrasitametpellentesquevehiculaelituteleifendlobortisjustoipsumfringillatellusimperdietmattismagnapurusvitaelacusnamfaucibusdiamacsagittislaoreetodioligulagravidanuncsedvolutpatsemturpisquissapiensedimperdietmassanecportacondimentumaliquameratvolutpatnuncinodioatortorinterdumdictumaliquamvitaeleononquamfaucibusvolutpatvelutantenullammaximusdiamsedmimalesuadacongueinterdumetmalesuadafamesacanteipsumprimisinfaucibusproinluctusmaurisnecconsecteturfeugiatvelitfelissollicitudinquamsedcondimentumodiolacusinenimututleoamimaximussollicitudinindolorurnatinciduntvitaecommodoutdictumegetelitphaselluspulvinarjustoquisloremfermentumultricesclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosnullamolestiemalesuadamaurisnaminpurusnislquisqueurnanibhtinciduntquisnibhvitaeultricesauctoripsumpraesentporttitoranequeatgravidaaeneannequerisusmolestieegetconsequatutluctusatsapienutauctormassaeteuismodsollicitudinipsummassadapibusipsumquisplacerateratestsitametantecrasnonluctuspurusvivamussedmiacdolorscelerisquesemperineuodiopellentesquequisnequevelipsumblanditfinibusutinporttitorloremsedlaciniaduisedsodalessedmagnanoncursusdonecnonmetusdapibusiaculisodiositamethendreritnisifusceportanullanonegestaseuismodcurabiturmollisliberolobortissuscipittemportellustortoreleifendanteapharetraquameratfringillaquamnamacmiidligulacommodomolestiealiquamtempussemvitaearcuelementumlaoreetsuspendisseelitturpiscursusvelfermentumimperdietlaciniavitaeleoinaorcisedduiposuerefeugiatatnonminammaximusmattisnisiatcongueauguealiquamiddonecquisrisusatestluctushendreritaeneaninquamcondimentumvehiculaodiononpretiumlacusvivamusultricieslaciniavestibulumutvelitpurusvenenatisapharetravelauctornecelitphasellusconsequatmalesuadaligulainiaculisanteaeneanquistempusipsumsitametmolestielacusduisgravidaduiblanditfinibusinterdumturpisnullaimperdietenimnecsagittisantemassainestfusceultricesenimsedleoornareconsecteturnullamporttitornullavelduiviverrasitametaliquamnibhportadonecipsumenimtinciduntatsapieneugravidafermentumquamdonecvehiculaturpisvelaliquamfeugiatmetusvelitluctussemetdictumrisuserosquisnullaintempuslacusestquisfringillaligulalaoreeteualiquamrisusnequemalesuadaetportaattinciduntsitametenimsedfaucibusnullaeutemporposuereexduiblanditnibhutmaximusenimturpispretiumlectusinettinciduntnisiaelementumtellusdonecidaliquamrisusmorbiidurnaaipsumimperdietelementumatetmetusvivamusnecleomaurissuspendisseodiolacusconvallisnonauctoratmalesuadaamassautauctorultricesaliquetdonecfaucibussitametnullaacmaximusmorbicondimentumeniminsollicitudininterdumpellentesqueegetligulaidestcommodoeuismodnullamlectusleoscelerisquerhoncustempusaplaceratutnislaliquamullamcorperpulvinarmaurisvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraefuscevariusinestactristiquecrasluctusanibhinfaucibuscurabiturefficiturmollisipsumaceleifendrisusfusceiaculisaliquamdiamiaculisblanditfusceliberolectusaliquetutfaucibusidconsequatineratsuspendisseeufeugiatestaeneansedelitinmassadapibusconsecteturpellentesquefaucibusviverrajustoutultricesloremcommodoneccurabitursedvolutpatliberoorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusmaecenasvolutpattempusarcuaceleifendestscelerisquenecsedalacusnibhquisqueultricesipsumdiamsedsempertortoregestasidinposuereloremsedliberoeleifendacmaximuslacustempusproinvelaliquetnisletiamvulputatenisilectusegetlaciniaquamblanditidutsollicitudinmaurisquisrisuslaoreetaliquamquisquepretiumduiquisenimfinibusuteleifendantetinciduntnullamduiodiotristiqueiaculisanteetplaceratfinibustellussedleoestfermentumeuaccumsaneucursusutestetiamdictumelitesteusollicitudindolorbibendumeualiquamconsequatmagnaetjustoegestasacaliquamlectusvolutpatutnecaliquamloremproinvolutpatenimtortoraccommodoanteconguesitametsuspendissevestibulumnibhsedsemtristiquemaximuscurabiturinurnaidmagnaviverrasemperidsednequecrastinciduntmassaquisporttitorlaoreetenimmetusmolestiepurusetpharetranisifeliseuexvestibulumporttitorsempereratatlaciniapurusvehiculaetphasellusmolestieeratnectinciduntdignissiminvariusestacelementumsuscipitaugueleovestibulumturpisinconsequatvelitlectusacquamduisquisvariusorcinuncvulputatenuncaugueegetmattismassafaucibusdignissimdonecatnullaatestultriciesfermentumaliquamgravidaerosutefficiturconguesednequetortorconsequatidegestasquisultricesapurusdoneciddolorquiselitvenenatisrhoncusnecvitaeeratdonecquisdolorcondimentumcondimentumvelitvelpulvinararcupraesentutaccumsantellusfuscedictumpretiumenimsitametmaximuspuruspulvinarnonsedantenullainterdumeumaurisintinciduntcursusmassamauriscondimentumfelisidvariusvariussedvenenatiselitullamcorpersemperfacilisiscurabiturgravidaeratquisegestasvehiculanullaloremaliquetipsumsedeuismodauguenislideratmaurisutodioeratintegerpretiumsemquameuportafelistempusiduttinciduntsapienacultricesfaucibusmilacusvestibulumnullasitametvolutpatmassaantesedrisusnullatemporporttitorexacsagittiscrasnonbibendumlectusvivamusegetfinibusloremnullamornaretinciduntvelitatsempercrasimperdietipsumtinciduntauctorantesedultricieslectuscrasmattistinciduntodioeugravidaeratnuncvariusnisiidposuereaccumsantortorauguedapibuslacusetfinibussemexutnisimorbianuncexfuscenequeelitmattisaceratbibendumscelerisqueullamcorpermimauriseuismodeleifendinterdumaeneannecnullaefficiturhendreritfelisquisposuerelacusetiamimperdietaugueegestassollicitudinmolliscurabiturblanditestidvestibulummollisetiamegetnullaaenimlobortislobortismorbisodalesquislectussitametauctorcurabitureleifendvestibulumpharetrasuspendisseconvallissedtellussedblanditquisquevitaenullavelarcuullamcorperfinibusnullavehiculametusinimperdietfinibustortorarcufringillamagnaquismattisrisusmagnaveldiamcrasfaucibusdapibusantenonblanditpurussempernecorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusintegerestfelisultriciesquismiacfeugiatgravidamagnautportaelitestideuismodmagnamalesuadaidnamnonduileointegeraligulaanibhconsequatcursusnullafacilisissempermaurisvelconsectetursedauguetellusluctusporttitormetusetsodalesauctorjustosedeuismodvariusnisleuplaceratmassalobortisataeneanfermentumconsecteturquamiddapibusnibhinterdumvitaeaeneanutduimollislobortisnisinondictumodiosedmattisantevitaedictumgravidainpulvinarconsecteturegestassedetpulvinarmiaeneanidorcileointegerconsecteturdolorquisliberopellentesqueintristiquemassaelementumsedaduipellentesquemolestiemagnadapibusconsequatdiametiammattisviverrafelisnuncidurnavestibulumrutrumexiaculisconsequatrisusetiamidrhoncuslectusfusceefficiturconsequaturnasitametsollicitudinvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraevestibulumpellentesqueturpistemporcondimentumaugueidgravidavelitaeneanpulvinarnullarutrumelementumtristiquenislduipellentesquenislamaximusaugueaugueutmassamorbicursusenimanteinportanuncfermentumututegetturpisegetligulaconvallismolestiesedpharetraliberodonecaliquetdiamutnibhaccumsanetfaucibusmetuseleifendnullaplaceratconvallisfelisdictumeuismodproinhendreritrisusquisloremlaciniaacbibendumsapienpellentesquecrasquisantetellusphasellusvolutpategestasmalesuadavivamusmetusrisusblanditiaculissagittisatposuerenonmagnacrasconvalliserategetrutrumaliquammaecenasnectortorseminhachabitasseplateadictumstetiamvestibulumurnainmetuscongueporttitorutsedhendreritarcuvestibulumegetpretiumurnaphasellusdictumdiamestinportaorciscelerisquenecphasellussitametlobortisquamaliquamegetfaucibusmiegetullamcorperrisusmaecenasegestaspurusquisauguesempernonimperdietligulaultricesnullafacilisiduisaugueestpulvinarnecliberoquiseuismodpharetraurnafuscecommododolorvitaevulputatefeugiatduinibhluctusodioutcursusleoerosquisnequedonecexodioegestaspharetrasapienquisposuerefringillaodioetiamegetanteblanditgravidalorematdictumsemvestibulumestnisliaculissedlaciniaquismalesuadanonrisusmorbibibendumenimvelitatmalesuadadolorporttitorsitametsuspendisselectusurnaaliquamimperdietfelisetvulputateeleifendmipellentesquedolortellusaliquetinvestibulumsitametpharetraquismetusvivamusposuerearcuegeteximperdietpharetranunceumassavenenatisluctuseliteulaoreetodioaliquamutdolorvelitfuscesapiendolorullamcorperidauguenonplaceratlobortisduidonecplaceratlacusatsagittisauctorpellentesqueidfinibuslacusintegeregetnequevelnislpharetrascelerisqueaatortorsedvolutpatelitavelitvariussollicitudinsedvitaemaurisidsemvenenatissagittisfusceegettelluslobortisrhoncusanteutornareorcinullaelementumquameuaccumsanrhoncusinterdumetmalesuadafamesacanteipsumprimisinfaucibusaliquammaximusmalesuadavulputatenamnecsuscipitloremnuncvestibulumorciacexfacilisisconsequatinsodalesvehiculaexquisconvallismaurisrutrumeuvestibulumpulvinarduisitameteratullamcorpereuvariusfelisdapibusvestibulumquisvelittellusfusceeulectusimperdietvenenatisnullaatscelerisquequamaeneanegetligulasitametleovolutpategestasetconvallisduidonecettristiqueexnecfeugiatnullaaliquammolestieconsequatexnonpellentesquenequefringillaetsedeuismodauctorturpisacconsequatestnamvenenatisloremsedsagittisfacilisissemodiovenenatisarcuegetfacilisisnislloremnecsapiendonecvitaetortorvitaeurnaimperdietsodalesetsitametmagnavestibulumvenenatisdoloraaliquetsemperelitquamconsequatloremacmalesuadaelitfelisutduicraselementumeuismodnibhegetlaciniametustinciduntidquisqueegetfermentumpurusvivamusmalesuadalacusidsagittisplaceratnisimauriselementumorcivitaeluctusquamquamatnibhvivamusaliberolacuscurabiturvelligulavariusporttitornibhrutrumconsequatmaurisfusceutsemorcivivamusimperdietefficiturliberogravidafermentumexproininerosdictumlobortisnuncvitaeblanditlectuscurabiturvulputateetmagnautconguecurabiturtincidunttristiquenequepellentesquerhoncusnequerutrumatvivamusmidolorhendreritinmolestievariuslobortissitametnisicrasvelurnaaodiohendreritvulputatequisquemolestieiaculisnislinultricesantemattisquisnullafacilisifuscequisantesitameterostinciduntvolutpatintegernibhtortormalesuadaeuurnaetvenenatispellentesquetellusvivamuserosenimtempusegetrutrumvelegestasacsemnullamlectusdiamviverraegetpurusquiselementummattistellusnullamsitamettortornecnibhinterdumscelerisquesitametetleopellentesquesednequenuncaliquameratvolutpatfuscesollicitudinloremsitametvenenatissollicitudinantevelitefficiturfelisseddictummassamassaiaculislectusnunccursuspulvinarvolutpatmaecenasjustoenimvestibulumuthendreritvolutpatgravidasitametelitmorbietjustoenimnullamaccumsanacleoidvulputatesedegetturpisattortoreuismodbibendumaliquamsuscipitvelenimeufermentumdonecinnislinmagnasagittisblanditinvolutpatexacconsequatmalesuadaquamduiluctusvelitvitaeconvallisarculigulavelorcivivamusatpharetratortorintegervitaeestseddiamiaculisrhoncusatquismassanullasitametplaceratodiocurabituripsumligulaefficiturnonvestibulumeufringillaeumagnaintegeregestasfeugiatpellentesquedonecmaurisurnascelerisqueegetnisieuinterdumfeugiatdiametiamblanditmalesuadaexveldictumaliquamexdiamimperdietacnibhquisaccumsaniaculisorciquisquesedtristiquenisicurabiturdictumodioodioacrhoncusnullasollicitudinvelcrasvelsemvariusfringilladolorsitametfringillamagnanullamtristiqueeteratvitaeiaculisfuscevitaeiaculismisedfacilisisligulacurabiturdapibustortorsedcursusviverracrastemporullamcorpermetusornarecommodopraesentmolestieodioegetfaucibusfacilisismaecenasconsecteturtellussedleoultriciesefficiturphasellusvolutpatcondimentumelitcrasfeugiatconvallisporttitorpraesentduielitpulvinarportafringillasitametullamcorperatseminterdumetmalesuadafamesacanteipsumprimisinfaucibusduisfringillanonrisusneceleifendaliquamadignissimantedoneclorempuruscondimentumquisscelerisquesedhendreritvelurnadonectinciduntlaciniamassasitametpretiumphaselluslectusenimcongueetmolestiesitametgravidanecodioaeneanegestaseratipsumvelfinibuslacusmalesuadainmorbivenenatisodioliberointerdumetmalesuadafamesacanteipsumprimisinfaucibussedultricessemvelvolutpatelementumduiipsumbibendumnuncegetdictummifelisetenimsedlaoreetarcusitameterossuscipitullamcorperpretiumliberoposuereduisbibendumutnibhquisposuerequisquequiseratutmaurisdapibussagittisphasellusmalesuadaconsequatmetusinpellentesquenamacmialiberoultricesfacilisismorbipellentesquemollislaciniacrasporttitorporttitorsapienatultriciesproinutlectusegetrisusdictumfringilladuismalesuadametusquisporttitordictumnullaerosblanditmagnanonaliquetantelorematellussedullamcorperduimetusatmolestietellustinciduntultriciescrasmalesuadafringillaornarefuscequiscursusliberonullalaciniafringillafacilisismaurisneclectusnecipsumpellentesquedignissimcurabituregestasaliquetjustoquisvestibulumturpispretiumvelfusceefficiturfelisvelodioporttitoregetdictumorcicommodoproininrisusorcivivamusfermentumpretiumminonplaceratmaurisacultricesligulamorbitincidunttemporleocursusfinibusleocommodoeuquisquequispurusbibendumcursussemacporttitormetuscrasinsagittisipsumaliquaminviverrametusdonecsitametsuscipitelitclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosproinnonsapienvariuscondimentumexinfermentumturpisproinfinibuspretiumdignissimetiamlaoreetaliquamdiamvelfeugiatsuspendisseconvallisrutrumegestasnuncdapibuspurusvenenatisnislfacilisiselementumnullamfeugiatquamvelvolutpatluctusproindignissimipsumduiagravidatortormattisvelmaecenascondimentumscelerisqueorciaviverrautfeugiatorcimialiquammolestieipsummolestieatsedatlobortisfelisacportalectusaeneancommodoviverraurnanecfringillanuncsitametmassablanditpretiumarcusagittiscursusloremetiamaurnaalacuspulvinardictumcrassagittisornareexetmattisnunceleifendlacusetmalesuadasuscipitfuscefaucibusmetuseumagnaplaceratinviverraarcucursusvivamusegetmagnaapurusegestaspharetrasedlobortisestpurussedrhoncusorciscelerisqueatintegeretexnisinamhendreritcommodotristiquecurabiturfringillaantenonleoluctuslaciniaaliquamtinciduntleoidlaoreetpulvinarnequelacustristiquemaurisetvulputateorcijustovelexnullafacilisivestibulumpretiumpurusmagnasitametlacinialigulavolutpatsitametaeneaniaculisluctusdictummaecenassapienelitullamcorperdictumultricesnonrhoncusutmiaeneanelementumnibhquisfermentumullamcorperminullafinibusliberomaximusinterdumlacusvelitsedjustoproinmassamagnaullamcorperquisestsitametvariusmaximusmassavestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraeintegervelaliquetfeliscrasegetfeugiatenimetiamidscelerisqueleoproinsapienlacusaliquamegetgravidainsemperegetpurusutrisuspurusvolutpatinenimconsecteturbibendumfeugiattellusphasellussedjustovelauguefacilisistristiquenullaultriciesgravidaaliquetpraesentdictumdignissimnisialiquamidarcuvelmassaelementumtemporpellentesqueestdolormolestiesitametcongueullamcorperbibendumegetmaurisnamegetinterdumurnaelementumefficiturduisuspendissenonelitneclectusfacilisisconsequatduislobortisacdoloreuviverracurabiturcursusconvallispellentesquesedsapiennullaaliquamvitaelaciniaegetauctorvelliberomaurisnecurnadictumgravidamassaaeuismoddiamquisquemollisaccumsanbibendumvivamussedquamnislvivamusconsecteturnislegetarcuegestassuscipitfuscesagittisauctorduivestibulumeulobortisjustosedfinibusduinuncnecdoloramagnapulvinareuismodpellentesqueeuantenonnisigravidaultriciessitametvitaemisuspendissepotentifuscebibendumaccumsanfacilisispraesentegetcursusquamaeneanmollisbibendumfermentumutmolestieeratsedbibendumfringillasednontortorconguerhoncusduivelporttitorerosproinegetmolestiemetussuspendisseurnaenimimperdietsedodionecsagittistristiqueleophasellusnonvelitmollistinciduntnequeegettempornibhcrassagittisjustoeucommodosollicitudincurabiturposuereenimaarcusagittiselementumimperdietpuruscommododuisdapibuselitdiamvariuseleifendsemfaucibuseualiquamatnullalacussuspendissevestibulumtellusatconsecteturvolutpatodiotortorconsequattortoratplacerateratlacusvellectusinsuscipiterosegetinterdumaliquammaecenasmattisduiactemporelementumturpisurnablanditligulaegetornareloremnullaatleonamvariusquamquisiaculisdapibusproincommodovariusipsumidlaoreetnullammattisenimaliquamcommodointerdumlacusodioaccumsanelitidultricesmaurismaurisindolorintegerportatellusidvulputatelaoreetsedeuismodauguefelisvestibulumarcuorcielementumnecfaucibusnonvehiculanecvelitnuncefficitursempermiidconguenamfermentummollispharetraetiamdictumnislvitaenislporttitortristiquealiquaminelitfeugiattempusdolorvitaemaximusligulaaliquamaccumsaneuloremnecelementuminterdumetmalesuadafamesacanteipsumprimisinfaucibussuspendissedapibusturpisacnislrutrumethendreritnequelaoreetnamsitametrisustinciduntexposueredictumeuegetnequephaselluslaciniaegetnisivelpulvinarcurabitursedduiinenimimperdietullamcorperaliquamatdiamodiodoneceuismodantesitametorcipharetranonscelerisquenislfeugiatorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusphasellusfermentumauctoranteatrutrumvivamusmollisvariusquametlaoreetetiamvelarcuamagnaaccumsantempusutsitametmetuspraesentvelmetusetrisusdictumiaculisaceuerossedaliquamdolormolestieleoeuismodconsecteturnullaullamcorpermagnavitaeporttitorfacilisiscrasaduiinorcieleifendtinciduntpellentesqueplaceratinaugueidconsequatmorbiviverraodioegeterosornareegetscelerisquemassaportanamidsagittisdiamvivamusexnisifaucibusdignissimtemporacinterdumeuurnanullasagittisinleoabibendumaeneannislantefaucibusidarcuvitaeefficitursagittisarcuutetorciegetmaurisrhoncusposuereduisloremmaurishendreritutvehiculaamalesuadaasemmaecenassedvenenatisliberovitaeornarenibhvestibulumegetauguedignissimvestibulumexquisiaculismaurisphasellusvolutpatestinelementumtincidunteratdolorlaoreetnuncegetsuscipitlacuseratvelmaurisinultriciesmolestieduieueleifendfuscetristiquemaurisetvelitfacilisisetelementumnisifermentumproinatpharetratortorvestibulumsemperliberoeufermentumfringillaorciodiomaximusnisiquisdignissimestleofacilisisfelisnuncquiseleifendestdonecnullaorcisollicitudinetsemsedfermentumgravidavelitaeneansedaugueeunislultriciesauctorvelegetmetuspraesentsempervelitsitametrisussodalesegestasutidmassavestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraenullafacilisiorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmuspraesentsedaccumsanrisusnullamvelnequeidlectusiaculisullamcorpermaecenasadignissimsapiensedconsequatrisusquisquenecexsodalestortorscelerisqueinterdumeuactellusduisaliquamtellusinporttitormaximusjustonunctinciduntexeulobortissapienexinmetusnuncsodalesexetliberobibendumvitaemollisorcicursusphasellusdapibustellusnoninterdummaximusleoexvenenatisipsumidsodalesenimmassaetlacusdoneciaculisfaucibustellusaccumsanportadiamposuereatvivamusvitaelectusinorcisollicitudiniaculispellentesquehabitantmorbitristiquesenectusetnetusetmalesuadafamesacturpisegestasnullamquisloremegettellusporttitorsagittisveleuleonunclaoreetlectusalaoreetfermentumnullamnecfacilisismetusnullabibendumnunciddignissimhendreritpraesentelementumetrisusnecrutrumpellentesquemattislaciniaorcisedtristiquelacusdonecvelmaurismaximushendreriterosidultriceserosfuscequismimollismolestiemaurisatmattisorciduisacsagittisleosedfermentumeuismodportanullamolliselittellusvestibulumarcuexauctorinplaceratsitametfinibussitametnuncetiametsagittistortorinaliquetantepraesentvenenatisvelitavelitrhoncustristiquesedmaximusrhoncusnuncvivamussedminonestvulputateaccumsanpraesentjustoenimelementumegetelitetvestibulumfinibusaugueutetloremnonestmattisluctusidsitametexnamfaucibussedauguesedimperdietnullameuestporttitorvelitdictumornarenuncsapienaugueconvallisidorciegetpretiumrutrumsapieninutfelisutloremluctusultricesutmalesuadavelenimacaliquetinconsecteturtortortemporauguedapibustinciduntquisqueacquamtelluspellentesquelaoreetlobortisdiaminterdumauctormagnacursussitametsuspendisseipsumarcucursusegetvariusablanditnectellusnamiaculispulvinarvehiculanuncfeugiatnullasitametfinibusrhoncusnislaugueiaculisturpisegetcondimentumarcuvelitcongueestinsemperestidaugueullamcorpercondimentumutsempermetusidmicondimentumultricespraesentsitametmattisnisiproinvenenatiserosnecurnamalesuadaaliquamsedegetaugueuteleifendfacilisismagnainsemperestdonecplaceratconguemassainrutrumnullamsuscipitturpisnecdiamsemperquiseleifendnibhsollicitudinquisqueeleifenderosutaliquamsodalesmauriserosmalesuadaleoidhendreritmielitnecsemnametmolestieipsumutmollismassaduisconsectetureratidnisimattisinelementumloremfacilisissedmolestieduinonnibhlobortislobortisfuscefermentumlaoreetcondimentumnullamtemporpharetraaliquamorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusquisqueviverraexinmagnaiaculisinsagittisliberoconsecteturnullafacilisimaurisetfelisinsapienvolutpatvulputateaetquamnullaeuplaceratlectuspellentesquesedmetusetliberoportaviverrasedposuereegetturpissedhendreritnullamaliberonibhcurabiturarcufelisvehiculasedmattisegetultricessitametminamegetmassavelnibhvulputatesemperetiamatultriceselitvestibulumefficiturdignissimipsumquisfermentumarcucursussitametetiamluctuserostinciduntblanditaliquetvelitmaurishendreritdiamutcommododolorlectusintortoretiamsedestgravidaeleifenderatattinciduntarcucurabituruteleifendarcualiquamtinciduntmetuseusollicitudinrutrumaeneanegetipsumantepellentesquemattismassaquislaoreetvolutpatliberofelisportaduiegetplaceratmieratnonmetusnamegetultricesauguepellentesquesitametarcuduicrascursusfinibussagittisaliquamsitametodioegetmaurisornarepellentesqueetquisvelitnametgravidalacussedposuerefelisquismiscelerisquefinibusloremipsumdolorsitametconsecteturadipiscingelitsuspendisseaplaceratturpisaeneanvenenatismetusacsodalespulvinarauguedolorlaoreetsapieneucondimentumleosapienidfelisdonectortorligulaimperdietvehiculanibhquisviverrapretiumauguenullamapurusquisnuncvolutpatfinibusaquisdolornullamnoneleifendodiosedegestasodioinfinibusnullaeusapienaliquetrutrumcurabiturtristiquefermentumanteeuluctuspellentesquevelligulavelexsollicitudinultriciesvivamusrutrumblanditeratvelultriciesloremfaucibusfaucibusdonecconguemaurisvelvenenatiselementumvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraemaecenasfaucibusquamquisconvalliseuismoddonecmassaarcumaximusetarcunontempusfeugiatsapienduisvelfinibusturpispraesentvulputatemaurisdiamnonultriciesvelittinciduntegetpraesentsollicitudinmaurisorciegetcursusmagnalaciniaegetsedinporttitordiamduisnonnequepretiumbibendumligulanonconvallisturpisfusceporttitorultriciesultriciescrassitametduiloremquisqueutmassaligulanullamcommodoacestsitametullamcorpersedmaximusrhoncusrhoncusphasellusegetquamidloremfermentumconsequataegetelitvivamusanuncleoutfaucibusiaculisnibhatempornullavariusveliterattinciduntporttitormetuspharetrasedmorbivulputatetortoridmauriscommodolobortissitametasapienquisquepharetravestibulumturpisvitaeportaquamviverravelorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmuspellentesqueattellusvenenatisvenenatisenimquistemporurnadoneceratipsumblanditvelmetussitametelementumgravidapurusutsapienliberoeleifendvitaenibheuhendreritconguedoloringravidablanditfringillanampellentesquerutrumipsumnonaliquamipsumiaculisavestibulumestmagnatemporvitaeaugueacaliquetiaculiselitaliquamvitaeporttitorligulamaecenasacnislmaximusinterdumsemadignissimfelisaeneanportapharetranunceucondimentumproinfringillaeuismodrisusvitaepulvinarcurabitursodalesloremvitaemaximusmaximusfeliseratsollicitudintellusidrhoncusaugueliberoaturpisutquisarcuurnaproinrutrumsempermassaquissagittissapienfacilisissitametfuscevitaeegestasipsumproinegetmassadignissimdapibusfelisvenenatisvolutpatjustosuspendisseegetcursuselitduisaeratportagravidaenimconsequatcommodoestdonecscelerisqueenimacquamblanditvelaccumsannullasodalescrasacdictumtellusaeneanvelmetusipsumaeneanneciaculissapienaliquameratliberovehiculafacilisispulvinaridultricesutestuteuurnasitametleofermentumvariusaliquamatnisinuncblanditvelitegetauctorhendreritphasellusarcuerosaliquetsedfacilisismalesuadaplaceratornarearcudonecsitametodioatpurusvariusrhoncuseuacfelissuspendissecursusestsedaugueeuismodcondimentumpellentesqueaexcongueduivehiculatinciduntblanditvelenimaliquamnonenimfelissuspendissepotentialiquameratvolutpatmaecenasauctoreratvenenatissodalessollicitudindonecmalesuadamaurisacpulvinarcommodosedsuscipitatsemhendreritconsequatduismaximusplacerataliquetduisacloremfermentumposuerefelisathendreritnibhsedcongueornarediaminblanditnislnuncscelerisqueornaredignissimnullarisuserosconsecteturnecnibhposueresodalesvariusmassacrasmattisrutrumnislsitametconguealiquameratvolutpatdonecportaplaceratmagnaatportaaliquamiaculisnecanteegetfaucibuspellentesqueligulamaurisaliquetsitametsapienatvariusvolutpatduiphasellusvenenatisarcusitamethendreritultricesnamsodalesetlectusineleifendintegerlacinianullautposuerevulputatenequearcuvariussemvitaelobortisfelisarcurhoncusmaurismaurislectusurnalacinianonsapienacpretiumlacinialigulafusceloremmisuscipitsitametpharetraatiaculisacloremdoneclaoreettortorurnaatscelerisquerisusrutrumutvestibulumfacilisisdignissimnibhcrasnecliberolectusnuncviverramalesuadaliberosedportamorbisitametenimvenenatislacuseuismodvariuseutinciduntorciutetdoloreratsuspendisseconsequatmassaacestcondimentumsitametsempernisilobortisvivamuseleifendegestasmiegetvulputatepuruspharetravitaeinvolutpatvariuslobortisvestibulumsuscipitaliquettellusquisdapibusduisnonscelerisquetellusnullanonluctusmaurisfusceacpellentesquemaurisnecmalesuadanuncpellentesqueeleifenddiamnonexvulputatevestibulumcrasefficiturdignissimrhoncusutsitametsapiensedexlaciniaaccumsanaasemetiamlaciniapulvinareratnonfringillaaeneanimperdietestacnullalobortisquisluctusnullamolestieorcivariusnatoquepenatibusetmagnisdisparturientmontesnasceturridiculusmusmorbigravidaturpiseumaurispharetraneccommodoeratplaceratinhachabitasseplateadictumstinquisgravidaliberovestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraeaeneaneuligulanecvelitsuscipitmaximusphasellustellustortorconsecteturinlectussitametcursusmalesuadaarcuutposuerearcuacnequefringillascelerisquenuncsedaliquameratmaurisligulanisifermentumeuliberoegetaccumsanmaximusquamnamfaucibusmalesuadaeratamollisaeneancondimentummetusestdonectristiqueodioeleifendeliteuismodcursusetiammaurisenimcursusmaximusnisinecvariusfermentumelitquisquecursustinciduntullamcorperdoneclacinialaciniaimperdietsedconsequatjustoquamacvolutpateratvestibulumutmorbiaeratposueremalesuadaexquisdapibuselitsedvariusvelloremacvestibulumvivamusquisantesedfelismalesuadarhoncusquisegettellusquisquetristiquetortorvitaenibhsuscipitacpulvinarenimultricesfusceullamcorperiaculisorciimperdietgravidarisusgravidaacnullamvehiculaeleifendfelisquiscommodoproinegetpellentesqueestduisturpislacuselementumatnequeidfeugiatvariusvelitpraesentfinibussemperfelispellentesqueornaresuspendissecommododiamaeuismodfinibusnisileoornareturpisutvenenatissapienantenonquamingravidacondimentumipsumeusollicitudinvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraeintegeradiamsitametrisustristiqueposueresuspendisseneclectusfinibusfeugiatarcuidhendreritsapienduisvolutpatfelisegetporttitorsollicitudinquamantefaucibusauguenecconsecteturerosquamneclectusdonecsitametleopulvinarmollisquamvitaehendreritipsumintegersuscipitleoacultriciesaliquetpurusjustopulvinarpurusetsollicitudinnequeurnaidpurusnamnonbibendumenimproinrhoncusaugueetfeugiatfermentummagnadolorsollicitudinleovitaescelerisquejustonisieunibhinhachabitasseplateadictumstcrasquissodalesarcuidfeugiatlectusutneclectusacpurustinciduntfacilisisnecattortorcrascursuslectusloreminvestibulumvelitcondimentumegetvivamussitamettristiqueleosedsedmollismiatscelerisqueerosquisqueeufelisinnuncportalaciniaegetsitametarcuvestibulumaccumsanexjustoquisluctusturpisconsequatsitametaeneanvestibulumligulaidorcifinibusgravidaquisqueveltristiquevelitmaurisquamnisimolestieinfelisutmattiscongueestsuspendisseutconvallisorciegetauctorelitvivamusacommodovelitaeneanexnislmollisegetconguequiscondimentumaligulaphasellusconsecteturfelisidsollicitudinultricieseratnibhsodalesliberoacpulvinarnislorcietdolorpraesentmolliseleifendenimvitaeaccumsanmassatempusidinefficiturorciatsollicitudinfringillavestibulumrutrumenimneciaculissollicitudinipsummagnavolutpatpurusvelmollisfelisdiamvitaetellusnullamsagittisdolorvitaeestrutrumconsecteturvolutpatenimsagittisaliquameratvolutpatinhachabitasseplateadictumstinsuscipitnequemetusatmalesuadamiconsequatetdonecrutrumatnislegetviverradonecinpretiumtelluspellentesqueultriciesmollislorematsuscipitliberoplaceratamorbilaoreettinciduntsapienasollicitudinnamporttitordolorliberoetpretiumurnaluctusquisquisquebibendumfringillaeratvitaepellentesqueaugueluctusquisclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosinutipsumporttitorconsequatquameuposuerevelitproinnecporttitornequevivamusneccondimentumexegetcondimentumvelitproinultriciesmivelmaurisbibendumaccumsanvestibuluminurnasempermollismetusnecportaauguenuncvitaemetuspurusvestibulumvelliberoeturnavulputatetinciduntmorbinisimitinciduntnecenimatullamcorpersollicitudinestproinvolutpattortorsednullaconsequatacfermentummetussuscipitaliquamutlacusatelitvehiculascelerisquedonecsapiennullatempusidfaucibusinmalesuadaacnuncduisnonmassaornarecondimentumanteportasagittisleoduisnecsemegetdiamlaciniarhoncussedettortorsempernisiullamcorpertinciduntrutrumvelerospellentesqueeuismoddiaminipsumeleifendimperdietaeneanatsuscipitdiamutinterdumpuruspulvinarfermentumcommodoinnonvenenatisenimpellentesquesemmaurisluctuseueratacfaucibusimperdietnuncnuncetlectusdictumtincidunteratquisposuerediamnullamtinciduntarcuidimperdietullamcorperutnecnullanuncnamsemperelitiddictumfringillanibhelitsemperarcuquiseleifendenimeratquisnibhphasellusbibendumvitaeexaceleifendproinullamcorperlacusegethendreritsemperpellentesqueatelitsollicitudincursusenimetconsecteturduiquisqueconsequatrisusexviverraluctusmagnaconsequatutinveldictumipsumvivamusplaceratantesitametauctortempusnisiarcususcipittellusvelauctortortornuncnondolorcraseleifendvariusnisiaciaculispellentesquemattismetusetmagnatinciduntconsecteturutnonmiexdonecmattisurnaegetmimolestieelementumintegeretsemvariustinciduntjustoeudignissimdoloraliquammaximusplaceratmagnasitamettempusintegeripsumturpisfaucibusfermentumtortorapulvinarconguenibhsedmolestieactellusatrhoncuspellentesqueposuerevestibulumlectussedultriciesvivamusvitaenisinullavestibulumquisfelisuturnascelerisqueeleifendsedmetusmassatristiqueinarcusodalesinterdumcondimentumquamintinciduntmagnaultriciesorcipretiumaconguearcumollisaeneancondimentummollisscelerisqueduisrhoncusveldiamapretiumprointellusurnapharetravelfeugiatnecdignissimeuorcietiamposuereporttitorlaoreetpellentesquevitaeporttitorduifuscedolormagnaaliquamnecarcuquiselementumelementumdolorquisquebibendumjustoquiscongueluctusmagnaquamcursuselitintinciduntexmassaelementumtellusvestibulumpulvinarestnecsapienvariussedelementumquammattispraesentdapibusnisietfeliscongueutviverranisiconsectetursedcondimentumaccumsansapiensedlaoreetsuspendisselaoreetegestasfelisutpulvinarturpissemperatsuspendissealiquamnequeinvolutpatgravidajustonullaporttitorarcuindapibusrisuslectusegetquamduisconsectetursedenimeualiquamfusceeuiaculisliberoacvulputatetortordonecefficiturdoloracaliquamfeugiatnequejustoimperdietnisinecmaximusleoestutnuncnullamsedjustoiaculisinterdumipsumetviverralacusutlaoreetfermentumdiamconvalliseleifendenimsemperidmorbiveljustodolorsedsagittissapiensedlaciniavariusnequelacusimperdieteratvitaeefficiturantediameununcaliquamacrhoncusturpisactinciduntquamfusceluctusaccumsangravidasednonlacustortornullaelitestblanditquisaliquamvariushendreritdignissimpurusmorbitemportinciduntturpisetaccumsannuncvariusquaminporttitorelementummetusloremornarequamegetfaucibusligulafelisanullaaliquamapurusutjustopharetralaoreetnullamaliquetnuncasagittisconsecteturinterdumetmalesuadafamesacanteipsumprimisinfaucibusclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosintegeracipsumintortorlobortisaliquetdonecconsecteturmivariuslobortismaximusduisdignissimconsecteturorciiddictumduiporttitoranunchendreriterosetporttitoraliquetaeneananullaetmagnavehiculapellentesquemaecenasidlacusacnequetinciduntullamcorperanonjustoseddictumtortoregetfermentumgravidasedinsagittisantemaurisfelisleotempusnecsodalesnonaliquetsednuncsuspendissepotentimaecenasfermentumtristiqueultricesaliquamdictumimperdietornaremorbivestibulumnequeinestsempervelfermentumrisusfringillapraesentdapibusvitaelectusinpulvinaraliquameratvolutpatdonecdiamodioplaceratnonligulaquisfermentumbibendumexintegereuaugueatnequefacilisisvehiculaintegersodalestortoranteidsuscipitexvehiculaacnuncluctusnuncturpissitametdictumexaliquamquisaeneantempusullamcorperligulaetscelerisquemaurisfuscevitaesapienetipsumporttitorpretiumvelnecorcifuscerutrumlectusloremsedtinciduntlectusaccumsanbibendumphasellusacdolorfeliscurabiturtinciduntnibhquisscelerisquevariuscraslaoreetsodaleselitatpulvinardonecaccumsaninterdumquamegettinciduntexlobortisegetaeneanamassaiaculisornaremagnainconsecteturduialiquamposuereligulaleosediaculistellustempussedduisfeugiatpellentesqueelitvivamusluctusorciveltristiquetristiqueinhachabitasseplateadictumstmorbidictumimperdietsemattristiqueenimnullanecfaucibusdoloridluctusmetussedhendreritdiamsitamettristiquemalesuadafelisleoscelerisqueeratindictumsemmineclacusfuscesollicitudinauctormetusnonfinibussedsemperestvelauguefeugiatfeugiatduisactinciduntarcuproinidconsequattellussuspendisseporttitorelitseddolorsodalesseddapibusnislvenenatisinarcunislornarevelleoelementumcommodosollicitudinsemclassaptenttacitisociosquadlitoratorquentperconubianostraperinceptoshimenaeosetiamsedpharetradiampraesentiaculisarcusederateleifendtinciduntcraspulvinarorcivitaecursusplaceratvelitlectusvolutpatarcuettempusnisinequeetloremnullavenenatisduiegetconsequatinterdumdolorduipellentesquelacusacmaximusantesapienalectusvivamustempuseratsitametfringillatinciduntsuspendissevenenatissollicitudinanteetvulputatefuscepellentesquenislacvehiculalaciniapraesenttristiquerhoncusdolorsedcommodopraesentconsequatmattistortornecinterdumcurabiturconsequatblanditturpisegetsemperquamtristiquenonintegeretdictumurnafuscelaciniaeratultriciesorcicondimentumplaceratetiamnecodioetnequepretiumaliquetcurabiturfaucibuseuismodtellusinquisdapibusmetusquisquedapibusrhoncusmassamolestieposuereelitmattiseupraesentsemperplaceratmassaatristiquepurusblanditsitametnullabibendumvolutpatmetusidpretiumvestibulumanteipsumprimisinfaucibusorciluctusetultricesposuerecubiliacuraeaeneanmalesuadamaurisquisaliquamconsequatrisusjustovulputateduisedimperdiettortorligulaatorcicurabiturvelmaurisutodioimperdietbibendumnecaturpisphasellustemporvehiculatellusnammagnatortorfinibusvitaemagnaquisultricieseleifenddiamseddignissimmetusvelmolestieelementumleournainterdumduiegetsollicitudinsemarcusitametnisietiamconguedoloridduifeugiatporttitornullamefficiturarcuidimperdietornarenibharcuultricieselitatsuscipitauguerisusacfelispellentesquesollicitudinodioveltinciduntauctordonecorcisapienviverrautmassaactempusmalesuadadiamdoneclaoreetduidignissimmagnavehiculaconsecteturduisutmassasedduifinibustemporinposuerenequeeuloremdapibusauctornullaegetiaculisaugueaeneaneleifendmetusettemportinciduntfusceullamcorpermassaacvenenatisullamcorperintegermattisfeugiatlobortisaliquammattisarcuquisurnavariusinsuscipitarcumaximusnuncurnadolorporttitorplaceratestnoncursuspulvinarnisisedmattisfeugiatvariusloremipsumdolorsitametconsecteturadipiscingelitduisviverracongueodioacpellentesquenametvolutpatsapiensedrutrumipsummorbimattisnonerosnonvariusphasellustinciduntdiamatmattisinterdumdonecdiamduipretiumnecerosetinterdumdictumliberointerdumetmalesuadafamesacanteipsumprimisinfaucibusintegeramagnametussedattelluslaoreetrutrummaurisvelposuereligulavestibulumacvulputateduimaecenaspurusnuncfringillasitametestnonpretiumvenenatisnisialiquampellentesquefinibusvelitaviverraaugueeuismodconsequatnuncinterdumnonrisusvitaegravidamorbimetusnisiportatemporelitnonporttitorsuscipitfelissedtinciduntconvallistristiquefuscefacilisiselitsedfacilisisfacilisistortorpuruselementumquamconvallisauctormiliberosagittislectusfusceeunisisempercommodoorcisitameteleifenderoscrasodioeratgravidaatplaceratatultriciessedloremsuspendisseatviverraduisuspendissenondiamexdonecvestibulumlobortishendreritdonecnullafelisfeugiatsedligulaidvariustempusnislnamvulputateconsequataliquetfuscefeugiatsapienegetarcucommodoinconguesapientinciduntquisqueeratloremeleifendfeugiatnullaquisconvalliscondimentumrisusduisdapibusaturpisidtinciduntmaurisutipsumnibhproinanequealiberovestibulumconvallisduisinimperdietduimorbiidsempertellusinnequenibhtristiqueidrisusnoninterdumiaculisvelitproinnonmagnasemnullamainterdumurnamaurisquismagnaeuturpisaliquetvariusquisquetinciduntestvelnequeviverrafringillapellentesquehabitantmorbitristiquesenectusetnetusetmalesuadafamesacturpisegestasvivamusnectempussapienacluctusvelitintegerconsequatloremsitametvehiculaultriciesorcielitsollicitudinorcisedvestibulumestdolorutelitetiamvelultricesipsumvitaeimperdietfelisvivamusmaximusexidmassaauctorvitaefringillasapiencursusmaecenasfelisipsumsuscipitnonultriciessodalesmollisegetlacusdonecullamcorperquamatrhoncusmalesuadaetiamiaculissemveleleifendornaremassatortoreleifenddiamiddictumeratpurusacrisusintegerlaciniaodioatnisipulvinarattinciduntauguecondimentumproinmalesuadafelisturpisidlaciniaeniminterdummattisduisvelexconsecteturmattisnuncetullamcorpervelitmaurisinmattisfelisetpretiumodiopellentesquealiquetipsumegestasorciconguevitaealiquetloremvestibulumduisvitaerisuselementumlobortislectusafermentummetussedfacilisisturpisegetposuerevenenatiseratpurusvestibulumnibhaceleifenddolortortornonvelitmaecenasutfacilisisturpisetplaceratmetusaeneanlacusjustosagittisvitaeblanditidfermentumvelestloremipsumdolorsitametconsecteturadipiscingelitfusceveltemporodioaliquamtristiquearcusemperestornaregravidaaeneanconsecteturviverrafelisnonaliquampellentesqueauctorexacimperdietporttitoraliquamtinciduntcondimentumsempercrasrutrumsapieneuinterdumporttitorerosquamvolutpatpurusacsempernislleoetlacusphasellusrutrumarculobortispretiumtortornecmolliselitpraesentdictumvehiculasemetfringillasedvestibulumanteinpharetraauctorligulanequealiquetantevitaeconvallisexmagnavenenatisnequemaecenasfringillaconvallisnuncpulvinarpellentesquesuspendissepotenticrasmassaliberoviverraaiaculisincommodoconsequatjustoaeneansitametfinibuspurusidfinibussemfuscevestibulumlaoreetliberononportaerosgravidamolestienametorcifeugiateroslaoreetvulputatenuncinfelisluctusegestasmauriseuconguejustovivamusveltellusnonanteeleifendconsequatetefficiturnibhproinfeugiatdiameuleofinibussedcursustortorvenenatisnamtempustortorquisnuncinterdumsuscipitpellentesquenonorcisitametrisusluctusegestasvelnontortorquisquefeugiatlacusetrutrummalesuadasedvehiculaplaceratlaoreetdonecornareegetexegetornarenamnecplaceratnequeaviverraurnasuspendisseaugueliberotristiquenecsollicitudinarhoncusinurnaphasellusacgravidadolornullamsodalesullamcorperloremvitaefaucibuseratiaculisnonmaurisinterdumleofermentumcommodoliberonecvulputatejustodonectempusarcuutefficiturbibendumminequefeugiatligulaaccursusenimmassanecvelitnullampharetranequeetexfermentumaccongueenimvolutpatdonecutlaoreeteratnuncatsempermagnamaurispurustellusluctusvelsapienquiselementumcondimentumnequecurabitursuscipitvulputatemaurisquisquevenenatiserostortorquisportapurusviverraut \ No newline at end of file diff --git a/Third term/Discrete math/some_text.txt b/Third term/Discrete math/some_text.txt new file mode 100755 index 0000000..95d61a5 --- /dev/null +++ b/Third term/Discrete math/some_text.txt @@ -0,0 +1,301 @@ + + +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi et eros mauris. Nullam nec lorem fermentum, viverra nunc nec, accumsan erat. Aliquam lacinia velit nibh. Morbi varius rhoncus velit, et tempus nulla interdum et. Vestibulum eget enim in risus faucibus tincidunt. Duis tellus elit, ornare ac orci eu, euismod scelerisque augue. Cras vitae arcu interdum, convallis libero quis, egestas arcu. Proin ac hendrerit sem, in tempor enim. Curabitur sollicitudin eros in nulla malesuada rutrum. Curabitur lacus ante, rutrum quis quam id, commodo laoreet nulla. Proin non vehicula enim. Phasellus tempor commodo diam, ullamcorper pellentesque metus blandit quis. Pellentesque nisi enim, ultricies quis sagittis vitae, ornare et justo. Vestibulum pretium rutrum rutrum. Nulla facilisi. + +Nam ipsum tellus, tincidunt eu malesuada et, imperdiet vitae mauris. Morbi condimentum nisi sit amet magna mattis, condimentum rhoncus nibh eleifend. Proin gravida libero blandit nisl consequat efficitur. Suspendisse id magna et augue bibendum pharetra vitae non dui. Vivamus ipsum sapien, sollicitudin sit amet tempus a, vehicula at leo. Mauris tempor metus ut gravida scelerisque. Proin in tristique odio. Interdum et malesuada fames ac ante ipsum primis in faucibus. Quisque consectetur sagittis enim et tincidunt. Nam consequat nulla est, a convallis massa facilisis ac. + +Proin nunc massa, egestas a ex vitae, imperdiet pellentesque purus. Integer semper magna nibh, sed commodo mi placerat in. Pellentesque ullamcorper blandit nulla. Duis feugiat purus at cursus tincidunt. Phasellus aliquam tellus at velit efficitur cursus. Ut eu auctor elit, id sollicitudin nibh. Lorem ipsum dolor sit amet, consectetur adipiscing elit. + +Integer quis efficitur elit, eget faucibus ex. Morbi efficitur purus sit amet purus placerat ornare. Aliquam in suscipit eros. Cras ultricies, nisi quis posuere iaculis, felis urna vestibulum mi, quis volutpat metus velit eu eros. Mauris in rutrum ligula, quis volutpat ligula. Duis in interdum dui. Donec a ligula velit. Praesent dictum lorem leo, vel placerat mi vehicula nec. Vestibulum lectus est, pretium a gravida sit amet, vehicula vitae nisl. Duis nec ultrices mauris, ac vestibulum tellus. Ut lacus elit, ullamcorper eu risus vel, cursus posuere lectus. Duis sit amet laoreet metus. Nullam volutpat consectetur purus sed faucibus. Suspendisse nec ullamcorper lorem. + +Duis neque nisl, volutpat in ante semper, finibus feugiat lacus. Morbi id est ante. Vivamus at tincidunt sapien, at maximus erat. Phasellus congue et augue euismod tincidunt. Nunc orci quam, vestibulum fermentum semper a, suscipit a ante. Suspendisse erat metus, ornare eget pretium eu, vestibulum non massa. Curabitur arcu erat, egestas et turpis et, dapibus suscipit orci. Etiam lobortis ligula mauris, vitae molestie elit tristique sed. + +Fusce ipsum lorem, luctus sit amet diam sed, condimentum tincidunt elit. Nulla tincidunt elementum arcu. Mauris laoreet elit eu eros faucibus lobortis. Vestibulum leo orci, interdum ut tincidunt et, placerat eu nisi. Nam aliquet accumsan lorem vel pharetra. In sem metus, aliquet a quam sed, vehicula pellentesque felis. Fusce cursus dui nisi, in tempor orci bibendum sit amet. Integer vel suscipit nibh. + +Sed lobortis in metus ut efficitur. Proin dui augue, finibus ac volutpat in, porta eget orci. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nunc semper ipsum sit amet congue viverra. Sed ullamcorper felis vitae lobortis varius. Vestibulum id lacus ac quam lobortis pretium. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Ut scelerisque fermentum nunc quis volutpat. Ut in libero accumsan, interdum felis sit amet, interdum mauris. Donec non vulputate sem. Maecenas pellentesque, felis ut mollis pellentesque, risus nisl elementum libero, at blandit ligula nisi at diam. Sed eu hendrerit neque. + +Nulla porttitor lacus vitae risus efficitur suscipit et et est. Etiam auctor posuere sapien, eu malesuada lectus eleifend et. Aliquam scelerisque sollicitudin nibh, id faucibus enim accumsan ut. Praesent sit amet dolor nisl. Mauris pulvinar tincidunt neque eu lobortis. Donec lobortis dapibus augue, vel ultricies diam ornare a. Nullam lorem dui, accumsan nec mollis a, egestas ut nisi. Nulla tempus interdum ligula. Phasellus sed magna ligula. Ut pellentesque lectus ac ex sodales maximus. Sed laoreet nibh eu mattis pretium. Nullam in erat faucibus, imperdiet turpis at, venenatis augue. + +Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Morbi eget mattis augue. Nullam id odio diam. Vestibulum et nisl quis lacus sodales viverra. Quisque hendrerit auctor lorem. Sed molestie dolor et augue maximus, eget luctus neque rhoncus. Vestibulum volutpat luctus vestibulum. Vivamus mollis massa a sapien rutrum pulvinar. + +Nunc sit amet tortor orci. Nulla tincidunt lorem aliquet varius eleifend. Aliquam erat volutpat. Morbi ut urna augue. Pellentesque feugiat, erat at fringilla congue, massa arcu ullamcorper felis, in gravida libero lorem ut odio. Pellentesque eget orci sed lectus tempus lacinia. Aenean sit amet gravida mauris, quis interdum est. Integer eu placerat ligula. Mauris dapibus aliquet urna, semper hendrerit nunc lacinia eu. Vivamus pellentesque risus et arcu dapibus, ac posuere orci sagittis. Integer molestie diam ac mollis ullamcorper. Sed tincidunt pretium lectus ut convallis. Donec euismod quam nec lacinia eleifend. Nam gravida massa orci, sit amet bibendum quam consequat eu. Duis eget dapibus diam, ut ullamcorper leo. + +Morbi justo dui, lobortis vel dapibus in, blandit sed nisl. Vestibulum faucibus mauris et nunc lobortis pellentesque. Aenean in bibendum diam. Donec finibus a ligula a imperdiet. Mauris sodales nibh sem. Praesent a auctor nisl. Maecenas ante mauris, suscipit id purus eget, mattis tincidunt augue. Integer non diam eget enim viverra iaculis. Quisque nec est nec leo condimentum consectetur. Mauris accumsan vitae diam id facilisis. Sed fermentum venenatis lobortis. Curabitur vel pellentesque urna. Vivamus vestibulum mi vel varius mollis. Praesent convallis lacus id ipsum varius, quis suscipit mi pellentesque. Quisque et lectus ante. Fusce sed purus metus. + +Quisque dapibus felis vel neque placerat ultrices non quis sem. Cras id congue ante. Nam tempor volutpat laoreet. Integer malesuada, eros eget sodales aliquam, velit urna faucibus justo, non varius turpis ligula nec metus. Praesent sed enim ornare, vehicula enim at, feugiat velit. Maecenas suscipit interdum facilisis. In hac habitasse platea dictumst. Fusce lobortis eu felis accumsan consectetur. + +Vivamus dictum ultricies facilisis. Pellentesque nisi turpis, rhoncus ut lacus eu, vehicula dictum diam. Quisque mattis ac neque a viverra. Nulla porttitor faucibus elit, a molestie ante interdum non. Duis nulla nisl, elementum et interdum et, sodales sollicitudin urna. Vestibulum sed felis a ex faucibus lobortis. Nam faucibus nibh eget faucibus lobortis. Etiam hendrerit mauris at finibus luctus. Donec et ipsum accumsan, aliquet dolor eget, fermentum justo. In hac habitasse platea dictumst. Aenean faucibus quam ac lacus venenatis, sit amet bibendum est aliquam. Fusce pulvinar ornare enim ut convallis. + +Fusce ultricies massa mollis iaculis euismod. Donec viverra, ligula ut tristique dapibus, justo purus finibus turpis, vel facilisis nisi diam ac dui. Nunc id dui in magna fermentum ornare. Fusce id pulvinar libero. Suspendisse neque erat, fringilla et bibendum vitae, placerat volutpat ante. Ut posuere dignissim ante vitae condimentum. Interdum et malesuada fames ac ante ipsum primis in faucibus. In hac habitasse platea dictumst. + +Duis iaculis, ex ac lacinia fringilla, ex ligula fermentum justo, vel tempus neque ligula id metus. Praesent nec aliquam risus. Donec in lorem porttitor, fringilla leo ac, consequat tellus. Fusce ultrices metus ut ultricies rutrum. Fusce ut ante non magna scelerisque interdum. In vehicula ex arcu, vel cursus sapien iaculis a. Vivamus blandit lacus sed aliquam mollis. Nullam condimentum tellus nec vestibulum tincidunt. Ut suscipit, turpis ac aliquet auctor, urna elit interdum sem, at aliquet enim diam ut leo. Integer dignissim massa sed blandit dapibus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Phasellus fringilla, felis ut facilisis mollis, mi dui egestas tortor, vel facilisis mi diam ac tellus. Nam et maximus elit, sit amet laoreet tellus. Suspendisse tempor mattis elit id molestie. Aenean vestibulum tortor ac commodo elementum. Aenean vitae dolor nec libero viverra tempus quis non elit. + +Pellentesque feugiat lacus nec nunc rhoncus, eu imperdiet ipsum feugiat. Nullam commodo est at suscipit porttitor. Nam suscipit risus at tortor porttitor bibendum. Praesent id finibus eros. Proin tempus enim odio, vitae condimentum ante convallis eget. Donec malesuada nisi et velit bibendum accumsan. Vestibulum luctus velit vel augue venenatis, gravida ullamcorper ex commodo. Duis vulputate lacinia varius. In hac habitasse platea dictumst. Nunc condimentum ante diam, ut ultrices arcu egestas vitae. Cras sit amet nisi feugiat, fermentum urna sit amet, ultrices quam. Aliquam sed ligula et erat pellentesque imperdiet. Phasellus nec velit sit amet nibh consequat scelerisque quis ut est. Proin neque massa, bibendum nec varius ac, congue in ante. + +Ut non sem faucibus, sollicitudin enim id, facilisis leo. Curabitur porttitor faucibus orci, in bibendum velit gravida et. Quisque pharetra vehicula dui, sed placerat nisi eleifend sit amet. Cras mattis mauris et elit porttitor aliquam. Morbi eget pellentesque ipsum. Donec gravida erat diam, eu venenatis enim consequat eget. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam nec pretium neque. + +Proin vitae orci sem. Etiam pulvinar enim vitae orci vehicula, quis congue tellus lobortis. Sed dapibus tincidunt erat, at semper risus mattis eget. Donec consectetur massa dapibus augue tempor, id sollicitudin tortor finibus. Etiam egestas pharetra maximus. Etiam id consequat diam, et tristique urna. Mauris sit amet purus et risus condimentum vestibulum. Donec elementum ultricies urna vitae ultrices. + +Duis facilisis non sem in suscipit. Etiam interdum tortor sit amet tellus egestas consectetur. Proin non suscipit arcu, et pharetra lorem. Cras cursus ligula nec diam pulvinar, nec consequat nulla vulputate. Quisque aliquam dapibus maximus. Phasellus in finibus augue. Aenean fermentum nisl at mauris rhoncus lacinia. + +Aliquam erat volutpat. Vivamus ut egestas mi. Phasellus laoreet finibus purus sit amet molestie. Suspendisse consectetur neque sit amet hendrerit interdum. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut at tellus ac mi molestie finibus. Cras eget varius magna. Duis eleifend purus ut metus vulputate accumsan vitae at leo. Integer aliquet varius arcu. Integer ac vehicula ante, nec placerat justo. Nunc cursus maximus urna sed congue. + +Mauris eu maximus mauris. Praesent fringilla ut diam lobortis ullamcorper. Ut elementum nibh vitae nisi sodales hendrerit. Proin euismod nibh quis purus imperdiet rutrum. Quisque vel scelerisque ante, sed placerat nisi. Suspendisse accumsan libero et mauris facilisis, posuere imperdiet nisi dignissim. Integer vestibulum sapien in nulla consectetur, eu scelerisque felis porta. Vestibulum vitae justo luctus, posuere arcu eu, fermentum urna. + +Proin ullamcorper neque aliquam nibh egestas, id interdum lorem laoreet. Etiam id tempor dui. Vivamus congue iaculis felis, ac maximus elit feugiat quis. Aenean est massa, condimentum vel varius in, venenatis a purus. Sed pellentesque iaculis sem, eu aliquam urna lobortis non. Morbi magna arcu, elementum eu orci ut, venenatis aliquet lectus. Proin bibendum suscipit sem id sagittis. Duis tempor sagittis luctus. Praesent et elementum dolor, sit amet aliquet nulla. Nunc vitae volutpat ipsum. Praesent eu leo condimentum, facilisis libero in, tincidunt leo. Suspendisse vestibulum ipsum non nunc finibus, id vestibulum ligula ullamcorper. Duis posuere mattis massa id fermentum. Nulla facilisi. Fusce sapien neque, porttitor quis porttitor in, maximus id quam. + +Donec egestas maximus massa in faucibus. Nunc tempor elit non massa dapibus, eu dignissim est pellentesque. Donec pharetra consequat aliquam. Quisque at dui quis erat gravida vulputate a non ex. Curabitur ornare, massa ac tincidunt placerat, erat metus suscipit diam, id consectetur enim risus quis erat. Mauris ligula mauris, vehicula ut libero in, vulputate scelerisque nisi. Donec ac ipsum vitae orci convallis vestibulum eget eu nunc. Maecenas sit amet molestie purus, vel auctor nulla. Aenean iaculis mauris at risus dictum rutrum. Suspendisse semper semper turpis, eget semper nibh. Pellentesque ligula sem, porttitor ut leo sed, tempor posuere arcu. + +Vivamus at odio tortor. Curabitur euismod interdum purus eu convallis. Cras eleifend dapibus turpis. Duis eros nisl, gravida nec bibendum ut, lacinia non quam. Curabitur venenatis lorem suscipit, euismod velit commodo, tristique felis. Vivamus et enim interdum, posuere enim at, maximus nunc. Quisque lobortis fringilla enim, a ornare magna vulputate at. Aenean arcu nulla, fringilla vitae enim sit amet, porttitor aliquet erat. Quisque sollicitudin pharetra purus id vestibulum. Etiam eget placerat velit. Etiam facilisis ligula vitae ullamcorper fringilla. Vestibulum volutpat, ligula eu luctus dignissim, magna nibh cursus odio, nec imperdiet enim sapien quis turpis. Sed accumsan nunc sit amet ipsum dictum mattis. + +Morbi et ultricies turpis. Cras vulputate dolor ut sem vestibulum, non semper enim bibendum. Donec fringilla nisi nec elit vestibulum faucibus. Maecenas non lacinia sapien, ut porttitor erat. Curabitur et eros a nisi accumsan facilisis eu eu urna. Mauris bibendum sagittis felis, ut mattis nulla faucibus eget. Suspendisse in elit ut nibh hendrerit pharetra. Integer nisi dolor, mollis in turpis a, vehicula dictum nisl. Etiam posuere lacinia dolor, sed aliquet metus consectetur nec. Maecenas quis tincidunt orci. Donec euismod egestas massa, vitae aliquam quam malesuada eget. Donec non nisi odio. + +Mauris tristique et tellus non fringilla. Integer tempor at nisl vel convallis. Maecenas convallis aliquam justo vel ultrices. Aliquam gravida placerat risus vitae venenatis. Suspendisse aliquet sagittis tortor dignissim aliquet. Sed et mattis libero. Maecenas auctor tortor nibh, eget tempor felis bibendum vel. Morbi mollis arcu mi, eu placerat massa fermentum sit amet. Etiam sollicitudin rhoncus urna, non tristique massa consequat sagittis. + +Duis sagittis porta ipsum, nec ullamcorper turpis eleifend ac. Quisque pellentesque imperdiet dui eget tempus. Aliquam eleifend egestas maximus. Aliquam efficitur enim quis tellus pellentesque pulvinar id a nulla. Duis non pharetra sapien. Nullam porttitor magna mauris, vitae mollis turpis vestibulum quis. Donec dignissim nisl non lorem placerat, eget condimentum arcu commodo. Suspendisse potenti. Vivamus consectetur arcu ut nibh viverra, id sagittis tellus egestas. Proin non mattis diam. Ut in nibh non leo placerat finibus. Aenean consectetur dictum nulla quis ultricies. Curabitur pulvinar maximus gravida. + +Proin vestibulum quam sed magna sagittis egestas. Curabitur a nisi maximus enim sodales vulputate ut id lorem. Morbi ullamcorper fringilla mattis. Vivamus pellentesque consequat nibh. Mauris aliquet, urna eu mattis maximus, leo elit congue arcu, eget ullamcorper nibh eros id mi. Suspendisse semper suscipit nulla. Etiam accumsan neque leo. Interdum et malesuada fames ac ante ipsum primis in faucibus. Quisque vulputate, nibh non malesuada suscipit, ex lacus sodales erat, nec ultricies mauris nulla gravida purus. + +Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi mattis, nunc eu consectetur feugiat, metus turpis consectetur felis, eu pulvinar ipsum purus et lorem. Integer elementum, nulla vitae tincidunt condimentum, orci justo fringilla velit, ac posuere est est nec dui. Ut ornare, quam varius tincidunt interdum, felis ligula semper metus, vel mollis diam dolor sed lorem. Proin auctor augue nisl, non lobortis velit lacinia luctus. Curabitur ac tellus ex. Donec dignissim nec urna id posuere. Fusce erat justo, fermentum ut elit ut, efficitur pretium odio. Suspendisse ultricies sit amet justo vel congue. Sed laoreet consequat nunc, non scelerisque tortor porttitor non. Nullam libero risus, porttitor vel velit luctus, dapibus rutrum nisl. Mauris ut porttitor risus. + +Suspendisse finibus elementum velit, vel imperdiet tellus elementum sit amet. Etiam a faucibus nisl, ut maximus odio. Curabitur id nisl ac nibh malesuada semper in quis purus. Nulla ut elementum sem. Vestibulum quis enim sed lacus pretium tempus vel rhoncus eros. Morbi mattis sodales metus, vitae aliquam neque scelerisque sed. Phasellus at volutpat lectus, ac hendrerit felis. Nullam consectetur cursus ipsum, quis aliquam orci luctus eget. Curabitur efficitur consectetur purus, id suscipit lectus. Mauris sagittis posuere dolor, a vestibulum lectus consectetur vel. Etiam aliquam convallis ipsum, a condimentum lacus accumsan nec. Integer tortor tellus, tincidunt non tortor at, dignissim eleifend nulla. Etiam a ligula ac metus feugiat pretium non et risus. Curabitur finibus sollicitudin ipsum, et ornare nisl condimentum eu. Proin tristique non erat eget bibendum. + +Nunc fringilla, ex ut gravida vulputate, purus felis elementum elit, id fermentum massa massa at turpis. Curabitur aliquet eu lorem ut gravida. Sed auctor non augue ut consequat. Morbi sodales diam vitae vestibulum iaculis. Nullam at nunc tortor. Donec nec consequat justo, nec lobortis odio. Phasellus sit amet urna dui. Vivamus tincidunt, purus ac aliquet lacinia, nulla lacus euismod elit, vel egestas dolor augue ac justo. Vivamus vitae tortor scelerisque ex sagittis rhoncus in nec enim. Suspendisse magna eros, feugiat quis consequat eu, dictum quis neque. Sed vel lorem diam. + +Suspendisse ultrices id lacus vel venenatis. Ut et convallis augue. Sed id nisl urna. Proin faucibus imperdiet erat, hendrerit faucibus tortor sodales feugiat. Vivamus commodo, nibh vitae interdum tristique, felis nisl molestie diam, sit amet dapibus mi mauris eget lectus. Duis pharetra erat eget mauris maximus eleifend. Pellentesque porttitor tellus ut ex hendrerit vehicula. Nullam id faucibus dolor, at mollis nunc. Cras ac malesuada risus, quis luctus mi. In efficitur condimentum molestie. Nunc hendrerit, velit id sodales ultrices, lacus felis tempor lacus, sed auctor lorem nisl at ex. Vivamus vitae augue aliquet, suscipit neque id, venenatis sapien. Etiam id facilisis nibh. + +Mauris quis nulla eu nibh tincidunt mollis ut ac justo. Nullam semper dapibus turpis a euismod. Aenean pulvinar vestibulum odio, sed vehicula mauris euismod et. Cras consequat varius maximus. Aliquam malesuada aliquam arcu, quis tristique arcu egestas et. Aenean consectetur, nulla vel feugiat ultricies, ante nibh vehicula ante, a mattis mauris nibh sit amet leo. Sed nec turpis sem. + +Integer sed pharetra mi. Duis gravida, odio quis posuere tincidunt, tellus nibh fermentum ex, vitae viverra nibh lacus ac lorem. Vivamus viverra pharetra congue. Mauris vestibulum venenatis libero eget tempor. Donec et imperdiet lacus. Nam sed porttitor arcu. Etiam aliquet, est non posuere ullamcorper, ligula dui eleifend urna, sit amet posuere nisi nibh at elit. Nulla facilisi. Integer tempus diam augue. Quisque ullamcorper, tortor vel egestas sagittis, purus tellus tempor velit, sed tempor ipsum lacus ac turpis. + +Donec eget justo lobortis, pulvinar elit at, auctor velit. Cras porttitor fermentum consequat. Suspendisse et vestibulum elit. Etiam ut libero et odio mattis commodo. Vestibulum finibus quis nisl in hendrerit. Fusce in nisl turpis. Praesent sodales faucibus turpis, a accumsan purus rhoncus lobortis. Cras sit amet porta sapien. Donec arcu libero, varius eget odio sit amet, ultrices viverra enim. + +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam nec ante sit amet est lacinia ultrices. Duis facilisis molestie mollis. Ut consequat iaculis purus eu dapibus. Nulla tempus felis tellus, id congue velit tincidunt vitae. In vehicula viverra lectus et convallis. Donec hendrerit urna sit amet orci tempor finibus. Aenean laoreet justo aliquet, elementum orci eget, convallis mi. + +Nullam nec lectus quam. Aliquam egestas sapien et venenatis dignissim. Ut malesuada ante nisl, a tincidunt leo maximus a. Pellentesque iaculis nisi et porta tempus. Proin luctus nulla a urna ultricies, vitae laoreet magna scelerisque. Nam feugiat posuere enim non venenatis. Nulla rhoncus sapien a eleifend blandit. Cras pretium, dolor vitae ornare vulputate, velit magna laoreet ante, sit amet rhoncus sem magna quis lacus. Morbi auctor placerat neque nec tincidunt. Praesent tempus, tellus eu sollicitudin hendrerit, augue enim facilisis arcu, eget efficitur leo mauris a tortor. Donec pellentesque nibh vel velit scelerisque ornare. + +Nulla dui sem, convallis nec ante nec, pellentesque imperdiet nisi. Nunc molestie iaculis leo nec finibus. Pellentesque a luctus erat. Curabitur sed nulla vulputate, consequat enim id, pulvinar arcu. Proin porttitor ex lacus, sit amet viverra lectus finibus ac. Ut cursus congue laoreet. Integer imperdiet leo nec elit ultrices, at imperdiet nisl bibendum. Suspendisse suscipit leo ac dolor lobortis sagittis. Vivamus ullamcorper dictum eros, convallis aliquam dolor hendrerit et. Donec malesuada rhoncus pharetra. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus pretium, neque nec dictum tristique, lacus nibh tempor ligula, vitae ultricies metus elit eget felis. Duis quis mattis sem. Praesent eget nibh ut tellus pretium efficitur ac ut magna. Nam urna urna, vehicula in felis id, luctus sollicitudin ligula. + +Vestibulum aliquet, ligula id eleifend ultricies, sapien leo venenatis dolor, a pretium erat metus non lacus. In hac habitasse platea dictumst. Maecenas congue magna augue, nec sodales est feugiat a. Proin semper sodales placerat. Ut malesuada ante ut justo scelerisque semper. Nulla facilisi. Donec ac leo mauris. Integer cursus tortor eget velit lobortis dapibus. Aliquam euismod fringilla enim, ac porta tellus lacinia non. Nunc iaculis ante sit amet tortor dapibus, lobortis ultrices leo maximus. In congue lacus at odio semper, placerat dignissim ligula dapibus. Pellentesque ullamcorper nec nunc quis malesuada. Sed convallis rutrum porttitor. Mauris egestas quis ligula sit amet aliquam. Praesent eget tristique ante. Proin tristique lacus vitae ante tincidunt, eget pellentesque sem tincidunt. + +Ut a est rutrum, accumsan lorem id, ultrices eros. Duis posuere aliquet purus, id vestibulum mauris. Aenean vehicula, metus nec tristique convallis, eros elit congue ante, ut imperdiet ipsum turpis quis tortor. Pellentesque id dictum felis. In hac habitasse platea dictumst. Quisque non risus odio. Nullam aliquet tellus quis purus pharetra volutpat. Morbi accumsan diam lectus, ut rhoncus lectus dictum ac. Praesent ligula massa, condimentum sit amet pretium id, elementum ac arcu. Nam pulvinar sed nisl in lacinia. Nulla sit amet sapien nec ligula efficitur tristique quis sit amet metus. Pellentesque nisi enim, elementum ac massa sed, ultrices ornare lacus. Etiam auctor tellus quis erat maximus, nec faucibus neque maximus. Nullam tempor nunc sed felis accumsan dictum. Curabitur ut eros tellus. + +Aliquam eget facilisis lacus, ac ornare mi. Nam rutrum libero in est pulvinar sollicitudin. Etiam egestas pharetra magna. Aliquam volutpat, felis a condimentum consequat, tellus nisl lacinia leo, non interdum justo lectus eget est. Integer euismod lacus id ipsum tempor, non condimentum libero sodales. Phasellus sagittis sed ex a pellentesque. Vivamus luctus feugiat massa, sit amet tincidunt enim. Phasellus justo sem, eleifend a convallis ut, feugiat vel lectus. Duis bibendum nunc a commodo dictum. Proin eu purus nisi. Phasellus non semper odio. Suspendisse lectus urna, porttitor sed auctor et, dictum et nunc. Etiam laoreet mollis ante quis porta. Aenean eleifend, dolor ac dictum aliquet, risus lectus hendrerit nunc, eu rhoncus lorem magna non mauris. Quisque elementum, orci et posuere blandit, arcu quam rhoncus est, sit amet eleifend massa felis non urna. Praesent quis neque tristique, finibus dolor nec, laoreet metus. + +Donec convallis leo vitae odio scelerisque, at pharetra turpis viverra. Sed id dui id arcu fermentum finibus eu eu ex. Curabitur at pretium elit. Fusce hendrerit mi in urna sollicitudin, ac rhoncus mauris mattis. Pellentesque cursus turpis ligula, in fringilla nisl viverra at. In condimentum sit amet felis in luctus. Etiam tincidunt odio et justo lacinia, et vehicula elit lobortis. Phasellus volutpat finibus magna, a porttitor nisl tincidunt in. Pellentesque et orci vel lorem efficitur dignissim nec nec magna. Duis at orci id tortor condimentum pulvinar vitae vel massa. Pellentesque tincidunt mauris quam, ac dignissim sapien condimentum eget. Fusce accumsan nisl lorem, eget luctus tortor accumsan eget. Quisque ultrices eget dui vitae convallis. Phasellus consequat velit non lorem efficitur, id porttitor ante lacinia. Vestibulum ac nibh at orci rutrum placerat id et lorem. + +Nam finibus ullamcorper nibh, scelerisque luctus leo ultricies et. Donec id lectus ligula. Aenean sed egestas nulla. Integer sed velit tristique, euismod massa id, sollicitudin ligula. Donec urna sapien, blandit at lorem sit amet, semper molestie leo. Sed lorem urna, luctus dictum pharetra sit amet, tempor et mauris. Nulla in efficitur lorem, at tempus leo. Ut ullamcorper tortor ex, a accumsan metus consequat ut. Nunc nec dolor vel quam fermentum interdum eu quis enim. Phasellus pulvinar lacus et mi molestie dapibus. Curabitur dolor quam, mattis ac augue non, tincidunt ultrices arcu. Praesent tempor sem ac mi luctus pellentesque. Ut luctus tincidunt tellus, a rutrum nulla maximus porttitor. Nulla eget dapibus ligula, ut sodales diam. Vivamus dapibus dictum lorem, sit amet scelerisque est laoreet vitae. + +Vivamus accumsan rhoncus est non congue. Nam lacus nisi, vulputate eget tincidunt imperdiet, sagittis id orci. Donec eleifend lectus eu blandit vulputate. Integer accumsan risus lacus, vitae rhoncus justo pretium vitae. Integer varius nec augue sit amet volutpat. Phasellus interdum, erat sit amet vehicula consectetur, odio dui tincidunt quam, vitae egestas ligula risus quis velit. Proin facilisis nulla quis sodales vestibulum. Curabitur sagittis tortor vel massa fermentum, sed gravida quam tincidunt. Etiam pulvinar, felis id tincidunt euismod, est arcu viverra nunc, vitae viverra nibh enim vel orci. Mauris porta eros vel hendrerit tincidunt. + +Duis maximus id eros vitae blandit. Etiam porttitor nisl quam, non consectetur odio molestie non. Morbi vel condimentum lacus. Sed ut ipsum nisi. Cras congue justo eu laoreet volutpat. Fusce euismod elit aliquam libero luctus, ac accumsan mauris ultrices. Praesent augue nisl, facilisis a pulvinar sit amet, mollis sit amet quam. Maecenas elementum eleifend mattis. + +In vitae pharetra turpis. Integer in massa tincidunt, maximus elit sed, varius massa. Curabitur id sodales sem. Aenean nulla nunc, tincidunt et scelerisque ut, imperdiet in diam. Donec laoreet nibh arcu, ac ullamcorper ante porttitor a. Nunc facilisis turpis sed sollicitudin bibendum. Duis sagittis odio ipsum, quis pharetra dolor maximus nec. Phasellus non laoreet massa, et imperdiet sapien. Curabitur enim diam, euismod eu porttitor eget, tristique ut urna. + +Fusce finibus quis massa maximus vehicula. Sed fringilla sodales risus, ullamcorper laoreet odio tincidunt eu. Nullam maximus, nisi eu porta consequat, ligula tortor volutpat enim, quis scelerisque dolor sapien a orci. Mauris nibh urna, faucibus nec accumsan nec, sagittis eget metus. Curabitur vel tortor leo. Integer enim quam, convallis ut orci nec, mollis pretium nunc. Aenean vel ante nibh. Nam purus arcu, finibus et tempor non, volutpat vel purus. Aliquam vitae nisl id sem eleifend bibendum et quis mi. Duis porttitor malesuada aliquam. Maecenas varius interdum nunc eget cursus. Suspendisse potenti. + +Nullam tellus nisi, ullamcorper sed odio a, pulvinar lobortis ligula. Aliquam posuere lectus a ex pellentesque, in porttitor justo sodales. Sed non quam in dui ultrices scelerisque non nec tortor. Donec eu pellentesque sapien, sagittis tempor est. Cras scelerisque nisi nunc, in fringilla dui cursus eu. Aenean pretium euismod nisi ut tincidunt. Proin porta velit eget nisi volutpat viverra. Donec mi leo, sodales in tristique id, sollicitudin quis augue. In hac habitasse platea dictumst. Sed ante lectus, dictum vitae ex volutpat, fringilla rutrum leo. Ut leo augue, facilisis tempor magna quis, tempor volutpat neque. Suspendisse eu mi a mauris fringilla aliquet nec vel urna. Phasellus tempor pharetra magna, ut faucibus sem ultricies eget. Donec eleifend ipsum eget eros semper, in efficitur mauris pulvinar. + +Aliquam bibendum ligula eu vestibulum volutpat. Sed nunc massa, convallis vitae condimentum ut, euismod eleifend leo. Phasellus congue at magna convallis lobortis. Integer pretium, ex et porta tincidunt, leo mauris sodales mauris, sit amet blandit nisl enim vel quam. Duis bibendum, leo sed dapibus sollicitudin, orci mauris sagittis felis, a varius elit nulla eget mauris. Aenean massa est, convallis ac commodo sit amet, feugiat id nisi. Nulla facilisi. Quisque a purus et magna gravida egestas quis id libero. + +Maecenas id vulputate risus. Ut tempus in ipsum sit amet varius. Sed euismod, est eu dignissim hendrerit, erat dui placerat dui, non consectetur lectus tellus a ligula. Aliquam vel enim leo. Donec vitae purus purus. Nullam rhoncus risus id sollicitudin vehicula. Sed eu pharetra ligula. Vestibulum eu venenatis nunc. Sed ut nulla euismod, dignissim justo et, posuere ipsum. Pellentesque viverra tortor nec justo aliquet interdum. Vivamus vulputate at tortor sit amet tempor. Aenean consequat pretium risus, sit amet ornare est tempor sit amet. Nulla erat lorem, sodales ac eros eu, luctus lacinia lectus. + +Morbi tempus libero ac tellus congue hendrerit. Nunc odio est, mollis eu risus a, ultricies laoreet orci. Cras lacus mauris, vehicula eget tortor et, finibus aliquam mauris. Fusce pretium in felis ac ornare. Nunc sem velit, mattis et odio a, efficitur dictum sem. Aenean dapibus pulvinar massa eu pretium. Phasellus imperdiet eu libero quis ullamcorper. Nunc id mi suscipit, varius neque in, elementum dui. Proin semper, eros ut pulvinar ultricies, tellus lacus congue nibh, a rhoncus libero lectus sit amet eros. Ut nec blandit lacus. Nulla facilisi. Integer nec placerat orci. Maecenas sapien diam, pellentesque sit amet ultrices vitae, fringilla dictum sem. Nulla rhoncus blandit bibendum. Proin quam tortor, pellentesque in vestibulum et, imperdiet ac est. + +Sed nec nisl purus. Fusce urna augue, suscipit sed finibus vel, fermentum et ex. Cras ullamcorper sapien nec lacus vulputate interdum. In hac habitasse platea dictumst. Aliquam erat volutpat. Sed hendrerit felis at risus semper vulputate. Nulla placerat eget quam non varius. Integer in venenatis purus, vel tristique leo. In tempus ex sed libero mattis, vel tempus metus vulputate. Etiam imperdiet augue vitae tincidunt varius. Phasellus sit amet elit bibendum, dapibus ante vel, efficitur tortor. Nulla tempus, dui a sollicitudin sollicitudin, augue urna hendrerit dolor, pharetra tincidunt tellus turpis vel libero. Duis quis velit at elit sodales bibendum sed vel libero. + +Phasellus eu eleifend nisi. Sed consequat quis felis id egestas. Pellentesque libero mauris, ullamcorper vitae porttitor quis, pharetra eu ipsum. Fusce at viverra lacus. Mauris lobortis elit vel urna pulvinar lacinia. Quisque laoreet magna sit amet nulla luctus, a consequat nulla viverra. Sed gravida sit amet orci at pharetra. Duis vitae massa congue nunc dapibus facilisis. Nulla facilisi. Aenean eget blandit est. Pellentesque sapien tortor, tempor sed faucibus nec, pharetra at tortor. Pellentesque ultrices pellentesque molestie. Pellentesque elementum nibh id pulvinar commodo. + +Etiam eu fringilla nunc, eget semper purus. Vestibulum faucibus placerat ante, nec ullamcorper purus ultricies eu. Fusce quis commodo erat, id tempus massa. Aenean non libero eget mauris venenatis finibus. Donec commodo eu erat id mattis. Praesent volutpat purus nunc. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Donec porta, neque et iaculis maximus, turpis erat aliquam mauris, quis posuere mi lectus vitae ligula. Suspendisse malesuada dui in magna facilisis rhoncus eu sed dolor. Duis consequat libero at consequat semper. Ut ante diam, pretium a enim non, ullamcorper sodales augue. Donec eget volutpat quam. + +Nulla sollicitudin metus vitae magna elementum, rutrum auctor ipsum aliquam. Nam aliquet elementum lobortis. Mauris pellentesque sapien a odio aliquam ultricies. Aliquam sed turpis pellentesque lectus sollicitudin aliquam vel sed sem. Quisque in sodales sapien. Mauris est orci, tincidunt non tellus faucibus, faucibus varius turpis. Nunc lacinia risus et libero vehicula hendrerit. Mauris in pellentesque urna, sed lobortis nunc. Cras tincidunt varius elit, eu vestibulum sapien blandit eget. Pellentesque tincidunt elit sapien, at faucibus sapien lobortis ut. Donec rhoncus, purus ut vulputate laoreet, nibh eros bibendum leo, a volutpat erat felis sed lectus. Pellentesque eget sapien mi. Cras at mauris sit amet est pharetra porttitor. Proin pellentesque sollicitudin tortor nec sollicitudin. + +Mauris accumsan sagittis mattis. Aenean commodo suscipit auctor. Ut vel risus sagittis, efficitur nunc a, maximus nisi. Vestibulum eget ex sollicitudin, elementum elit eget, aliquet orci. Sed a odio nec sem tempor vulputate a mattis nisl. Maecenas odio felis, convallis eget dolor eu, scelerisque maximus lectus. Aliquam convallis enim nec ante rutrum, at volutpat est faucibus. Donec vitae leo finibus, efficitur risus et, convallis est. + +Ut at eleifend erat, ac consequat ex. Nullam et libero ut enim interdum lacinia vitae at nunc. Curabitur ut gravida tellus, a commodo tortor. Aliquam accumsan, sem sit amet vulputate bibendum, odio ex luctus enim, ut laoreet arcu justo ac elit. Integer ornare ante ligula, sit amet elementum enim cursus et. Aenean imperdiet molestie enim ut elementum. Nulla pellentesque sollicitudin ligula ut dapibus. Cras ultricies rhoncus ante, a blandit purus vehicula fermentum. + +Curabitur vel sapien quis lorem gravida ultrices in id arcu. Integer vestibulum mi non metus rhoncus auctor. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas et accumsan ligula. Aliquam dignissim auctor diam, vitae sagittis enim tempor ornare. Curabitur vitae elit ut lectus egestas aliquet. Morbi interdum nisl a aliquam mattis. Morbi sit amet congue risus. + +Nulla venenatis ultrices turpis quis tincidunt. Curabitur eget vestibulum massa. Nullam id dolor mattis, elementum mauris vel, aliquam nulla. Proin mattis turpis in nisl scelerisque, eu rutrum ipsum ultrices. Mauris sodales viverra sem eget finibus. Cras luctus et neque et condimentum. Suspendisse leo erat, tincidunt sed venenatis vitae, gravida ac purus. + +Cras commodo tempor metus, et pharetra orci euismod vitae. Aliquam maximus posuere quam ut fermentum. Vestibulum aliquam lectus in posuere fringilla. Sed accumsan orci felis, nec mollis dolor luctus sit amet. Nunc eros ipsum, eleifend ut lectus at, facilisis vulputate lacus. Nunc eu ultricies tellus. Vestibulum scelerisque vulputate ante, id efficitur mi blandit facilisis. Aliquam sodales metus ut neque semper, vestibulum molestie erat venenatis. Fusce vitae odio dolor. Nullam consectetur tincidunt eleifend. Sed eu mauris rutrum, ornare urna at, iaculis leo. Nunc interdum porttitor quam a elementum. Proin quis dui placerat, vulputate dolor ac, auctor est. Vivamus fermentum facilisis libero ut tincidunt. Sed sed lacinia tellus. + +Sed nec nisl sit amet purus posuere semper. Duis id dui lectus. Aenean porta sodales quam eget tempus. Sed id magna ac justo placerat lacinia. Suspendisse at venenatis justo. Proin vitae ipsum gravida tortor auctor dictum. Ut et purus rhoncus, auctor lorem quis, auctor nulla. Nullam hendrerit porta ex, sit amet dapibus justo condimentum et. Phasellus condimentum accumsan ex, nec sodales diam varius at. Vestibulum elementum gravida turpis sagittis fringilla. + +Integer vitae purus mauris. Sed in rhoncus enim. Pellentesque a maximus lacus. Suspendisse rhoncus est est, ut consequat nisi bibendum a. Quisque accumsan id leo ornare convallis. Donec eu iaculis orci, in lacinia mi. Donec a tincidunt augue. Mauris maximus fermentum mi, eu commodo sapien fringilla blandit. + +Nam feugiat mi vel gravida tincidunt. Vivamus posuere blandit tortor, quis egestas magna consectetur sed. Aliquam nec ipsum ac purus tempus cursus finibus ut odio. Ut ut turpis vel risus mattis rutrum consectetur ac metus. Mauris et pellentesque tellus, sit amet convallis metus. Sed id tempor tellus. Duis congue neque arcu, eu commodo velit tincidunt at. Cras non elit quis nulla lacinia laoreet in et purus. Donec id sapien quam. Nulla rhoncus sem at risus tristique, in pretium velit laoreet. Mauris vitae quam id ipsum euismod aliquet. Sed consectetur, ante quis elementum pulvinar, mauris nisi consequat sapien, gravida ultricies justo diam id turpis. Fusce nec fermentum erat. Sed nec facilisis ex. + +Etiam in magna leo. Aliquam dictum nisl sed laoreet aliquet. Donec tempus vitae lectus quis imperdiet. Nunc euismod tortor massa, eget dignissim augue maximus ac. Morbi sit amet lorem turpis. In maximus fringilla orci, sed dictum diam ullamcorper semper. In mollis malesuada diam at mollis. Vivamus ornare nulla enim, quis tempor ligula dapibus laoreet. + +Aenean blandit nisl at ligula feugiat fermentum. Cras gravida rutrum nulla nec ullamcorper. Duis gravida nisl felis, a suscipit nisl blandit a. Quisque varius ullamcorper velit, id tempor ipsum euismod nec. Suspendisse vitae condimentum turpis. Nunc vitae semper risus. Nunc sem justo, interdum in est at, vestibulum tincidunt est. Sed eget lectus non massa laoreet pulvinar. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aliquam dolor dolor, blandit eget porta quis, porta non nisl. + +Quisque mollis faucibus orci, in malesuada enim tincidunt vel. Nulla augue leo, tristique sit amet pulvinar sed, ornare sed tellus. Quisque ac purus lacus. Nunc pretium malesuada pretium. Donec finibus tellus nec arcu vulputate, ut vestibulum nunc vulputate. In hac habitasse platea dictumst. Curabitur viverra condimentum pulvinar. Nam vehicula, nunc sed tincidunt tempor, felis ex tincidunt neque, ac malesuada nibh eros eu magna. + +Nullam ac iaculis diam. Quisque dignissim orci quis orci volutpat, at ultricies leo malesuada. Nam faucibus risus et tincidunt sollicitudin. Morbi pellentesque odio vitae dignissim consequat. Morbi mollis lorem in lectus iaculis pharetra. Cras laoreet aliquet eleifend. Vestibulum et libero sodales, congue ante vel, varius sem. Praesent aliquet facilisis enim ut luctus. Mauris vulputate tincidunt nibh, eget ultrices urna lobortis non. Nulla congue eu velit eget porta. Maecenas aliquam urna at varius pretium. Aenean commodo, diam id varius efficitur, dui magna congue leo, id dignissim est ligula in leo. + +Nunc ex magna, tristique non tincidunt vel, placerat a tortor. Vestibulum lorem quam, finibus a libero ut, porta ultricies urna. Proin tincidunt lacus dui, nec imperdiet eros ornare non. Proin vitae elit purus. Aliquam in ultrices eros, pretium dictum urna. Sed eu lorem lorem. Curabitur posuere, ante vel elementum tristique, tellus ipsum pharetra massa, laoreet feugiat neque felis non sapien. Sed tristique diam at sem pretium, ac dictum enim varius. Maecenas quis eleifend quam. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent sit amet commodo nunc. Etiam in orci a nunc ullamcorper laoreet suscipit a nulla. Duis sed nisl risus. Suspendisse ultricies mollis velit nec pellentesque. Suspendisse ornare sed tortor sed facilisis. + +Aenean sit amet metus euismod justo tincidunt pretium. Phasellus consequat ultricies elit et lacinia. Etiam fringilla turpis sit amet metus aliquet commodo. Aenean sagittis, nibh a pretium varius, nunc mauris mollis lorem, et rhoncus velit nulla at erat. Sed id pharetra eros, ac pretium enim. Nam non accumsan nibh. Quisque consectetur tempor ipsum, non mattis sem bibendum eget. Aenean gravida in lacus imperdiet feugiat. Nulla mi tortor, molestie et pretium elementum, bibendum tincidunt quam. Integer sit amet mi ut nulla sollicitudin bibendum ut quis velit. Sed et faucibus leo, tempor auctor lectus. Nam non lorem ante. Duis eu justo sodales nibh interdum aliquam. Morbi varius ultrices aliquam. Nullam commodo lorem ut semper scelerisque. Vivamus at nibh egestas lectus aliquam bibendum. + +Suspendisse sit amet velit pulvinar, mollis turpis id, placerat nibh. Donec at malesuada arcu. Vestibulum accumsan quam vitae laoreet aliquet. Maecenas semper ornare bibendum. Pellentesque id luctus augue, ac gravida diam. Curabitur ut nunc nec metus tristique pellentesque quis nec ligula. Sed facilisis, risus eget mollis fermentum, nunc tellus placerat turpis, sed consectetur nibh nisi ut quam. Suspendisse luctus consectetur ex sit amet scelerisque. Etiam in ex ac orci imperdiet rhoncus. Integer sit amet ipsum nec dui mollis auctor. In in commodo ante. Etiam suscipit dapibus tincidunt. + +Vivamus ut condimentum sem, sit amet viverra est. Mauris sollicitudin arcu risus, in feugiat neque egestas nec. Quisque vehicula orci a justo tempus, sit amet tincidunt dui placerat. Ut fringilla sollicitudin urna, et consectetur risus laoreet nec. Etiam id pharetra ipsum. Nullam venenatis est diam, vitae vestibulum ipsum ultrices sed. Aenean commodo ipsum blandit metus pulvinar, at aliquet urna suscipit. Pellentesque luctus dapibus sem, eleifend ultricies lectus sodales ac. Nullam tincidunt nisi nibh, in blandit dui pharetra sit amet. Pellentesque vehicula, elit ut eleifend lobortis, justo ipsum fringilla tellus, imperdiet mattis magna purus vitae lacus. Nam faucibus, diam ac sagittis laoreet, odio ligula gravida nunc, sed volutpat sem turpis quis sapien. Sed imperdiet massa nec porta condimentum. Aliquam erat volutpat. + +Nunc in odio a tortor interdum dictum. Aliquam vitae leo non quam faucibus volutpat vel ut ante. Nullam maximus diam sed mi malesuada congue. Interdum et malesuada fames ac ante ipsum primis in faucibus. Proin luctus, mauris nec consectetur feugiat, velit felis sollicitudin quam, sed condimentum odio lacus in enim. Ut ut leo a mi maximus sollicitudin. In dolor urna, tincidunt vitae commodo ut, dictum eget elit. Phasellus pulvinar justo quis lorem fermentum ultrices. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nulla molestie malesuada mauris. Nam in purus nisl. Quisque urna nibh, tincidunt quis nibh vitae, ultrices auctor ipsum. Praesent porttitor a neque at gravida. + +Aenean neque risus, molestie eget consequat ut, luctus at sapien. Ut auctor, massa et euismod sollicitudin, ipsum massa dapibus ipsum, quis placerat erat est sit amet ante. Cras non luctus purus. Vivamus sed mi ac dolor scelerisque semper in eu odio. Pellentesque quis neque vel ipsum blandit finibus. Ut in porttitor lorem, sed lacinia dui. Sed sodales sed magna non cursus. Donec non metus dapibus, iaculis odio sit amet, hendrerit nisi. + +Fusce porta nulla non egestas euismod. Curabitur mollis, libero lobortis suscipit tempor, tellus tortor eleifend ante, a pharetra quam erat fringilla quam. Nam ac mi id ligula commodo molestie. Aliquam tempus sem vitae arcu elementum laoreet. Suspendisse elit turpis, cursus vel fermentum imperdiet, lacinia vitae leo. In a orci sed dui posuere feugiat at non mi. Nam maximus mattis nisi, at congue augue aliquam id. Donec quis risus at est luctus hendrerit. Aenean in quam condimentum, vehicula odio non, pretium lacus. Vivamus ultricies lacinia vestibulum. Ut velit purus, venenatis a pharetra vel, auctor nec elit. Phasellus consequat malesuada ligula, in iaculis ante. + +Aenean quis tempus ipsum, sit amet molestie lacus. Duis gravida, dui blandit finibus interdum, turpis nulla imperdiet enim, nec sagittis ante massa in est. Fusce ultrices enim sed leo ornare consectetur. Nullam porttitor nulla vel dui viverra, sit amet aliquam nibh porta. Donec ipsum enim, tincidunt at sapien eu, gravida fermentum quam. Donec vehicula, turpis vel aliquam feugiat, metus velit luctus sem, et dictum risus eros quis nulla. In tempus lacus est, quis fringilla ligula laoreet eu. Aliquam risus neque, malesuada et porta at, tincidunt sit amet enim. Sed faucibus, nulla eu tempor posuere, ex dui blandit nibh, ut maximus enim turpis pretium lectus. In et tincidunt nisi, a elementum tellus. Donec id aliquam risus. Morbi id urna a ipsum imperdiet elementum at et metus. Vivamus nec leo mauris. Suspendisse odio lacus, convallis non auctor at, malesuada a massa. Ut auctor ultrices aliquet. Donec faucibus sit amet nulla ac maximus. + +Morbi condimentum enim in sollicitudin interdum. Pellentesque eget ligula id est commodo euismod. Nullam lectus leo, scelerisque rhoncus tempus a, placerat ut nisl. Aliquam ullamcorper pulvinar mauris. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Fusce varius in est ac tristique. Cras luctus a nibh in faucibus. Curabitur efficitur mollis ipsum, ac eleifend risus. Fusce iaculis aliquam diam iaculis blandit. Fusce libero lectus, aliquet ut faucibus id, consequat in erat. Suspendisse eu feugiat est. Aenean sed elit in massa dapibus consectetur. Pellentesque faucibus viverra justo, ut ultrices lorem commodo nec. Curabitur sed volutpat libero. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. + +Maecenas volutpat tempus arcu, ac eleifend est scelerisque nec. Sed a lacus nibh. Quisque ultrices ipsum diam, sed semper tortor egestas id. In posuere lorem sed libero eleifend, ac maximus lacus tempus. Proin vel aliquet nisl. Etiam vulputate nisi lectus, eget lacinia quam blandit id. Ut sollicitudin mauris quis risus laoreet aliquam. Quisque pretium dui quis enim finibus, ut eleifend ante tincidunt. Nullam dui odio, tristique iaculis ante et, placerat finibus tellus. Sed leo est, fermentum eu accumsan eu, cursus ut est. Etiam dictum elit est, eu sollicitudin dolor bibendum eu. + +Aliquam consequat magna et justo egestas, ac aliquam lectus volutpat. Ut nec aliquam lorem. Proin volutpat enim tortor, ac commodo ante congue sit amet. Suspendisse vestibulum nibh sed sem tristique maximus. Curabitur in urna id magna viverra semper id sed neque. Cras tincidunt, massa quis porttitor laoreet, enim metus molestie purus, et pharetra nisi felis eu ex. Vestibulum porttitor semper erat, at lacinia purus vehicula et. Phasellus molestie erat nec tincidunt dignissim. In varius, est ac elementum suscipit, augue leo vestibulum turpis, in consequat velit lectus ac quam. Duis quis varius orci. Nunc vulputate nunc augue, eget mattis massa faucibus dignissim. Donec at nulla at est ultricies fermentum. Aliquam gravida eros ut efficitur congue. Sed neque tortor, consequat id egestas quis, ultrices a purus. + +Donec id dolor quis elit venenatis rhoncus nec vitae erat. Donec quis dolor condimentum, condimentum velit vel, pulvinar arcu. Praesent ut accumsan tellus. Fusce dictum pretium enim, sit amet maximus purus pulvinar non. Sed ante nulla, interdum eu mauris in, tincidunt cursus massa. Mauris condimentum felis id varius varius. Sed venenatis elit ullamcorper semper facilisis. Curabitur gravida, erat quis egestas vehicula, nulla lorem aliquet ipsum, sed euismod augue nisl id erat. Mauris ut odio erat. Integer pretium sem quam, eu porta felis tempus id. Ut tincidunt, sapien ac ultrices faucibus, mi lacus vestibulum nulla, sit amet volutpat massa ante sed risus. + +Nulla tempor porttitor ex ac sagittis. Cras non bibendum lectus. Vivamus eget finibus lorem. Nullam ornare tincidunt velit at semper. Cras imperdiet ipsum tincidunt, auctor ante sed, ultricies lectus. Cras mattis tincidunt odio, eu gravida erat. Nunc varius, nisi id posuere accumsan, tortor augue dapibus lacus, et finibus sem ex ut nisi. Morbi a nunc ex. Fusce neque elit, mattis ac erat bibendum, scelerisque ullamcorper mi. Mauris euismod eleifend interdum. Aenean nec nulla efficitur, hendrerit felis quis, posuere lacus. + +Etiam imperdiet augue egestas sollicitudin mollis. Curabitur blandit est id vestibulum mollis. Etiam eget nulla a enim lobortis lobortis. Morbi sodales quis lectus sit amet auctor. Curabitur eleifend vestibulum pharetra. Suspendisse convallis sed tellus sed blandit. Quisque vitae nulla vel arcu ullamcorper finibus. Nulla vehicula, metus in imperdiet finibus, tortor arcu fringilla magna, quis mattis risus magna vel diam. Cras faucibus dapibus ante, non blandit purus semper nec. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Integer est felis, ultricies quis mi ac, feugiat gravida magna. + +Ut porta elit est, id euismod magna malesuada id. Nam non dui leo. Integer a ligula a nibh consequat cursus. Nulla facilisis semper mauris vel consectetur. Sed augue tellus, luctus porttitor metus et, sodales auctor justo. Sed euismod varius nisl, eu placerat massa lobortis at. Aenean fermentum consectetur quam, id dapibus nibh interdum vitae. Aenean ut dui mollis, lobortis nisi non, dictum odio. Sed mattis ante vitae dictum gravida. In pulvinar consectetur egestas. Sed et pulvinar mi. Aenean id orci leo. Integer consectetur dolor quis libero pellentesque, in tristique massa elementum. Sed a dui pellentesque, molestie magna dapibus, consequat diam. Etiam mattis viverra felis. + +Nunc id urna vestibulum, rutrum ex iaculis, consequat risus. Etiam id rhoncus lectus. Fusce efficitur consequat urna sit amet sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Vestibulum pellentesque turpis tempor, condimentum augue id, gravida velit. Aenean pulvinar, nulla rutrum elementum tristique, nisl dui pellentesque nisl, a maximus augue augue ut massa. Morbi cursus enim ante, in porta nunc fermentum ut. Ut eget turpis eget ligula convallis molestie sed pharetra libero. Donec aliquet diam ut nibh accumsan, et faucibus metus eleifend. + +Nulla placerat convallis felis dictum euismod. Proin hendrerit risus quis lorem lacinia, ac bibendum sapien pellentesque. Cras quis ante tellus. Phasellus volutpat egestas malesuada. Vivamus metus risus, blandit iaculis sagittis at, posuere non magna. Cras convallis erat eget rutrum aliquam. Maecenas nec tortor sem. In hac habitasse platea dictumst. Etiam vestibulum urna in metus congue porttitor. Ut sed hendrerit arcu. Vestibulum eget pretium urna. Phasellus dictum diam est, in porta orci scelerisque nec. + +Phasellus sit amet lobortis quam. Aliquam eget faucibus mi, eget ullamcorper risus. Maecenas egestas purus quis augue semper, non imperdiet ligula ultrices. Nulla facilisi. Duis augue est, pulvinar nec libero quis, euismod pharetra urna. Fusce commodo, dolor vitae vulputate feugiat, dui nibh luctus odio, ut cursus leo eros quis neque. Donec ex odio, egestas pharetra sapien quis, posuere fringilla odio. + +Etiam eget ante blandit, gravida lorem at, dictum sem. Vestibulum est nisl, iaculis sed lacinia quis, malesuada non risus. Morbi bibendum enim velit, at malesuada dolor porttitor sit amet. Suspendisse lectus urna, aliquam imperdiet felis et, vulputate eleifend mi. Pellentesque dolor tellus, aliquet in vestibulum sit amet, pharetra quis metus. Vivamus posuere arcu eget ex imperdiet pharetra. Nunc eu massa venenatis, luctus elit eu, laoreet odio. Aliquam ut dolor velit. Fusce sapien dolor, ullamcorper id augue non, placerat lobortis dui. Donec placerat lacus at sagittis auctor. Pellentesque id finibus lacus. Integer eget neque vel nisl pharetra scelerisque a a tortor. Sed volutpat elit a velit varius sollicitudin. + +Sed vitae mauris id sem venenatis sagittis. Fusce eget tellus lobortis, rhoncus ante ut, ornare orci. Nulla elementum quam eu accumsan rhoncus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aliquam maximus malesuada vulputate. Nam nec suscipit lorem. Nunc vestibulum orci ac ex facilisis consequat. In sodales vehicula ex, quis convallis mauris rutrum eu. + +Vestibulum pulvinar dui sit amet erat ullamcorper, eu varius felis dapibus. Vestibulum quis velit tellus. Fusce eu lectus imperdiet, venenatis nulla at, scelerisque quam. Aenean eget ligula sit amet leo volutpat egestas et convallis dui. Donec et tristique ex, nec feugiat nulla. Aliquam molestie consequat ex, non pellentesque neque fringilla et. Sed euismod auctor turpis, ac consequat est. Nam venenatis, lorem sed sagittis facilisis, sem odio venenatis arcu, eget facilisis nisl lorem nec sapien. Donec vitae tortor vitae urna imperdiet sodales et sit amet magna. Vestibulum venenatis, dolor a aliquet semper, elit quam consequat lorem, ac malesuada elit felis ut dui. Cras elementum euismod nibh, eget lacinia metus tincidunt id. Quisque eget fermentum purus. Vivamus malesuada, lacus id sagittis placerat, nisi mauris elementum orci, vitae luctus quam quam at nibh. Vivamus a libero lacus. Curabitur vel ligula varius, porttitor nibh rutrum, consequat mauris. + +Fusce ut sem orci. Vivamus imperdiet efficitur libero, gravida fermentum ex. Proin in eros dictum, lobortis nunc vitae, blandit lectus. Curabitur vulputate et magna ut congue. Curabitur tincidunt tristique neque, pellentesque rhoncus neque rutrum at. Vivamus mi dolor, hendrerit in molestie varius, lobortis sit amet nisi. Cras vel urna a odio hendrerit vulputate. Quisque molestie iaculis nisl, in ultrices ante mattis quis. Nulla facilisi. + +Fusce quis ante sit amet eros tincidunt volutpat. Integer nibh tortor, malesuada eu urna et, venenatis pellentesque tellus. Vivamus eros enim, tempus eget rutrum vel, egestas ac sem. Nullam lectus diam, viverra eget purus quis, elementum mattis tellus. Nullam sit amet tortor nec nibh interdum scelerisque sit amet et leo. Pellentesque sed neque nunc. Aliquam erat volutpat. Fusce sollicitudin, lorem sit amet venenatis sollicitudin, ante velit efficitur felis, sed dictum massa massa iaculis lectus. Nunc cursus pulvinar volutpat. Maecenas justo enim, vestibulum ut hendrerit volutpat, gravida sit amet elit. Morbi et justo enim. Nullam accumsan ac leo id vulputate. Sed eget turpis at tortor euismod bibendum. + +Aliquam suscipit vel enim eu fermentum. Donec in nisl in magna sagittis blandit. In volutpat, ex ac consequat malesuada, quam dui luctus velit, vitae convallis arcu ligula vel orci. Vivamus at pharetra tortor. Integer vitae est sed diam iaculis rhoncus at quis massa. Nulla sit amet placerat odio. Curabitur ipsum ligula, efficitur non vestibulum eu, fringilla eu magna. Integer egestas feugiat pellentesque. Donec mauris urna, scelerisque eget nisi eu, interdum feugiat diam. Etiam blandit malesuada ex vel dictum. Aliquam ex diam, imperdiet ac nibh quis, accumsan iaculis orci. Quisque sed tristique nisi. Curabitur dictum odio odio, ac rhoncus nulla sollicitudin vel. Cras vel sem varius, fringilla dolor sit amet, fringilla magna. Nullam tristique et erat vitae iaculis. Fusce vitae iaculis mi, sed facilisis ligula. + +Curabitur dapibus tortor sed cursus viverra. Cras tempor ullamcorper metus ornare commodo. Praesent molestie odio eget faucibus facilisis. Maecenas consectetur tellus sed leo ultricies efficitur. Phasellus volutpat condimentum elit. Cras feugiat convallis porttitor. Praesent dui elit, pulvinar porta fringilla sit amet, ullamcorper at sem. Interdum et malesuada fames ac ante ipsum primis in faucibus. + +Duis fringilla non risus nec eleifend. Aliquam a dignissim ante. Donec lorem purus, condimentum quis scelerisque sed, hendrerit vel urna. Donec tincidunt lacinia massa sit amet pretium. Phasellus lectus enim, congue et molestie sit amet, gravida nec odio. Aenean egestas erat ipsum, vel finibus lacus malesuada in. Morbi venenatis odio libero. Interdum et malesuada fames ac ante ipsum primis in faucibus. Sed ultrices, sem vel volutpat elementum, dui ipsum bibendum nunc, eget dictum mi felis et enim. + +Sed laoreet arcu sit amet eros suscipit, ullamcorper pretium libero posuere. Duis bibendum ut nibh quis posuere. Quisque quis erat ut mauris dapibus sagittis. Phasellus malesuada consequat metus in pellentesque. Nam ac mi a libero ultrices facilisis. Morbi pellentesque mollis lacinia. Cras porttitor porttitor sapien at ultricies. Proin ut lectus eget risus dictum fringilla. + +Duis malesuada, metus quis porttitor dictum, nulla eros blandit magna, non aliquet ante lorem a tellus. Sed ullamcorper dui metus, at molestie tellus tincidunt ultricies. Cras malesuada fringilla ornare. Fusce quis cursus libero. Nulla lacinia fringilla facilisis. Mauris nec lectus nec ipsum pellentesque dignissim. Curabitur egestas aliquet justo, quis vestibulum turpis pretium vel. Fusce efficitur felis vel odio porttitor, eget dictum orci commodo. Proin in risus orci. Vivamus fermentum pretium mi non placerat. Mauris ac ultrices ligula. Morbi tincidunt tempor leo, cursus finibus leo commodo eu. Quisque quis purus bibendum, cursus sem ac, porttitor metus. Cras in sagittis ipsum. Aliquam in viverra metus. + +Donec sit amet suscipit elit. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Proin non sapien varius, condimentum ex in, fermentum turpis. Proin finibus pretium dignissim. Etiam laoreet aliquam diam vel feugiat. Suspendisse convallis rutrum egestas. Nunc dapibus purus venenatis nisl facilisis elementum. Nullam feugiat quam vel volutpat luctus. Proin dignissim ipsum dui, a gravida tortor mattis vel. + +Maecenas condimentum scelerisque orci a viverra. Ut feugiat orci mi, aliquam molestie ipsum molestie at. Sed at lobortis felis, ac porta lectus. Aenean commodo viverra urna nec fringilla. Nunc sit amet massa blandit, pretium arcu sagittis, cursus lorem. Etiam a urna a lacus pulvinar dictum. Cras sagittis ornare ex et mattis. Nunc eleifend lacus et malesuada suscipit. Fusce faucibus metus eu magna placerat, in viverra arcu cursus. Vivamus eget magna a purus egestas pharetra. Sed lobortis est purus, sed rhoncus orci scelerisque at. Integer et ex nisi. Nam hendrerit commodo tristique. Curabitur fringilla ante non leo luctus lacinia. + +Aliquam tincidunt, leo id laoreet pulvinar, neque lacus tristique mauris, et vulputate orci justo vel ex. Nulla facilisi. Vestibulum pretium purus magna, sit amet lacinia ligula volutpat sit amet. Aenean iaculis luctus dictum. Maecenas sapien elit, ullamcorper dictum ultrices non, rhoncus ut mi. Aenean elementum, nibh quis fermentum ullamcorper, mi nulla finibus libero, maximus interdum lacus velit sed justo. Proin massa magna, ullamcorper quis est sit amet, varius maximus massa. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; + +Integer vel aliquet felis. Cras eget feugiat enim. Etiam id scelerisque leo. Proin sapien lacus, aliquam eget gravida in, semper eget purus. Ut risus purus, volutpat in enim consectetur, bibendum feugiat tellus. Phasellus sed justo vel augue facilisis tristique. Nulla ultricies gravida aliquet. Praesent dictum dignissim nisi. + +Aliquam id arcu vel massa elementum tempor. Pellentesque est dolor, molestie sit amet congue ullamcorper, bibendum eget mauris. Nam eget interdum urna, elementum efficitur dui. Suspendisse non elit nec lectus facilisis consequat. Duis lobortis ac dolor eu viverra. Curabitur cursus convallis pellentesque. Sed sapien nulla, aliquam vitae lacinia eget, auctor vel libero. Mauris nec urna dictum, gravida massa a, euismod diam. Quisque mollis accumsan bibendum. Vivamus sed quam nisl. Vivamus consectetur nisl eget arcu egestas suscipit. Fusce sagittis auctor dui. + +Vestibulum eu lobortis justo, sed finibus dui. Nunc nec dolor a magna pulvinar euismod. Pellentesque eu ante non nisi gravida ultricies sit amet vitae mi. Suspendisse potenti. Fusce bibendum accumsan facilisis. Praesent eget cursus quam. Aenean mollis bibendum fermentum. Ut molestie erat sed bibendum fringilla. + +Sed non tortor congue, rhoncus dui vel, porttitor eros. Proin eget molestie metus. Suspendisse urna enim, imperdiet sed odio nec, sagittis tristique leo. Phasellus non velit mollis, tincidunt neque eget, tempor nibh. Cras sagittis justo eu commodo sollicitudin. Curabitur posuere enim a arcu sagittis, elementum imperdiet purus commodo. Duis dapibus elit diam, varius eleifend sem faucibus eu. Aliquam at nulla lacus. Suspendisse vestibulum, tellus at consectetur volutpat, odio tortor consequat tortor, at placerat erat lacus vel lectus. In suscipit eros eget interdum aliquam. Maecenas mattis, dui ac tempor elementum, turpis urna blandit ligula, eget ornare lorem nulla at leo. Nam varius quam quis iaculis dapibus. + +Proin commodo varius ipsum id laoreet. Nullam mattis, enim aliquam commodo interdum, lacus odio accumsan elit, id ultrices mauris mauris in dolor. Integer porta tellus id vulputate laoreet. Sed euismod augue felis. Vestibulum arcu orci, elementum nec faucibus non, vehicula nec velit. Nunc efficitur semper mi id congue. Nam fermentum mollis pharetra. Etiam dictum nisl vitae nisl porttitor tristique. Aliquam in elit feugiat, tempus dolor vitae, maximus ligula. Aliquam accumsan eu lorem nec elementum. Interdum et malesuada fames ac ante ipsum primis in faucibus. Suspendisse dapibus turpis ac nisl rutrum, et hendrerit neque laoreet. Nam sit amet risus tincidunt ex posuere dictum eu eget neque. Phasellus lacinia eget nisi vel pulvinar. + +Curabitur sed dui in enim imperdiet ullamcorper. Aliquam at diam odio. Donec euismod ante sit amet orci pharetra, non scelerisque nisl feugiat. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Phasellus fermentum auctor ante at rutrum. Vivamus mollis varius quam et laoreet. Etiam vel arcu a magna accumsan tempus ut sit amet metus. Praesent vel metus et risus dictum iaculis ac eu eros. Sed aliquam dolor molestie leo euismod consectetur. Nulla ullamcorper magna vitae porttitor facilisis. Cras a dui in orci eleifend tincidunt. Pellentesque placerat in augue id consequat. + +Morbi viverra odio eget eros ornare, eget scelerisque massa porta. Nam id sagittis diam. Vivamus ex nisi, faucibus dignissim tempor ac, interdum eu urna. Nulla sagittis in leo a bibendum. Aenean nisl ante, faucibus id arcu vitae, efficitur sagittis arcu. Ut et orci eget mauris rhoncus posuere. Duis lorem mauris, hendrerit ut vehicula a, malesuada a sem. + +Maecenas sed venenatis libero, vitae ornare nibh. Vestibulum eget augue dignissim, vestibulum ex quis, iaculis mauris. Phasellus volutpat, est in elementum tincidunt, erat dolor laoreet nunc, eget suscipit lacus erat vel mauris. In ultricies molestie dui eu eleifend. Fusce tristique mauris et velit facilisis, et elementum nisi fermentum. Proin at pharetra tortor. Vestibulum semper, libero eu fermentum fringilla, orci odio maximus nisi, quis dignissim est leo facilisis felis. Nunc quis eleifend est. Donec nulla orci, sollicitudin et sem sed, fermentum gravida velit. Aenean sed augue eu nisl ultricies auctor vel eget metus. Praesent semper velit sit amet risus sodales egestas ut id massa. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nulla facilisi. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Praesent sed accumsan risus. Nullam vel neque id lectus iaculis ullamcorper. + +Maecenas a dignissim sapien, sed consequat risus. Quisque nec ex sodales tortor scelerisque interdum eu ac tellus. Duis aliquam, tellus in porttitor maximus, justo nunc tincidunt ex, eu lobortis sapien ex in metus. Nunc sodales ex et libero bibendum, vitae mollis orci cursus. Phasellus dapibus, tellus non interdum maximus, leo ex venenatis ipsum, id sodales enim massa et lacus. Donec iaculis faucibus tellus, accumsan porta diam posuere at. Vivamus vitae lectus in orci sollicitudin iaculis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nullam quis lorem eget tellus porttitor sagittis vel eu leo. Nunc laoreet lectus a laoreet fermentum. Nullam nec facilisis metus. + +Nulla bibendum nunc id dignissim hendrerit. Praesent elementum et risus nec rutrum. Pellentesque mattis lacinia orci, sed tristique lacus. Donec vel mauris maximus, hendrerit eros id, ultrices eros. Fusce quis mi mollis, molestie mauris at, mattis orci. Duis ac sagittis leo. Sed fermentum euismod porta. Nulla mollis elit tellus. Vestibulum arcu ex, auctor in placerat sit amet, finibus sit amet nunc. Etiam et sagittis tortor, in aliquet ante. + +Praesent venenatis velit a velit rhoncus tristique. Sed maximus rhoncus nunc. Vivamus sed mi non est vulputate accumsan. Praesent justo enim, elementum eget elit et, vestibulum finibus augue. Ut et lorem non est mattis luctus id sit amet ex. Nam faucibus sed augue sed imperdiet. Nullam eu est porttitor velit dictum ornare. Nunc sapien augue, convallis id orci eget, pretium rutrum sapien. In ut felis ut lorem luctus ultrices. Ut malesuada vel enim ac aliquet. In consectetur tortor tempor augue dapibus tincidunt. Quisque ac quam tellus. Pellentesque laoreet lobortis diam, interdum auctor magna cursus sit amet. Suspendisse ipsum arcu, cursus eget varius a, blandit nec tellus. Nam iaculis pulvinar vehicula. + +Nunc feugiat, nulla sit amet finibus rhoncus, nisl augue iaculis turpis, eget condimentum arcu velit congue est. In semper est id augue ullamcorper condimentum. Ut semper metus id mi condimentum ultrices. Praesent sit amet mattis nisi. Proin venenatis eros nec urna malesuada aliquam sed eget augue. Ut eleifend facilisis magna, in semper est. Donec placerat congue massa in rutrum. Nullam suscipit turpis nec diam semper, quis eleifend nibh sollicitudin. Quisque eleifend, eros ut aliquam sodales, mauris eros malesuada leo, id hendrerit mi elit nec sem. Nam et molestie ipsum, ut mollis massa. Duis consectetur erat id nisi mattis, in elementum lorem facilisis. + +Sed molestie dui non nibh lobortis lobortis. Fusce fermentum laoreet condimentum. Nullam tempor pharetra aliquam. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Quisque viverra ex in magna iaculis, in sagittis libero consectetur. Nulla facilisi. Mauris et felis in sapien volutpat vulputate a et quam. Nulla eu placerat lectus. Pellentesque sed metus et libero porta viverra. Sed posuere eget turpis sed hendrerit. Nullam a libero nibh. Curabitur arcu felis, vehicula sed mattis eget, ultrices sit amet mi. Nam eget massa vel nibh vulputate semper. + +Etiam at ultrices elit. Vestibulum efficitur dignissim ipsum, quis fermentum arcu cursus sit amet. Etiam luctus, eros tincidunt blandit aliquet, velit mauris hendrerit diam, ut commodo dolor lectus in tortor. Etiam sed est gravida, eleifend erat at, tincidunt arcu. Curabitur ut eleifend arcu. Aliquam tincidunt metus eu sollicitudin rutrum. Aenean eget ipsum ante. Pellentesque mattis, massa quis laoreet volutpat, libero felis porta dui, eget placerat mi erat non metus. Nam eget ultrices augue. Pellentesque sit amet arcu dui. Cras cursus finibus sagittis. Aliquam sit amet odio eget mauris ornare pellentesque et quis velit. Nam et gravida lacus. Sed posuere felis quis mi scelerisque finibus. + +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse a placerat turpis. Aenean venenatis, metus ac sodales pulvinar, augue dolor laoreet sapien, eu condimentum leo sapien id felis. Donec tortor ligula, imperdiet vehicula nibh quis, viverra pretium augue. Nullam a purus quis nunc volutpat finibus a quis dolor. Nullam non eleifend odio, sed egestas odio. In finibus nulla eu sapien aliquet rutrum. Curabitur tristique fermentum ante eu luctus. Pellentesque vel ligula vel ex sollicitudin ultricies. Vivamus rutrum blandit erat, vel ultricies lorem faucibus faucibus. Donec congue mauris vel venenatis elementum. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; + +Maecenas faucibus quam quis convallis euismod. Donec massa arcu, maximus et arcu non, tempus feugiat sapien. Duis vel finibus turpis. Praesent vulputate mauris diam, non ultricies velit tincidunt eget. Praesent sollicitudin mauris orci, eget cursus magna lacinia eget. Sed in porttitor diam. Duis non neque pretium, bibendum ligula non, convallis turpis. Fusce porttitor ultricies ultricies. Cras sit amet dui lorem. Quisque ut massa ligula. Nullam commodo ac est sit amet ullamcorper. + +Sed maximus rhoncus rhoncus. Phasellus eget quam id lorem fermentum consequat a eget elit. Vivamus a nunc leo. Ut faucibus iaculis nibh a tempor. Nulla varius velit erat, tincidunt porttitor metus pharetra sed. Morbi vulputate tortor id mauris commodo lobortis sit amet a sapien. Quisque pharetra vestibulum turpis, vitae porta quam viverra vel. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Pellentesque at tellus venenatis, venenatis enim quis, tempor urna. Donec erat ipsum, blandit vel metus sit amet, elementum gravida purus. Ut sapien libero, eleifend vitae nibh eu, hendrerit congue dolor. In gravida blandit fringilla. Nam pellentesque rutrum ipsum, non aliquam ipsum iaculis a. Vestibulum est magna, tempor vitae augue ac, aliquet iaculis elit. Aliquam vitae porttitor ligula. + +Maecenas ac nisl maximus, interdum sem a, dignissim felis. Aenean porta pharetra nunc eu condimentum. Proin fringilla euismod risus vitae pulvinar. Curabitur sodales, lorem vitae maximus maximus, felis erat sollicitudin tellus, id rhoncus augue libero a turpis. Ut quis arcu urna. Proin rutrum semper massa, quis sagittis sapien facilisis sit amet. Fusce vitae egestas ipsum. Proin eget massa dignissim, dapibus felis venenatis, volutpat justo. Suspendisse eget cursus elit. + +Duis a erat porta, gravida enim consequat, commodo est. Donec scelerisque enim ac quam blandit, vel accumsan nulla sodales. Cras ac dictum tellus. Aenean vel metus ipsum. Aenean nec iaculis sapien. Aliquam erat libero, vehicula facilisis pulvinar id, ultrices ut est. Ut eu urna sit amet leo fermentum varius aliquam at nisi. Nunc blandit velit eget auctor hendrerit. Phasellus arcu eros, aliquet sed facilisis malesuada, placerat ornare arcu. + +Donec sit amet odio at purus varius rhoncus eu ac felis. Suspendisse cursus est sed augue euismod condimentum. Pellentesque a ex congue dui vehicula tincidunt blandit vel enim. Aliquam non enim felis. Suspendisse potenti. Aliquam erat volutpat. Maecenas auctor erat venenatis sodales sollicitudin. Donec malesuada mauris ac pulvinar commodo. Sed suscipit at sem hendrerit consequat. Duis maximus placerat aliquet. Duis ac lorem fermentum, posuere felis at, hendrerit nibh. + +Sed congue ornare diam, in blandit nisl. Nunc scelerisque ornare dignissim. Nulla risus eros, consectetur nec nibh posuere, sodales varius massa. Cras mattis rutrum nisl sit amet congue. Aliquam erat volutpat. Donec porta placerat magna at porta. Aliquam iaculis nec ante eget faucibus. Pellentesque ligula mauris, aliquet sit amet sapien at, varius volutpat dui. Phasellus venenatis arcu sit amet hendrerit ultrices. Nam sodales et lectus in eleifend. Integer lacinia, nulla ut posuere vulputate, neque arcu varius sem, vitae lobortis felis arcu rhoncus mauris. Mauris lectus urna, lacinia non sapien ac, pretium lacinia ligula. Fusce lorem mi, suscipit sit amet pharetra at, iaculis ac lorem. + +Donec laoreet tortor urna, at scelerisque risus rutrum ut. Vestibulum facilisis dignissim nibh. Cras nec libero lectus. Nunc viverra malesuada libero sed porta. Morbi sit amet enim venenatis lacus euismod varius eu tincidunt orci. Ut et dolor erat. Suspendisse consequat massa ac est condimentum, sit amet semper nisi lobortis. Vivamus eleifend egestas mi, eget vulputate purus pharetra vitae. In volutpat varius lobortis. Vestibulum suscipit aliquet tellus quis dapibus. Duis non scelerisque tellus. Nulla non luctus mauris. + +Fusce ac pellentesque mauris, nec malesuada nunc. Pellentesque eleifend diam non ex vulputate vestibulum. Cras efficitur dignissim rhoncus. Ut sit amet sapien sed ex lacinia accumsan a a sem. Etiam lacinia pulvinar erat non fringilla. Aenean imperdiet est ac nulla lobortis, quis luctus nulla molestie. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Morbi gravida turpis eu mauris pharetra, nec commodo erat placerat. In hac habitasse platea dictumst. + +In quis gravida libero. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Aenean eu ligula nec velit suscipit maximus. Phasellus tellus tortor, consectetur in lectus sit amet, cursus malesuada arcu. Ut posuere arcu ac neque fringilla scelerisque. Nunc sed aliquam erat. Mauris ligula nisi, fermentum eu libero eget, accumsan maximus quam. Nam faucibus malesuada erat a mollis. Aenean condimentum metus est. Donec tristique odio eleifend elit euismod cursus. Etiam mauris enim, cursus maximus nisi nec, varius fermentum elit. + +Quisque cursus tincidunt ullamcorper. Donec lacinia lacinia imperdiet. Sed consequat justo quam, ac volutpat erat vestibulum ut. Morbi a erat posuere, malesuada ex quis, dapibus elit. Sed varius vel lorem ac vestibulum. Vivamus quis ante sed felis malesuada rhoncus quis eget tellus. Quisque tristique tortor vitae nibh suscipit, ac pulvinar enim ultrices. Fusce ullamcorper iaculis orci, imperdiet gravida risus gravida ac. Nullam vehicula eleifend felis quis commodo. Proin eget pellentesque est. Duis turpis lacus, elementum at neque id, feugiat varius velit. Praesent finibus semper felis pellentesque ornare. + +Suspendisse commodo, diam a euismod finibus, nisi leo ornare turpis, ut venenatis sapien ante non quam. In gravida condimentum ipsum eu sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Integer a diam sit amet risus tristique posuere. Suspendisse nec lectus finibus, feugiat arcu id, hendrerit sapien. Duis volutpat, felis eget porttitor sollicitudin, quam ante faucibus augue, nec consectetur eros quam nec lectus. Donec sit amet leo pulvinar, mollis quam vitae, hendrerit ipsum. Integer suscipit, leo ac ultricies aliquet, purus justo pulvinar purus, et sollicitudin neque urna id purus. Nam non bibendum enim. Proin rhoncus, augue et feugiat fermentum, magna dolor sollicitudin leo, vitae scelerisque justo nisi eu nibh. In hac habitasse platea dictumst. Cras quis sodales arcu, id feugiat lectus. Ut nec lectus ac purus tincidunt facilisis nec at tortor. Cras cursus lectus lorem, in vestibulum velit condimentum eget. + +Vivamus sit amet tristique leo. Sed sed mollis mi, at scelerisque eros. Quisque eu felis in nunc porta lacinia eget sit amet arcu. Vestibulum accumsan ex justo, quis luctus turpis consequat sit amet. Aenean vestibulum ligula id orci finibus gravida. Quisque vel tristique velit. Mauris quam nisi, molestie in felis ut, mattis congue est. Suspendisse ut convallis orci, eget auctor elit. Vivamus a commodo velit. Aenean ex nisl, mollis eget congue quis, condimentum a ligula. Phasellus consectetur, felis id sollicitudin ultricies, erat nibh sodales libero, ac pulvinar nisl orci et dolor. Praesent mollis eleifend enim, vitae accumsan massa tempus id. In efficitur orci at sollicitudin fringilla. Vestibulum rutrum, enim nec iaculis sollicitudin, ipsum magna volutpat purus, vel mollis felis diam vitae tellus. Nullam sagittis dolor vitae est rutrum, consectetur volutpat enim sagittis. + +Aliquam erat volutpat. In hac habitasse platea dictumst. In suscipit neque metus, at malesuada mi consequat et. Donec rutrum at nisl eget viverra. Donec in pretium tellus. Pellentesque ultricies mollis lorem, at suscipit libero placerat a. Morbi laoreet tincidunt sapien a sollicitudin. Nam porttitor dolor libero, et pretium urna luctus quis. + +Quisque bibendum fringilla erat, vitae pellentesque augue luctus quis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In ut ipsum porttitor, consequat quam eu, posuere velit. Proin nec porttitor neque. Vivamus nec condimentum ex, eget condimentum velit. Proin ultricies mi vel mauris bibendum accumsan. Vestibulum in urna semper, mollis metus nec, porta augue. Nunc vitae metus purus. Vestibulum vel libero et urna vulputate tincidunt. Morbi nisi mi, tincidunt nec enim at, ullamcorper sollicitudin est. + +Proin volutpat tortor sed nulla consequat, ac fermentum metus suscipit. Aliquam ut lacus at elit vehicula scelerisque. Donec sapien nulla, tempus id faucibus in, malesuada ac nunc. Duis non massa ornare, condimentum ante porta, sagittis leo. Duis nec sem eget diam lacinia rhoncus. Sed et tortor semper nisi ullamcorper tincidunt rutrum vel eros. Pellentesque euismod diam in ipsum eleifend imperdiet. Aenean at suscipit diam. + +Ut interdum purus pulvinar fermentum commodo. In non venenatis enim. Pellentesque sem mauris, luctus eu erat ac, faucibus imperdiet nunc. Nunc et lectus dictum, tincidunt erat quis, posuere diam. Nullam tincidunt arcu id imperdiet ullamcorper. Ut nec nulla nunc. Nam semper, elit id dictum fringilla, nibh elit semper arcu, quis eleifend enim erat quis nibh. Phasellus bibendum vitae ex ac eleifend. Proin ullamcorper lacus eget hendrerit semper. Pellentesque at elit sollicitudin, cursus enim et, consectetur dui. + +Quisque consequat risus ex, viverra luctus magna consequat ut. In vel dictum ipsum. Vivamus placerat, ante sit amet auctor tempus, nisi arcu suscipit tellus, vel auctor tortor nunc non dolor. Cras eleifend varius nisi ac iaculis. Pellentesque mattis metus et magna tincidunt consectetur. Ut non mi ex. Donec mattis urna eget mi molestie elementum. Integer et sem varius, tincidunt justo eu, dignissim dolor. + +Aliquam maximus placerat magna sit amet tempus. Integer ipsum turpis, faucibus fermentum tortor a, pulvinar congue nibh. Sed molestie ac tellus at rhoncus. Pellentesque posuere vestibulum lectus sed ultricies. Vivamus vitae nisi nulla. Vestibulum quis felis ut urna scelerisque eleifend. Sed metus massa, tristique in arcu sodales, interdum condimentum quam. In tincidunt magna ultricies orci pretium, a congue arcu mollis. Aenean condimentum mollis scelerisque. Duis rhoncus vel diam a pretium. Proin tellus urna, pharetra vel feugiat nec, dignissim eu orci. + +Etiam posuere porttitor laoreet. Pellentesque vitae porttitor dui. Fusce dolor magna, aliquam nec arcu quis, elementum elementum dolor. Quisque bibendum, justo quis congue luctus, magna quam cursus elit, in tincidunt ex massa elementum tellus. Vestibulum pulvinar est nec sapien varius, sed elementum quam mattis. Praesent dapibus nisi et felis congue, ut viverra nisi consectetur. Sed condimentum accumsan sapien sed laoreet. Suspendisse laoreet egestas felis, ut pulvinar turpis semper at. Suspendisse aliquam, neque in volutpat gravida, justo nulla porttitor arcu, in dapibus risus lectus eget quam. Duis consectetur sed enim eu aliquam. Fusce eu iaculis libero, ac vulputate tortor. Donec efficitur, dolor ac aliquam feugiat, neque justo imperdiet nisi, nec maximus leo est ut nunc. + +Nullam sed justo iaculis, interdum ipsum et, viverra lacus. Ut laoreet fermentum diam, convallis eleifend enim semper id. Morbi vel justo dolor. Sed sagittis, sapien sed lacinia varius, neque lacus imperdiet erat, vitae efficitur ante diam eu nunc. Aliquam ac rhoncus turpis, ac tincidunt quam. Fusce luctus accumsan gravida. Sed non lacus tortor. Nulla elit est, blandit quis aliquam varius, hendrerit dignissim purus. + +Morbi tempor tincidunt turpis et accumsan. Nunc varius, quam in porttitor elementum, metus lorem ornare quam, eget faucibus ligula felis a nulla. Aliquam a purus ut justo pharetra laoreet. Nullam aliquet nunc a sagittis consectetur. Interdum et malesuada fames ac ante ipsum primis in faucibus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Integer ac ipsum in tortor lobortis aliquet. Donec consectetur mi varius lobortis maximus. Duis dignissim consectetur orci, id dictum dui porttitor a. Nunc hendrerit eros et porttitor aliquet. Aenean a nulla et magna vehicula pellentesque. Maecenas id lacus ac neque tincidunt ullamcorper a non justo. Sed dictum tortor eget fermentum gravida. Sed in sagittis ante. + +Mauris felis leo, tempus nec sodales non, aliquet sed nunc. Suspendisse potenti. Maecenas fermentum tristique ultrices. Aliquam dictum imperdiet ornare. Morbi vestibulum neque in est semper, vel fermentum risus fringilla. Praesent dapibus vitae lectus in pulvinar. Aliquam erat volutpat. + +Donec diam odio, placerat non ligula quis, fermentum bibendum ex. Integer eu augue at neque facilisis vehicula. Integer sodales tortor ante, id suscipit ex vehicula ac. Nunc luctus nunc turpis, sit amet dictum ex aliquam quis. Aenean tempus ullamcorper ligula, et scelerisque mauris. Fusce vitae sapien et ipsum porttitor pretium vel nec orci. Fusce rutrum lectus lorem, sed tincidunt lectus accumsan bibendum. Phasellus ac dolor felis. + +Curabitur tincidunt nibh quis scelerisque varius. Cras laoreet sodales elit at pulvinar. Donec accumsan interdum quam, eget tincidunt ex lobortis eget. Aenean a massa iaculis, ornare magna in, consectetur dui. Aliquam posuere ligula leo, sed iaculis tellus tempus sed. Duis feugiat pellentesque elit. Vivamus luctus orci vel tristique tristique. In hac habitasse platea dictumst. Morbi dictum imperdiet sem, at tristique enim. Nulla nec faucibus dolor, id luctus metus. + +Sed hendrerit, diam sit amet tristique malesuada, felis leo scelerisque erat, in dictum sem mi nec lacus. Fusce sollicitudin auctor metus non finibus. Sed semper est vel augue feugiat feugiat. Duis ac tincidunt arcu. Proin id consequat tellus. Suspendisse porttitor elit sed dolor sodales, sed dapibus nisl venenatis. In arcu nisl, ornare vel leo elementum, commodo sollicitudin sem. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Etiam sed pharetra diam. Praesent iaculis arcu sed erat eleifend tincidunt. Cras pulvinar, orci vitae cursus placerat, velit lectus volutpat arcu, et tempus nisi neque et lorem. + +Nulla venenatis, dui eget consequat interdum, dolor dui pellentesque lacus, ac maximus ante sapien a lectus. Vivamus tempus erat sit amet fringilla tincidunt. Suspendisse venenatis sollicitudin ante et vulputate. Fusce pellentesque nisl ac vehicula lacinia. Praesent tristique rhoncus dolor sed commodo. Praesent consequat mattis tortor nec interdum. Curabitur consequat blandit turpis, eget semper quam tristique non. Integer et dictum urna. Fusce lacinia erat ultricies orci condimentum placerat. Etiam nec odio et neque pretium aliquet. + +Curabitur faucibus euismod tellus. In quis dapibus metus. Quisque dapibus rhoncus massa, molestie posuere elit mattis eu. Praesent semper placerat massa, a tristique purus blandit sit amet. Nulla bibendum volutpat metus id pretium. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Aenean malesuada, mauris quis aliquam consequat, risus justo vulputate dui, sed imperdiet tortor ligula at orci. Curabitur vel mauris ut odio imperdiet bibendum nec a turpis. Phasellus tempor vehicula tellus. Nam magna tortor, finibus vitae magna quis, ultricies eleifend diam. + +Sed dignissim, metus vel molestie elementum, leo urna interdum dui, eget sollicitudin sem arcu sit amet nisi. Etiam congue dolor id dui feugiat porttitor. Nullam efficitur, arcu id imperdiet ornare, nibh arcu ultricies elit, at suscipit augue risus ac felis. Pellentesque sollicitudin odio vel tincidunt auctor. Donec orci sapien, viverra ut massa ac, tempus malesuada diam. Donec laoreet dui dignissim magna vehicula consectetur. Duis ut massa sed dui finibus tempor. + +In posuere neque eu lorem dapibus auctor. Nulla eget iaculis augue. Aenean eleifend metus et tempor tincidunt. Fusce ullamcorper massa ac venenatis ullamcorper. Integer mattis feugiat lobortis. Aliquam mattis arcu quis urna varius, in suscipit arcu maximus. Nunc urna dolor, porttitor placerat est non, cursus pulvinar nisi. Sed mattis feugiat varius. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis viverra congue odio ac pellentesque. Nam et volutpat sapien, sed rutrum ipsum. Morbi mattis non eros non varius. Phasellus tincidunt diam at mattis interdum. + +Donec diam dui, pretium nec eros et, interdum dictum libero. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer a magna metus. Sed at tellus laoreet, rutrum mauris vel, posuere ligula. Vestibulum ac vulputate dui. Maecenas purus nunc, fringilla sit amet est non, pretium venenatis nisi. Aliquam pellentesque finibus velit, a viverra augue euismod consequat. Nunc interdum non risus vitae gravida. Morbi metus nisi, porta tempor elit non, porttitor suscipit felis. Sed tincidunt convallis tristique. Fusce facilisis, elit sed facilisis facilisis, tortor purus elementum quam, convallis auctor mi libero sagittis lectus. + +Fusce eu nisi semper, commodo orci sit amet, eleifend eros. Cras odio erat, gravida at placerat at, ultricies sed lorem. Suspendisse at viverra dui. Suspendisse non diam ex. Donec vestibulum lobortis hendrerit. Donec nulla felis, feugiat sed ligula id, varius tempus nisl. Nam vulputate consequat aliquet. + +Fusce feugiat sapien eget arcu commodo, in congue sapien tincidunt. Quisque erat lorem, eleifend feugiat nulla quis, convallis condimentum risus. Duis dapibus a turpis id tincidunt. Mauris ut ipsum nibh. Proin a neque a libero vestibulum convallis. Duis in imperdiet dui. Morbi id semper tellus. In neque nibh, tristique id risus non, interdum iaculis velit. Proin non magna sem. Nullam a interdum urna. Mauris quis magna eu turpis aliquet varius. Quisque tincidunt est vel neque viverra fringilla. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vivamus nec tempus sapien, ac luctus velit. Integer consequat, lorem sit amet vehicula ultricies, orci elit sollicitudin orci, sed vestibulum est dolor ut elit. + +Etiam vel ultrices ipsum, vitae imperdiet felis. Vivamus maximus ex id massa auctor, vitae fringilla sapien cursus. Maecenas felis ipsum, suscipit non ultricies sodales, mollis eget lacus. Donec ullamcorper quam at rhoncus malesuada. Etiam iaculis, sem vel eleifend ornare, massa tortor eleifend diam, id dictum erat purus ac risus. Integer lacinia odio at nisi pulvinar, at tincidunt augue condimentum. Proin malesuada felis turpis, id lacinia enim interdum mattis. Duis vel ex consectetur, mattis nunc et, ullamcorper velit. Mauris in mattis felis, et pretium odio. + +Pellentesque aliquet ipsum egestas orci congue, vitae aliquet lorem vestibulum. Duis vitae risus elementum, lobortis lectus a, fermentum metus. Sed facilisis, turpis eget posuere venenatis, erat purus vestibulum nibh, ac eleifend dolor tortor non velit. Maecenas ut facilisis turpis, et placerat metus. Aenean lacus justo, sagittis vitae blandit id, fermentum vel est. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce vel tempor odio. Aliquam tristique arcu semper est ornare gravida. Aenean consectetur viverra felis non aliquam. Pellentesque auctor ex ac imperdiet porttitor. Aliquam tincidunt condimentum semper. Cras rutrum, sapien eu interdum porttitor, eros quam volutpat purus, ac semper nisl leo et lacus. Phasellus rutrum arcu lobortis, pretium tortor nec, mollis elit. + +Praesent dictum vehicula sem et fringilla. Sed vestibulum, ante in pharetra auctor, ligula neque aliquet ante, vitae convallis ex magna venenatis neque. Maecenas fringilla convallis nunc pulvinar pellentesque. Suspendisse potenti. Cras massa libero, viverra a iaculis in, commodo consequat justo. Aenean sit amet finibus purus, id finibus sem. Fusce vestibulum laoreet libero, non porta eros gravida molestie. Nam et orci feugiat eros laoreet vulputate. Nunc in felis luctus, egestas mauris eu, congue justo. + +Vivamus vel tellus non ante eleifend consequat et efficitur nibh. Proin feugiat diam eu leo finibus, sed cursus tortor venenatis. Nam tempus tortor quis nunc interdum suscipit. Pellentesque non orci sit amet risus luctus egestas vel non tortor. Quisque feugiat lacus et rutrum malesuada. Sed vehicula placerat laoreet. Donec ornare eget ex eget ornare. Nam nec placerat neque, a viverra urna. Suspendisse augue libero, tristique nec sollicitudin a, rhoncus in urna. + +Phasellus ac gravida dolor. Nullam sodales ullamcorper lorem, vitae faucibus erat iaculis non. Mauris interdum leo fermentum, commodo libero nec, vulputate justo. Donec tempus, arcu ut efficitur bibendum, mi neque feugiat ligula, ac cursus enim massa nec velit. Nullam pharetra neque et ex fermentum, ac congue enim volutpat. Donec ut laoreet erat. Nunc at semper magna. Mauris purus tellus, luctus vel sapien quis, elementum condimentum neque. Curabitur suscipit vulputate mauris. Quisque venenatis eros tortor, quis porta purus viverra ut. \ No newline at end of file diff --git a/Third term/Frontend and backend development/README.md b/Third term/Frontend and backend development/README.md new file mode 100755 index 0000000..47df3b9 --- /dev/null +++ b/Third term/Frontend and backend development/README.md @@ -0,0 +1,7 @@ +# Artificial intelligence systems and big data + +number | grade +:----: | :---: +1 | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Third term/Frontend and backend development/first_term.html b/Third term/Frontend and backend development/first_term.html new file mode 100755 index 0000000..394ceba --- /dev/null +++ b/Third term/Frontend and backend development/first_term.html @@ -0,0 +1,509 @@ + + + + + + Учебный план + + + + + +
+ +
+ +
+ Логотип +

Лого

+
+ +
+

Группа: ЭФБО-09-23

+

Калинин Никита Викторович

+
+
+ + +
+ +
+ + + +
+

Первый семестр

+ + +
+

Лекции

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
НомерТемаПосещение
1Основы языка HTML + checkbox-true +
2Углубленное изучение HTML + checkbox-false +
3Основы работы с CSS + checkbox-false +
4Адаптивная верстка. Flexbox и Grid Layout + checkbox-false +
5Bootstrap — работа с фреймворком + checkbox-false +
6Основы языка JavaScript + checkbox-false +
7Работа с DOM и событиями в JavaScript + checkbox-false +
8Введение в GitHub и GitHub Pages + checkbox-false +
+
+ + +
+

Практики

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
НомерТемаПосещениеВыполнение
1Основы языка HTML + checkbox-true + + checkbox-true +
2Формы и кнопки в HTML + checkbox-false + + checkbox-false +
3Таблицы и интерактивные элементы HTML + checkbox-false + + checkbox-false +
4Основы работы с CSS + checkbox-false + + checkbox-false +
5Работа с классами в CSS + checkbox-false + + checkbox-false +
6Работа с сетками и разметкой в HTML + checkbox-false + + checkbox-false +
7Адаптивная верстка + checkbox-false + + checkbox-false +
8Bootstrap + checkbox-false + + checkbox-false +
9Основы языка JavaScript + checkbox-false + + checkbox-false +
10Базовые задачи на JS + checkbox-false + + checkbox-false +
11 + DOM-структура приложений и работа с объектами в языке JS + + checkbox-false + + checkbox-false +
12Встраивание скриптов + checkbox-false + + checkbox-false +
13Отладка сценариев + checkbox-false + + checkbox-false +
14Анимации и работа с ними + checkbox-false + + checkbox-false +
15Github + checkbox-false + + checkbox-false +
16Защита проекта + checkbox-false + + checkbox-false +
+
+ + +
+

+ Занятия проходят по адресу + Москва, проспект Вернадского, 78, стр. 4 +

+ +
+ + +
+

Рабочая программа

+ +

+ Unable to display PDF file. + Download instead. +

+ +
+
+
+ + +
+

© 2024 Все права защищены.

+ + +
+ + diff --git a/Third term/Frontend and backend development/index.html b/Third term/Frontend and backend development/index.html new file mode 100755 index 0000000..057903c --- /dev/null +++ b/Third term/Frontend and backend development/index.html @@ -0,0 +1,225 @@ + + + + + + Главная страница + + + + +
+ +
+ +
+ Логотип +

Лого

+
+ +
+

Группа: ЭФБО-09-23

+

Калинин Никита Викторович

+
+
+ + +
+ +
+ + + +
+ +

Добро пожаловать на мой сайт

+
+ +

+ Меня зовут Иванов Иван Иванович и я начинающий специалист по + веб-разработке. +

+ + user +
+ +
+

Фронтенд

+

+ Фронтенд (Frontend) — это часть веб-разработки, которая отвечает за + создание пользовательского интерфейса и взаимодействие пользователя + с веб-приложением. Другими словами, фронтенд охватывает все, что + пользователь видит на экране и с чем он взаимодействует в браузере. + Основная задача фронтенд-разработчика — сделать так, чтобы сайт или + веб-приложение были удобными, понятными и эстетически приятными для + пользователя. +

+

Ключевые технологии фронтенда:

+
    +
  • + HTML (HyperText Markup Language) — язык разметки, который + определяет структуру веб-страницы. Он используется для создания + различных элементов, таких как заголовки, абзацы, ссылки, + изображения и другие элементы веб-страницы. +
    • +
  • + CSS (Cascading Style Sheets) — каскадные таблицы стилей, + которые отвечают за внешний вид веб-страницы. С помощью CSS можно + задавать стили для различных элементов HTML, например, цвета, + шрифты, размеры, отступы и расположение на странице. +
    • +
  • + JavaScript — язык программирования, который позволяет + создавать динамическое и интерактивное поведение на веб-странице. + С его помощью можно реализовывать различные анимации, обработку + событий, валидацию форм и взаимодействие с сервером без + перезагрузки страницы. +
    • +
+

Современные инструменты и библиотеки:

+
    +
  • + Фреймворки — такие как React, Angular, Vue.js, которые + предоставляют готовые компоненты и архитектуры для создания + сложных веб-приложений. +
    • +
  • + Системы сборки — Webpack, Gulp, которые помогают + автоматизировать процесс сборки и оптимизации кода. +
    • +
  • + Системы контроля версий — Git, которые позволяют + отслеживать изменения в коде и работать в команде. +
    • +
+

Роль фронтенд-разработчика

+

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

+ + +
+ +
+

Бэкенд

+

+ Бэкенд (Backend) — это часть веб-разработки, которая отвечает за + серверную логику, работу с базами данных и общую инфраструктуру, + поддерживающую работу веб-приложения. Если фронтенд — это то, что + видит и с чем взаимодействует пользователь, то бэкенд — это то, что + происходит "за кулисами". Бэкенд обрабатывает запросы пользователя, + взаимодействует с базами данных, управляет сессиями и обеспечивает + безопасность приложения. +

+

Ключевые технологии бэкенда:

+
    +
  • + Языки программирования — такие как Python, Java, PHP, Ruby, + JavaScript (Node.js), которые позволяют создавать серверную логику + и обрабатывать запросы от фронтенда. +
    • +
  • + СУБД (Системы управления базами данных) — MySQL, + PostgreSQL, MongoDB, которые отвечают за хранение и управление + данными. Бэкенд-разработчик создает запросы к базам данных и + обрабатывает полученные результаты. +
    • +
  • + API (Application Programming Interface) — интерфейсы + программирования приложений, такие как REST и GraphQL, которые + используются для взаимодействия между фронтендом и бэкендом, а + также между различными сервисами внутри приложения. +
    • +
+

Современные инструменты и фреймворки:

+
    +
  • + Фреймворки — такие как Django, Spring, Express.js, которые + предоставляют готовые решения для создания и управления серверной + логикой. +
    • +
  • + Системы контейнеризации и виртуализации — Docker, + Kubernetes, которые упрощают развертывание и масштабирование + приложений. +
    • +
  • + Системы управления версиями — такие как Git, которые + позволяют отслеживать изменения в коде и эффективно работать в + команде. +
    • +
+

Роль бэкенд-разработчика

+

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

+ + +
+
+
+ + +
+

© 2024 Все права защищены.

+ + +
+ + diff --git a/Third term/Frontend and backend development/services.html b/Third term/Frontend and backend development/services.html new file mode 100755 index 0000000..964e750 --- /dev/null +++ b/Third term/Frontend and backend development/services.html @@ -0,0 +1,237 @@ + + + + + + Услуги + + + + + + + + +
+ +
+ +
+ Логотип +

Лого

+
+ +
+

Группа: ЭФБО-09-23

+

Калинин Никита Викторович

+
+
+ + +
+ +
+ + + +
+ + +

Разработка веб-приложений

+ +
+
+ site +

Сайт-визитка

+ +
+
+ site +

Корпоративный сайт

+ +
+
+ site +

Интернет-магазин

+ +
+
+
+

Сайт-визитка

+

+ Сайт-визитка — это небольшой веб-сайт, который представляет собой + цифровую визитную карточку компании, специалиста или бренда. Такой + сайт обычно состоит из нескольких страниц и содержит основную + информацию: название компании, виды деятельности, контактные данные, + а также ссылки на социальные сети. Основная цель сайта-визитки — это + предоставление краткой и точной информации о компании или человеке. + Это простой и быстрый способ создать присутствие в интернете без + значительных затрат. +

+
+
+

Корпоративный сайт

+

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

+
+
+

Интернет-магазин

+

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

+
+
+
+ + +
+

© 2024 Все права защищены.

+ + +
+ + + + + diff --git a/Third term/Frontend and backend development/src/css/first_term.css b/Third term/Frontend and backend development/src/css/first_term.css new file mode 100755 index 0000000..e6290ab --- /dev/null +++ b/Third term/Frontend and backend development/src/css/first_term.css @@ -0,0 +1,34 @@ +/* Общие стили для таблицы */ +table { + width: 100%; + border-collapse: collapse; + margin-bottom: 20px; +} + +/* Стили для ячеек */ +th, +td { + border: 1px solid black; + padding: 8px; + text-align: center; +} + +/* Фон заголовков */ +th { + background-color: #f2f2f2; +} + +/* Чередование цветов строк */ +tbody tr:nth-child(even) { + background-color: #f9f9f9; +} + +tbody tr:nth-child(odd) { + background-color: #e9e9e9; +} + +/* Размер чекбоксов */ +.checkbox { + width: 18px; + height: 18px; +} diff --git a/Third term/Frontend and backend development/src/css/main.css b/Third term/Frontend and backend development/src/css/main.css new file mode 100755 index 0000000..65f2082 --- /dev/null +++ b/Third term/Frontend and backend development/src/css/main.css @@ -0,0 +1,73 @@ +/* Основные стили для body */ +body { + border: 2px solid black; + font-family: Arial, sans-serif; +} + +/* Общий контейнер для flex элементов */ +.container { + display: flex; +} + +/* Стили для иконок */ +.icon { + width: 32px; + height: 32px; +} + +/* Стили для изображения пользователя */ +.user-image { + width: 100px; + height: 100px; + padding: 5px; + margin: 0 auto; + border: 2px solid black; +} + +/* Стили для информации в шапке и футере */ +.header-info, +footer { + display: flex; + align-items: center; + padding: 10px 20px; + justify-content: space-between; +} + +/* Стили для навигации в шапке */ +.header-navigation { + padding: 15px; + border-top: 2px solid black; + border-bottom: 2px solid black; +} + +/* Общие стили для ссылок в шапке, на странице и в футере */ +.header-navigation-link, +.page-navigation-link, +.footer-navigation-link { + margin: 0 10px; + color: black; + text-decoration: none; +} + +/* Стили для наведения курсора на ссылки */ +.header-navigation-link:hover, +.page-navigation-link:hover { + text-decoration: underline; +} + +/* Стили для навигации по странице */ +.page-navigation { + width: 30%; + border-right: 2px solid black; + padding: 10px; +} + +/* Основной контент страницы */ +.page-info { + padding: 10px; +} + +/* Стили для футера */ +footer { + border-top: 2px solid black; +} diff --git a/Third term/Frontend and backend development/src/css/services.css b/Third term/Frontend and backend development/src/css/services.css new file mode 100755 index 0000000..0f5b346 --- /dev/null +++ b/Third term/Frontend and backend development/src/css/services.css @@ -0,0 +1,84 @@ +/* Стили для карточек сайтов */ +.site-card { + border: 2px solid black; + margin: 0 auto; + display: flex; + flex-direction: column; /* Элементы располагаются вертикально */ + align-items: center; /* Центрируем элементы по горизонтали */ +} + +/* Стили для изображений сайтов */ +.site-image { + width: 200px; + height: 200px; + padding: 5px; + border-bottom: 2px solid black; +} + +/* Стили для текста карточек сайтов */ +.site-card-text { + margin: 10px; + text-align: center; +} + +/* Основной стиль для модального окна */ +.modal { + display: none; /* Скрыто по умолчанию */ + position: fixed; + z-index: 1; + left: 0; + top: 0; + width: 100%; + height: 100%; + overflow: hidden; + background-color: rgba(0, 0, 0, 0.4); +} + +/* Стиль для содержимого модального окна */ +.modal-content { + background-color: white; + margin: 4% auto; + padding: 20px; + border: 2px solid black; + width: 80%; + max-width: 500px; +} + +/* Кнопка закрытия модального окна */ +.close { + color: #aaa; + float: right; + font-size: 28px; + font-weight: bold; +} + +.close:hover, +.close:focus { + color: black; + text-decoration: none; + cursor: pointer; +} + +/* Стиль для формы внутри модального окна */ +form { + display: flex; + flex-direction: column; +} + +label { + margin-top: 10px; +} + +input, +textarea { + margin-bottom: 10px; + padding: 8px; + border: 1px solid black; +} + +button { + padding: 5px; + margin: 10px; + border: 1px solid black; + cursor: pointer; +} diff --git a/Third term/Frontend and backend development/src/img/checkbox-false.png b/Third term/Frontend and backend development/src/img/checkbox-false.png new file mode 100644 index 0000000..795dc2e Binary files /dev/null and b/Third term/Frontend and backend development/src/img/checkbox-false.png differ diff --git a/Third term/Frontend and backend development/src/img/checkbox-true.png b/Third term/Frontend and backend development/src/img/checkbox-true.png new file mode 100644 index 0000000..2f9d7ea Binary files /dev/null and b/Third term/Frontend and backend development/src/img/checkbox-true.png differ diff --git a/Third term/Frontend and backend development/src/img/circle-info-solid.svg b/Third term/Frontend and backend development/src/img/circle-info-solid.svg new file mode 100755 index 0000000..a66cf43 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/circle-info-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/earth-europe-solid.svg b/Third term/Frontend and backend development/src/img/earth-europe-solid.svg new file mode 100755 index 0000000..3019172 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/earth-europe-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/house-solid.svg b/Third term/Frontend and backend development/src/img/house-solid.svg new file mode 100755 index 0000000..374579b --- /dev/null +++ b/Third term/Frontend and backend development/src/img/house-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/telegram-brands-solid.svg b/Third term/Frontend and backend development/src/img/telegram-brands-solid.svg new file mode 100755 index 0000000..6797571 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/telegram-brands-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/user-solid.svg b/Third term/Frontend and backend development/src/img/user-solid.svg new file mode 100755 index 0000000..48569e9 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/user-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/vk-brands-solid.svg b/Third term/Frontend and backend development/src/img/vk-brands-solid.svg new file mode 100755 index 0000000..0999a65 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/vk-brands-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/img/xmark-solid.svg b/Third term/Frontend and backend development/src/img/xmark-solid.svg new file mode 100755 index 0000000..178a4d4 --- /dev/null +++ b/Third term/Frontend and backend development/src/img/xmark-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Third term/Frontend and backend development/src/pdf/3.pdf b/Third term/Frontend and backend development/src/pdf/3.pdf new file mode 100644 index 0000000..da15f1d Binary files /dev/null and b/Third term/Frontend and backend development/src/pdf/3.pdf differ diff --git a/Third term/Frontend and backend development/src/videos/backend.mp4 b/Third term/Frontend and backend development/src/videos/backend.mp4 new file mode 100644 index 0000000..00ada40 Binary files /dev/null and b/Third term/Frontend and backend development/src/videos/backend.mp4 differ diff --git a/Third term/Frontend and backend development/src/videos/frontend.mp4 b/Third term/Frontend and backend development/src/videos/frontend.mp4 new file mode 100644 index 0000000..187c8b2 Binary files /dev/null and b/Third term/Frontend and backend development/src/videos/frontend.mp4 differ diff --git a/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt b/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt new file mode 100755 index 0000000..5b72b0a --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt @@ -0,0 +1,71 @@ +cmake_minimum_required(VERSION 3.16) + +project(1_Calculator VERSION 0.1 LANGUAGES CXX) + +set(CMAKE_AUTOUIC ON) +set(CMAKE_AUTOMOC ON) +set(CMAKE_AUTORCC ON) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets) +find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets) + +set(PROJECT_SOURCES + main.cpp + mainwindow.cpp + mainwindow.h + mainwindow.ui +) + +if(${QT_VERSION_MAJOR} GREATER_EQUAL 6) + qt_add_executable(1_Calculator + MANUAL_FINALIZATION + ${PROJECT_SOURCES} + ) +# Define target properties for Android with Qt 6 as: +# set_property(TARGET 1_Calculator APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR +# ${CMAKE_CURRENT_SOURCE_DIR}/android) +# For more information, see https://doc.qt.io/qt-6/qt-add-executable.html#target-creation +else() + if(ANDROID) + add_library(1_Calculator SHARED + ${PROJECT_SOURCES} + ) +# Define properties for Android with Qt 5 after find_package() calls as: +# set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android") + else() + add_executable(1_Calculator + ${PROJECT_SOURCES} + programmingwindow.ui + ) + endif() +endif() + +target_link_libraries(1_Calculator PRIVATE Qt${QT_VERSION_MAJOR}::Widgets) + +# Qt for iOS sets MACOSX_BUNDLE_GUI_IDENTIFIER automatically since Qt 6.1. +# If you are developing for iOS or macOS you should consider setting an +# explicit, fixed bundle identifier manually though. +if(${QT_VERSION} VERSION_LESS 6.1.0) + set(BUNDLE_ID_OPTION MACOSX_BUNDLE_GUI_IDENTIFIER com.example.1_Calculator) +endif() +set_target_properties(1_Calculator PROPERTIES + ${BUNDLE_ID_OPTION} + MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION} + MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + MACOSX_BUNDLE TRUE + WIN32_EXECUTABLE TRUE +) + +include(GNUInstallDirs) +install(TARGETS 1_Calculator + BUNDLE DESTINATION . + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} +) + +if(QT_VERSION_MAJOR EQUAL 6) + qt_finalize_executable(1_Calculator) +endif() diff --git a/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt.user b/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt.user new file mode 100755 index 0000000..6ae2019 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/CMakeLists.txt.user @@ -0,0 +1,422 @@ + + + + + + EnvironmentId + {b09ad12c-2375-4d91-a30f-70a5d330cb93} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + 0 + false + true + false + 2 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + false + + + 0 + true + + true + true + Builtin.DefaultTidyAndClazy + 4 + true + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop + Desktop + {a763e5f1-4a4d-4ec1-b61b-aa3746a79db0} + 0 + 0 + 0 + + Debug + 2 + false + + -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_BUILD_TYPE:STRING=Debug +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG} + 0 + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug + + + + + all + + false + + true + Build + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + Build + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Debug + CMakeProjectManager.CMakeBuildConfiguration + + + Release + 2 + false + + -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_BUILD_TYPE:STRING=Release +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG} + /home/nktkln/Documents/1_Calculator/build/Desktop-Release + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release + CMakeProjectManager.CMakeBuildConfiguration + + + RelWithDebInfo + 2 + false + + -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG} + /home/nktkln/Documents/1_Calculator/build/Desktop-RelWithDebInfo + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release with Debug Information + CMakeProjectManager.CMakeBuildConfiguration + + + RelWithDebInfo + 2 + false + + -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG} + 0 + /home/nktkln/Documents/1_Calculator/build/Desktop-Profile + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Profile + CMakeProjectManager.CMakeBuildConfiguration + + + MinSizeRel + 2 + false + + -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_BUILD_TYPE:STRING=MinSizeRel +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG} + /home/nktkln/Documents/1_Calculator/build/Desktop-MinSizeRel + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Minimum Size Release + CMakeProjectManager.CMakeBuildConfiguration + + 5 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + 0 + true + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + 1_Calculator + CMakeProjectManager.CMakeRunConfiguration.1_Calculator + 1_Calculator + false + true + true + true + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/cache-v2 b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/cache-v2 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/cmakeFiles-v1 b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/cmakeFiles-v1 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/codemodel-v2 b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/query/codemodel-v2 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cache-v2-387291ecfba8681349fe.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cache-v2-387291ecfba8681349fe.json new file mode 100755 index 0000000..140cf67 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cache-v2-387291ecfba8681349fe.json @@ -0,0 +1,1559 @@ +{ + "entries" : + [ + { + "name" : "1_Calculator_BINARY_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug" + }, + { + "name" : "1_Calculator_IS_TOP_LEVEL", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "ON" + }, + { + "name" : "1_Calculator_SOURCE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator" + }, + { + "name" : "CMAKE_ADDR2LINE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/addr2line" + }, + { + "name" : "CMAKE_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ar" + }, + { + "name" : "CMAKE_BUILD_TYPE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "Debug" + }, + { + "name" : "CMAKE_CACHEFILE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "This is the directory where this CMakeCache.txt was created" + } + ], + "type" : "INTERNAL", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug" + }, + { + "name" : "CMAKE_CACHE_MAJOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Major version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "3" + }, + { + "name" : "CMAKE_CACHE_MINOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Minor version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "30" + }, + { + "name" : "CMAKE_CACHE_PATCH_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Patch version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "3" + }, + { + "name" : "CMAKE_COLOR_DIAGNOSTICS", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Enable colored diagnostics throughout." + } + ], + "type" : "BOOL", + "value" : "1" + }, + { + "name" : "CMAKE_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/cmake" + }, + { + "name" : "CMAKE_CPACK_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to cpack program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/cpack" + }, + { + "name" : "CMAKE_CTEST_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to ctest program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/ctest" + }, + { + "name" : "CMAKE_CXX_COMPILER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "CXX compiler" + } + ], + "type" : "STRING", + "value" : "/usr/bin/g++" + }, + { + "name" : "CMAKE_CXX_COMPILER_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler" + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/gcc-ar" + }, + { + "name" : "CMAKE_CXX_COMPILER_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler" + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/gcc-ranlib" + }, + { + "name" : "CMAKE_CXX_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during all build types." + } + ], + "type" : "STRING", + "value" : "-DQT_QML_DEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "-g" + }, + { + "name" : "CMAKE_CXX_FLAGS_INIT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "-DQT_QML_DEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "-Os -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "-O3 -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "-O2 -g -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_OUTPUT_EXTENSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "" + } + ], + "type" : "STRING", + "value" : ".o" + }, + { + "name" : "CMAKE_C_COMPILER", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/clang" + }, + { + "name" : "CMAKE_C_OUTPUT_EXTENSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "" + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_DLLTOOL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_DLLTOOL-NOTFOUND" + }, + { + "name" : "CMAKE_EDIT_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to cache edit program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/ccmake" + }, + { + "name" : "CMAKE_EXECUTABLE_FORMAT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Executable file format" + } + ], + "type" : "INTERNAL", + "value" : "ELF" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXPORT_COMPILE_COMMANDS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Enable/Disable output of compile commands during generation." + } + ], + "type" : "BOOL", + "value" : "" + }, + { + "name" : "CMAKE_FIND_PACKAGE_REDIRECTS_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake." + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/pkgRedirects" + }, + { + "name" : "CMAKE_GENERATOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "Ninja" + }, + { + "name" : "CMAKE_GENERATOR_INSTANCE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Generator instance identifier." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_PLATFORM", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator platform." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_TOOLSET", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator toolset." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_HOME_DIRECTORY", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Source directory with the top level CMakeLists.txt file for this project" + } + ], + "type" : "INTERNAL", + "value" : "/home/nktkln/Documents/1_Calculator" + }, + { + "name" : "CMAKE_INSTALL_BINDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "User executables (bin)" + } + ], + "type" : "PATH", + "value" : "bin" + }, + { + "name" : "CMAKE_INSTALL_DATADIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only architecture-independent data (DATAROOTDIR)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_DATAROOTDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only architecture-independent data root (share)" + } + ], + "type" : "PATH", + "value" : "share" + }, + { + "name" : "CMAKE_INSTALL_DOCDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Documentation root (DATAROOTDIR/doc/PROJECT_NAME)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_INCLUDEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "C header files (include)" + } + ], + "type" : "PATH", + "value" : "include" + }, + { + "name" : "CMAKE_INSTALL_INFODIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Info documentation (DATAROOTDIR/info)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_LIBDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Object code libraries (lib)" + } + ], + "type" : "PATH", + "value" : "lib" + }, + { + "name" : "CMAKE_INSTALL_LIBEXECDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Program executables (libexec)" + } + ], + "type" : "PATH", + "value" : "libexec" + }, + { + "name" : "CMAKE_INSTALL_LOCALEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Locale-dependent data (DATAROOTDIR/locale)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_LOCALSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Modifiable single-machine data (var)" + } + ], + "type" : "PATH", + "value" : "var" + }, + { + "name" : "CMAKE_INSTALL_MANDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Man documentation (DATAROOTDIR/man)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_OLDINCLUDEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "C header files for non-gcc (/usr/include)" + } + ], + "type" : "PATH", + "value" : "/usr/include" + }, + { + "name" : "CMAKE_INSTALL_PREFIX", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Install path prefix, prepended onto install directories." + } + ], + "type" : "PATH", + "value" : "/usr/local" + }, + { + "name" : "CMAKE_INSTALL_RUNSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Run-time variable data (LOCALSTATEDIR/run)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_SBINDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "System admin executables (sbin)" + } + ], + "type" : "PATH", + "value" : "sbin" + }, + { + "name" : "CMAKE_INSTALL_SHAREDSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Modifiable architecture-independent data (com)" + } + ], + "type" : "PATH", + "value" : "com" + }, + { + "name" : "CMAKE_INSTALL_SO_NO_EXE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Install .so files without execute permission." + } + ], + "type" : "INTERNAL", + "value" : "0" + }, + { + "name" : "CMAKE_INSTALL_SYSCONFDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only single-machine data (etc)" + } + ], + "type" : "PATH", + "value" : "etc" + }, + { + "name" : "CMAKE_LINKER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ld" + }, + { + "name" : "CMAKE_MAKE_PROGRAM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Program used to build from build.ninja files." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ninja" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_NM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/nm" + }, + { + "name" : "CMAKE_NUMBER_OF_MAKEFILES", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "number of local generators" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_OBJCOPY", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/objcopy" + }, + { + "name" : "CMAKE_OBJDUMP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/objdump" + }, + { + "name" : "CMAKE_PLATFORM_INFO_INITIALIZED", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Platform information initialized" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_PREFIX_PATH", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "PATH", + "value" : "/usr" + }, + { + "name" : "CMAKE_PROJECT_DESCRIPTION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_HOMEPAGE_URL", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_INCLUDE_BEFORE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake" + }, + { + "name" : "CMAKE_PROJECT_NAME", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1_Calculator" + }, + { + "name" : "CMAKE_PROJECT_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "0.1" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MAJOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "0" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MINOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1" + }, + { + "name" : "CMAKE_PROJECT_VERSION_PATCH", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_VERSION_TWEAK", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ranlib" + }, + { + "name" : "CMAKE_READELF", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/readelf" + }, + { + "name" : "CMAKE_ROOT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake installation." + } + ], + "type" : "INTERNAL", + "value" : "/usr/share/cmake" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SKIP_INSTALL_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when installing shared libraries, but are added when building." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_SKIP_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when using shared libraries." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STRIP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/strip" + }, + { + "name" : "CMAKE_TAPI", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_TAPI-NOTFOUND" + }, + { + "name" : "CMAKE_UNAME", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "uname command" + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/uname" + }, + { + "name" : "CMAKE_VERBOSE_MAKEFILE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only. With Visual Studio IDE projects all commands are done without /nologo." + } + ], + "type" : "BOOL", + "value" : "FALSE" + }, + { + "name" : "QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Skip Qt Creator's package manager auto-setup" + } + ], + "type" : "BOOL", + "value" : "OFF" + }, + { + "name" : "QT_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for QT." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5" + }, + { + "name" : "QT_QMAKE_EXECUTABLE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/qmake" + }, + { + "name" : "Qt5Core_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Core." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Core" + }, + { + "name" : "Qt5Gui_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Gui." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Gui" + }, + { + "name" : "Qt5Widgets_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Widgets." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Widgets" + }, + { + "name" : "Qt5_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5" + }, + { + "name" : "_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "linker supports push/pop state" + } + ], + "type" : "INTERNAL", + "value" : "TRUE" + }, + { + "name" : "_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "CMAKE_INSTALL_PREFIX during last run" + } + ], + "type" : "INTERNAL", + "value" : "/usr/local" + } + ], + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cmakeFiles-v1-6e3d2fd7600caa8021a8.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cmakeFiles-v1-6e3d2fd7600caa8021a8.json new file mode 100755 index 0000000..0f6c450 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/cmakeFiles-v1-6e3d2fd7600caa8021a8.json @@ -0,0 +1,654 @@ +{ + "inputs" : + [ + { + "path" : "CMakeLists.txt" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineSystem.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeSystem.cmake.in" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeNinjaFindMake.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-Determine-CXX.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCompilerIdDetection.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/ADSP-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/ARMClang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Borland-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Clang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Cray-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/CrayClang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GHS-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IAR-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Intel-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/MSVC-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/NVHPC-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/NVIDIA-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/OrangeC-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/PGI-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/PathScale-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/SCO-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/TI-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/TIClang-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Tasking-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/Watcom-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeFindBinUtils.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU-FindBinUtils.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeGenericSystem.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/UnixPaths.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCXXInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeLanguageInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-GNU.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseImplicitIncludeInfo.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseImplicitLinkInfo.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseLibraryArchitecture.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeDetermineCompilerSupport.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Internal/FeatureTesting.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5Config.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5Config.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseArguments.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseArguments.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/GNUInstallDirs.cmake" + } + ], + "kind" : "cmakeFiles", + "paths" : + { + "build" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "source" : "/home/nktkln/Documents/1_Calculator" + }, + "version" : + { + "major" : 1, + "minor" : 1 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/codemodel-v2-9a6bcbe562446a0cf472.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/codemodel-v2-9a6bcbe562446a0cf472.json new file mode 100755 index 0000000..01bf76e --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/codemodel-v2-9a6bcbe562446a0cf472.json @@ -0,0 +1,79 @@ +{ + "configurations" : + [ + { + "directories" : + [ + { + "build" : ".", + "hasInstallRule" : true, + "jsonFile" : "directory-.-Debug-da4a47c2c6e804eec357.json", + "minimumCMakeVersion" : + { + "string" : "3.16" + }, + "projectIndex" : 0, + "source" : ".", + "targetIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "name" : "Debug", + "projects" : + [ + { + "directoryIndexes" : + [ + 0 + ], + "name" : "1_Calculator", + "targetIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "targets" : + [ + { + "directoryIndex" : 0, + "id" : "1_Calculator::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator-Debug-efd30a14e0b320172536.json", + "name" : "1_Calculator", + "projectIndex" : 0 + }, + { + "directoryIndex" : 0, + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json", + "name" : "1_Calculator_autogen", + "projectIndex" : 0 + }, + { + "directoryIndex" : 0, + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json", + "name" : "1_Calculator_autogen_timestamp_deps", + "projectIndex" : 0 + } + ] + } + ], + "kind" : "codemodel", + "paths" : + { + "build" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "source" : "/home/nktkln/Documents/1_Calculator" + }, + "version" : + { + "major" : 2, + "minor" : 7 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/directory-.-Debug-da4a47c2c6e804eec357.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/directory-.-Debug-da4a47c2c6e804eec357.json new file mode 100755 index 0000000..57670ea --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/directory-.-Debug-da4a47c2c6e804eec357.json @@ -0,0 +1,45 @@ +{ + "backtraceGraph" : + { + "commands" : + [ + "install" + ], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + }, + { + "command" : 0, + "file" : 0, + "line" : 62, + "parent" : 0 + } + ] + }, + "installers" : + [ + { + "backtrace" : 1, + "component" : "Unspecified", + "destination" : "bin", + "paths" : + [ + "1_Calculator" + ], + "targetId" : "1_Calculator::@6890427a1f51a3e7e1df", + "targetIndex" : 0, + "type" : "target" + } + ], + "paths" : + { + "build" : ".", + "source" : "." + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/index-2024-09-11T16-21-57-0390.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/index-2024-09-11T16-21-57-0390.json new file mode 100755 index 0000000..390820d --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/index-2024-09-11T16-21-57-0390.json @@ -0,0 +1,89 @@ +{ + "cmake" : + { + "generator" : + { + "multiConfig" : false, + "name" : "Ninja" + }, + "paths" : + { + "cmake" : "/usr/bin/cmake", + "cpack" : "/usr/bin/cpack", + "ctest" : "/usr/bin/ctest", + "root" : "/usr/share/cmake" + }, + "version" : + { + "isDirty" : false, + "major" : 3, + "minor" : 30, + "patch" : 3, + "string" : "3.30.3", + "suffix" : "" + } + }, + "objects" : + [ + { + "jsonFile" : "codemodel-v2-9a6bcbe562446a0cf472.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 7 + } + }, + { + "jsonFile" : "cache-v2-387291ecfba8681349fe.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + { + "jsonFile" : "cmakeFiles-v1-6e3d2fd7600caa8021a8.json", + "kind" : "cmakeFiles", + "version" : + { + "major" : 1, + "minor" : 1 + } + } + ], + "reply" : + { + "cache-v2" : + { + "jsonFile" : "cache-v2-387291ecfba8681349fe.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + "cmakeFiles-v1" : + { + "jsonFile" : "cmakeFiles-v1-6e3d2fd7600caa8021a8.json", + "kind" : "cmakeFiles", + "version" : + { + "major" : 1, + "minor" : 1 + } + }, + "codemodel-v2" : + { + "jsonFile" : "codemodel-v2-9a6bcbe562446a0cf472.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 7 + } + } + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator-Debug-efd30a14e0b320172536.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator-Debug-efd30a14e0b320172536.json new file mode 100755 index 0000000..9143c2d --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator-Debug-efd30a14e0b320172536.json @@ -0,0 +1,308 @@ +{ + "artifacts" : + [ + { + "path" : "1_Calculator" + } + ], + "backtrace" : 1, + "backtraceGraph" : + { + "commands" : + [ + "add_executable", + "install", + "target_link_libraries", + "set_property", + "_populate_Widgets_target_properties", + "find_package" + ], + "files" : + [ + "CMakeLists.txt", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake", + "/usr/lib/cmake/Qt5/Qt5Config.cmake" + ], + "nodes" : + [ + { + "file" : 0 + }, + { + "command" : 0, + "file" : 0, + "line" : 39, + "parent" : 0 + }, + { + "command" : 1, + "file" : 0, + "line" : 62, + "parent" : 0 + }, + { + "command" : 2, + "file" : 0, + "line" : 45, + "parent" : 0 + }, + { + "command" : 5, + "file" : 0, + "line" : 13, + "parent" : 0 + }, + { + "file" : 2, + "parent" : 4 + }, + { + "command" : 5, + "file" : 2, + "line" : 28, + "parent" : 5 + }, + { + "file" : 1, + "parent" : 6 + }, + { + "command" : 4, + "file" : 1, + "line" : 213, + "parent" : 7 + }, + { + "command" : 3, + "file" : 1, + "line" : 57, + "parent" : 8 + } + ] + }, + "compileGroups" : + [ + { + "compileCommandFragments" : + [ + { + "fragment" : "-DQT_QML_DEBUG -g -std=gnu++17 -fdiagnostics-color=always" + }, + { + "backtrace" : 3, + "fragment" : "-fPIC" + } + ], + "defines" : + [ + { + "backtrace" : 3, + "define" : "QT_CORE_LIB" + }, + { + "backtrace" : 3, + "define" : "QT_GUI_LIB" + }, + { + "backtrace" : 3, + "define" : "QT_WIDGETS_LIB" + } + ], + "includes" : + [ + { + "backtrace" : 0, + "path" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtWidgets" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtGui" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtCore" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/lib/qt/mkspecs/linux-g++" + } + ], + "language" : "CXX", + "languageStandard" : + { + "backtraces" : + [ + 3 + ], + "standard" : "17" + }, + "sourceIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "dependencies" : + [ + { + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df" + }, + { + "backtrace" : 0, + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df" + } + ], + "id" : "1_Calculator::@6890427a1f51a3e7e1df", + "install" : + { + "destinations" : + [ + { + "backtrace" : 2, + "path" : "bin" + } + ], + "prefix" : + { + "path" : "/usr/local" + } + }, + "link" : + { + "commandFragments" : + [ + { + "fragment" : "-DQT_QML_DEBUG -g", + "role" : "flags" + }, + { + "fragment" : "", + "role" : "flags" + }, + { + "backtrace" : 3, + "fragment" : "/usr/lib/libQt5Widgets.so.5.15.14", + "role" : "libraries" + }, + { + "backtrace" : 9, + "fragment" : "/usr/lib/libQt5Gui.so.5.15.14", + "role" : "libraries" + }, + { + "backtrace" : 9, + "fragment" : "/usr/lib/libQt5Core.so.5.15.14", + "role" : "libraries" + } + ], + "language" : "CXX" + }, + "name" : "1_Calculator", + "nameOnDisk" : "1_Calculator", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sourceGroups" : + [ + { + "name" : "Source Files", + "sourceIndexes" : + [ + 0, + 1, + 2 + ] + }, + { + "name" : "Header Files", + "sourceIndexes" : + [ + 3, + 5 + ] + }, + { + "name" : "", + "sourceIndexes" : + [ + 4, + 6 + ] + }, + { + "name" : "CMake Rules", + "sourceIndexes" : + [ + 7 + ] + } + ], + "sources" : + [ + { + "backtrace" : 0, + "compileGroupIndex" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "compileGroupIndex" : 0, + "path" : "main.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "compileGroupIndex" : 0, + "path" : "mainwindow.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "path" : "mainwindow.h", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 1, + "path" : "mainwindow.ui", + "sourceGroupIndex" : 2 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/include/ui_mainwindow.h", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp", + "sourceGroupIndex" : 2 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp.rule", + "sourceGroupIndex" : 3 + } + ], + "type" : "EXECUTABLE" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json new file mode 100755 index 0000000..d1a1e64 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json @@ -0,0 +1,71 @@ +{ + "backtrace" : 0, + "backtraceGraph" : + { + "commands" : [], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + } + ] + }, + "dependencies" : + [ + { + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df" + } + ], + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df", + "isGeneratorProvided" : true, + "name" : "1_Calculator_autogen", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sourceGroups" : + [ + { + "name" : "", + "sourceIndexes" : + [ + 0 + ] + }, + { + "name" : "CMake Rules", + "sourceIndexes" : + [ + 1, + 2 + ] + } + ], + "sources" : + [ + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/1_Calculator_autogen", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.rule", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp.rule", + "sourceGroupIndex" : 1 + } + ], + "type" : "UTILITY" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json new file mode 100755 index 0000000..200ee23 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply.prev/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json @@ -0,0 +1,27 @@ +{ + "backtrace" : 0, + "backtraceGraph" : + { + "commands" : [], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + } + ] + }, + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df", + "isGeneratorProvided" : true, + "name" : "1_Calculator_autogen_timestamp_deps", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sources" : [], + "type" : "UTILITY" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cache-v2-387291ecfba8681349fe.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cache-v2-387291ecfba8681349fe.json new file mode 100755 index 0000000..140cf67 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cache-v2-387291ecfba8681349fe.json @@ -0,0 +1,1559 @@ +{ + "entries" : + [ + { + "name" : "1_Calculator_BINARY_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug" + }, + { + "name" : "1_Calculator_IS_TOP_LEVEL", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "ON" + }, + { + "name" : "1_Calculator_SOURCE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator" + }, + { + "name" : "CMAKE_ADDR2LINE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/addr2line" + }, + { + "name" : "CMAKE_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ar" + }, + { + "name" : "CMAKE_BUILD_TYPE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "Debug" + }, + { + "name" : "CMAKE_CACHEFILE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "This is the directory where this CMakeCache.txt was created" + } + ], + "type" : "INTERNAL", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug" + }, + { + "name" : "CMAKE_CACHE_MAJOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Major version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "3" + }, + { + "name" : "CMAKE_CACHE_MINOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Minor version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "30" + }, + { + "name" : "CMAKE_CACHE_PATCH_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Patch version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "3" + }, + { + "name" : "CMAKE_COLOR_DIAGNOSTICS", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Enable colored diagnostics throughout." + } + ], + "type" : "BOOL", + "value" : "1" + }, + { + "name" : "CMAKE_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/cmake" + }, + { + "name" : "CMAKE_CPACK_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to cpack program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/cpack" + }, + { + "name" : "CMAKE_CTEST_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to ctest program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/ctest" + }, + { + "name" : "CMAKE_CXX_COMPILER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "CXX compiler" + } + ], + "type" : "STRING", + "value" : "/usr/bin/g++" + }, + { + "name" : "CMAKE_CXX_COMPILER_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler" + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/gcc-ar" + }, + { + "name" : "CMAKE_CXX_COMPILER_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler" + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/gcc-ranlib" + }, + { + "name" : "CMAKE_CXX_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during all build types." + } + ], + "type" : "STRING", + "value" : "-DQT_QML_DEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "-g" + }, + { + "name" : "CMAKE_CXX_FLAGS_INIT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "-DQT_QML_DEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "-Os -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "-O3 -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "-O2 -g -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_OUTPUT_EXTENSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "" + } + ], + "type" : "STRING", + "value" : ".o" + }, + { + "name" : "CMAKE_C_COMPILER", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/clang" + }, + { + "name" : "CMAKE_C_OUTPUT_EXTENSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "" + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_DLLTOOL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_DLLTOOL-NOTFOUND" + }, + { + "name" : "CMAKE_EDIT_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to cache edit program executable." + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/ccmake" + }, + { + "name" : "CMAKE_EXECUTABLE_FORMAT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Executable file format" + } + ], + "type" : "INTERNAL", + "value" : "ELF" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXPORT_COMPILE_COMMANDS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Enable/Disable output of compile commands during generation." + } + ], + "type" : "BOOL", + "value" : "" + }, + { + "name" : "CMAKE_FIND_PACKAGE_REDIRECTS_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake." + } + ], + "type" : "STATIC", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/pkgRedirects" + }, + { + "name" : "CMAKE_GENERATOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "Ninja" + }, + { + "name" : "CMAKE_GENERATOR_INSTANCE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Generator instance identifier." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_PLATFORM", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator platform." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_TOOLSET", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator toolset." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_HOME_DIRECTORY", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Source directory with the top level CMakeLists.txt file for this project" + } + ], + "type" : "INTERNAL", + "value" : "/home/nktkln/Documents/1_Calculator" + }, + { + "name" : "CMAKE_INSTALL_BINDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "User executables (bin)" + } + ], + "type" : "PATH", + "value" : "bin" + }, + { + "name" : "CMAKE_INSTALL_DATADIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only architecture-independent data (DATAROOTDIR)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_DATAROOTDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only architecture-independent data root (share)" + } + ], + "type" : "PATH", + "value" : "share" + }, + { + "name" : "CMAKE_INSTALL_DOCDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Documentation root (DATAROOTDIR/doc/PROJECT_NAME)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_INCLUDEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "C header files (include)" + } + ], + "type" : "PATH", + "value" : "include" + }, + { + "name" : "CMAKE_INSTALL_INFODIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Info documentation (DATAROOTDIR/info)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_LIBDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Object code libraries (lib)" + } + ], + "type" : "PATH", + "value" : "lib" + }, + { + "name" : "CMAKE_INSTALL_LIBEXECDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Program executables (libexec)" + } + ], + "type" : "PATH", + "value" : "libexec" + }, + { + "name" : "CMAKE_INSTALL_LOCALEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Locale-dependent data (DATAROOTDIR/locale)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_LOCALSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Modifiable single-machine data (var)" + } + ], + "type" : "PATH", + "value" : "var" + }, + { + "name" : "CMAKE_INSTALL_MANDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Man documentation (DATAROOTDIR/man)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_OLDINCLUDEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "C header files for non-gcc (/usr/include)" + } + ], + "type" : "PATH", + "value" : "/usr/include" + }, + { + "name" : "CMAKE_INSTALL_PREFIX", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Install path prefix, prepended onto install directories." + } + ], + "type" : "PATH", + "value" : "/usr/local" + }, + { + "name" : "CMAKE_INSTALL_RUNSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Run-time variable data (LOCALSTATEDIR/run)" + } + ], + "type" : "PATH", + "value" : "" + }, + { + "name" : "CMAKE_INSTALL_SBINDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "System admin executables (sbin)" + } + ], + "type" : "PATH", + "value" : "sbin" + }, + { + "name" : "CMAKE_INSTALL_SHAREDSTATEDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Modifiable architecture-independent data (com)" + } + ], + "type" : "PATH", + "value" : "com" + }, + { + "name" : "CMAKE_INSTALL_SO_NO_EXE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Install .so files without execute permission." + } + ], + "type" : "INTERNAL", + "value" : "0" + }, + { + "name" : "CMAKE_INSTALL_SYSCONFDIR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Read-only single-machine data (etc)" + } + ], + "type" : "PATH", + "value" : "etc" + }, + { + "name" : "CMAKE_LINKER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ld" + }, + { + "name" : "CMAKE_MAKE_PROGRAM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Program used to build from build.ninja files." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ninja" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_NM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/nm" + }, + { + "name" : "CMAKE_NUMBER_OF_MAKEFILES", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "number of local generators" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_OBJCOPY", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/objcopy" + }, + { + "name" : "CMAKE_OBJDUMP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/objdump" + }, + { + "name" : "CMAKE_PLATFORM_INFO_INITIALIZED", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Platform information initialized" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_PREFIX_PATH", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "PATH", + "value" : "/usr" + }, + { + "name" : "CMAKE_PROJECT_DESCRIPTION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_HOMEPAGE_URL", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_INCLUDE_BEFORE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake" + }, + { + "name" : "CMAKE_PROJECT_NAME", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1_Calculator" + }, + { + "name" : "CMAKE_PROJECT_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "0.1" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MAJOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "0" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MINOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1" + }, + { + "name" : "CMAKE_PROJECT_VERSION_PATCH", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_VERSION_TWEAK", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/ranlib" + }, + { + "name" : "CMAKE_READELF", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/readelf" + }, + { + "name" : "CMAKE_ROOT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake installation." + } + ], + "type" : "INTERNAL", + "value" : "/usr/share/cmake" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SKIP_INSTALL_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when installing shared libraries, but are added when building." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_SKIP_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when using shared libraries." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STRIP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/strip" + }, + { + "name" : "CMAKE_TAPI", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_TAPI-NOTFOUND" + }, + { + "name" : "CMAKE_UNAME", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "uname command" + } + ], + "type" : "INTERNAL", + "value" : "/usr/bin/uname" + }, + { + "name" : "CMAKE_VERBOSE_MAKEFILE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only. With Visual Studio IDE projects all commands are done without /nologo." + } + ], + "type" : "BOOL", + "value" : "FALSE" + }, + { + "name" : "QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Skip Qt Creator's package manager auto-setup" + } + ], + "type" : "BOOL", + "value" : "OFF" + }, + { + "name" : "QT_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for QT." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5" + }, + { + "name" : "QT_QMAKE_EXECUTABLE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "/usr/bin/qmake" + }, + { + "name" : "Qt5Core_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Core." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Core" + }, + { + "name" : "Qt5Gui_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Gui." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Gui" + }, + { + "name" : "Qt5Widgets_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5Widgets." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5Widgets" + }, + { + "name" : "Qt5_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "The directory containing a CMake configuration file for Qt5." + } + ], + "type" : "PATH", + "value" : "/usr/lib/cmake/Qt5" + }, + { + "name" : "_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "linker supports push/pop state" + } + ], + "type" : "INTERNAL", + "value" : "TRUE" + }, + { + "name" : "_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "CMAKE_INSTALL_PREFIX during last run" + } + ], + "type" : "INTERNAL", + "value" : "/usr/local" + } + ], + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cmakeFiles-v1-21dd0959b8f68e4119cc.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cmakeFiles-v1-21dd0959b8f68e4119cc.json new file mode 100755 index 0000000..a45969a --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/cmakeFiles-v1-21dd0959b8f68e4119cc.json @@ -0,0 +1,325 @@ +{ + "inputs" : + [ + { + "path" : "CMakeLists.txt" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake" + }, + { + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeGenericSystem.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/UnixPaths.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCXXInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeLanguageInformation.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/GNU.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/Platform/Linux-GNU.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5Config.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5Config.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseArguments.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake" + }, + { + "isExternal" : true, + "path" : "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/CMakeParseArguments.cmake" + }, + { + "isCMake" : true, + "isExternal" : true, + "path" : "/usr/share/cmake/Modules/GNUInstallDirs.cmake" + } + ], + "kind" : "cmakeFiles", + "paths" : + { + "build" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "source" : "/home/nktkln/Documents/1_Calculator" + }, + "version" : + { + "major" : 1, + "minor" : 1 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/codemodel-v2-1fd6d71a0b9d0a4a4af3.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/codemodel-v2-1fd6d71a0b9d0a4a4af3.json new file mode 100755 index 0000000..249cd79 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/codemodel-v2-1fd6d71a0b9d0a4a4af3.json @@ -0,0 +1,79 @@ +{ + "configurations" : + [ + { + "directories" : + [ + { + "build" : ".", + "hasInstallRule" : true, + "jsonFile" : "directory-.-Debug-5850f714bd1b698df6da.json", + "minimumCMakeVersion" : + { + "string" : "3.16" + }, + "projectIndex" : 0, + "source" : ".", + "targetIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "name" : "Debug", + "projects" : + [ + { + "directoryIndexes" : + [ + 0 + ], + "name" : "1_Calculator", + "targetIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "targets" : + [ + { + "directoryIndex" : 0, + "id" : "1_Calculator::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator-Debug-c4868d6c984c8a4dfc72.json", + "name" : "1_Calculator", + "projectIndex" : 0 + }, + { + "directoryIndex" : 0, + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json", + "name" : "1_Calculator_autogen", + "projectIndex" : 0 + }, + { + "directoryIndex" : 0, + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df", + "jsonFile" : "target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json", + "name" : "1_Calculator_autogen_timestamp_deps", + "projectIndex" : 0 + } + ] + } + ], + "kind" : "codemodel", + "paths" : + { + "build" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "source" : "/home/nktkln/Documents/1_Calculator" + }, + "version" : + { + "major" : 2, + "minor" : 7 + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/directory-.-Debug-5850f714bd1b698df6da.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/directory-.-Debug-5850f714bd1b698df6da.json new file mode 100755 index 0000000..acab6eb --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/directory-.-Debug-5850f714bd1b698df6da.json @@ -0,0 +1,45 @@ +{ + "backtraceGraph" : + { + "commands" : + [ + "install" + ], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + }, + { + "command" : 0, + "file" : 0, + "line" : 63, + "parent" : 0 + } + ] + }, + "installers" : + [ + { + "backtrace" : 1, + "component" : "Unspecified", + "destination" : "bin", + "paths" : + [ + "1_Calculator" + ], + "targetId" : "1_Calculator::@6890427a1f51a3e7e1df", + "targetIndex" : 0, + "type" : "target" + } + ], + "paths" : + { + "build" : ".", + "source" : "." + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/index-2024-09-14T08-39-45-0241.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/index-2024-09-14T08-39-45-0241.json new file mode 100755 index 0000000..83187b7 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/index-2024-09-14T08-39-45-0241.json @@ -0,0 +1,89 @@ +{ + "cmake" : + { + "generator" : + { + "multiConfig" : false, + "name" : "Ninja" + }, + "paths" : + { + "cmake" : "/usr/bin/cmake", + "cpack" : "/usr/bin/cpack", + "ctest" : "/usr/bin/ctest", + "root" : "/usr/share/cmake" + }, + "version" : + { + "isDirty" : false, + "major" : 3, + "minor" : 30, + "patch" : 3, + "string" : "3.30.3", + "suffix" : "" + } + }, + "objects" : + [ + { + "jsonFile" : "codemodel-v2-1fd6d71a0b9d0a4a4af3.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 7 + } + }, + { + "jsonFile" : "cache-v2-387291ecfba8681349fe.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + { + "jsonFile" : "cmakeFiles-v1-21dd0959b8f68e4119cc.json", + "kind" : "cmakeFiles", + "version" : + { + "major" : 1, + "minor" : 1 + } + } + ], + "reply" : + { + "cache-v2" : + { + "jsonFile" : "cache-v2-387291ecfba8681349fe.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + "cmakeFiles-v1" : + { + "jsonFile" : "cmakeFiles-v1-21dd0959b8f68e4119cc.json", + "kind" : "cmakeFiles", + "version" : + { + "major" : 1, + "minor" : 1 + } + }, + "codemodel-v2" : + { + "jsonFile" : "codemodel-v2-1fd6d71a0b9d0a4a4af3.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 7 + } + } + } +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator-Debug-c4868d6c984c8a4dfc72.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator-Debug-c4868d6c984c8a4dfc72.json new file mode 100755 index 0000000..89110b3 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator-Debug-c4868d6c984c8a4dfc72.json @@ -0,0 +1,321 @@ +{ + "artifacts" : + [ + { + "path" : "1_Calculator" + } + ], + "backtrace" : 1, + "backtraceGraph" : + { + "commands" : + [ + "add_executable", + "install", + "target_link_libraries", + "set_property", + "_populate_Widgets_target_properties", + "find_package" + ], + "files" : + [ + "CMakeLists.txt", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake", + "/usr/lib/cmake/Qt5/Qt5Config.cmake" + ], + "nodes" : + [ + { + "file" : 0 + }, + { + "command" : 0, + "file" : 0, + "line" : 39, + "parent" : 0 + }, + { + "command" : 1, + "file" : 0, + "line" : 63, + "parent" : 0 + }, + { + "command" : 2, + "file" : 0, + "line" : 46, + "parent" : 0 + }, + { + "command" : 5, + "file" : 0, + "line" : 13, + "parent" : 0 + }, + { + "file" : 2, + "parent" : 4 + }, + { + "command" : 5, + "file" : 2, + "line" : 28, + "parent" : 5 + }, + { + "file" : 1, + "parent" : 6 + }, + { + "command" : 4, + "file" : 1, + "line" : 213, + "parent" : 7 + }, + { + "command" : 3, + "file" : 1, + "line" : 57, + "parent" : 8 + } + ] + }, + "compileGroups" : + [ + { + "compileCommandFragments" : + [ + { + "fragment" : "-DQT_QML_DEBUG -g -std=gnu++17 -fdiagnostics-color=always" + }, + { + "backtrace" : 3, + "fragment" : "-fPIC" + } + ], + "defines" : + [ + { + "backtrace" : 3, + "define" : "QT_CORE_LIB" + }, + { + "backtrace" : 3, + "define" : "QT_GUI_LIB" + }, + { + "backtrace" : 3, + "define" : "QT_WIDGETS_LIB" + } + ], + "includes" : + [ + { + "backtrace" : 0, + "path" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtWidgets" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtGui" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/include/qt/QtCore" + }, + { + "backtrace" : 3, + "isSystem" : true, + "path" : "/usr/lib/qt/mkspecs/linux-g++" + } + ], + "language" : "CXX", + "languageStandard" : + { + "backtraces" : + [ + 3 + ], + "standard" : "17" + }, + "sourceIndexes" : + [ + 0, + 1, + 2 + ] + } + ], + "dependencies" : + [ + { + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df" + }, + { + "backtrace" : 0, + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df" + } + ], + "id" : "1_Calculator::@6890427a1f51a3e7e1df", + "install" : + { + "destinations" : + [ + { + "backtrace" : 2, + "path" : "bin" + } + ], + "prefix" : + { + "path" : "/usr/local" + } + }, + "link" : + { + "commandFragments" : + [ + { + "fragment" : "-DQT_QML_DEBUG -g", + "role" : "flags" + }, + { + "fragment" : "", + "role" : "flags" + }, + { + "backtrace" : 3, + "fragment" : "/usr/lib/libQt5Widgets.so.5.15.14", + "role" : "libraries" + }, + { + "backtrace" : 9, + "fragment" : "/usr/lib/libQt5Gui.so.5.15.14", + "role" : "libraries" + }, + { + "backtrace" : 9, + "fragment" : "/usr/lib/libQt5Core.so.5.15.14", + "role" : "libraries" + } + ], + "language" : "CXX" + }, + "name" : "1_Calculator", + "nameOnDisk" : "1_Calculator", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sourceGroups" : + [ + { + "name" : "Source Files", + "sourceIndexes" : + [ + 0, + 1, + 2 + ] + }, + { + "name" : "Header Files", + "sourceIndexes" : + [ + 3, + 6, + 7 + ] + }, + { + "name" : "", + "sourceIndexes" : + [ + 4, + 5, + 8 + ] + }, + { + "name" : "CMake Rules", + "sourceIndexes" : + [ + 9 + ] + } + ], + "sources" : + [ + { + "backtrace" : 0, + "compileGroupIndex" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "compileGroupIndex" : 0, + "path" : "main.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "compileGroupIndex" : 0, + "path" : "mainwindow.cpp", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 1, + "path" : "mainwindow.h", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 1, + "path" : "mainwindow.ui", + "sourceGroupIndex" : 2 + }, + { + "backtrace" : 1, + "path" : "programmingwindow.ui", + "sourceGroupIndex" : 2 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/include/ui_mainwindow.h", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/include/ui_programmingwindow.h", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp", + "sourceGroupIndex" : 2 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp.rule", + "sourceGroupIndex" : 3 + } + ], + "type" : "EXECUTABLE" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json new file mode 100755 index 0000000..d1a1e64 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen-Debug-d84c4c6f772a36ae6725.json @@ -0,0 +1,71 @@ +{ + "backtrace" : 0, + "backtraceGraph" : + { + "commands" : [], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + } + ] + }, + "dependencies" : + [ + { + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df" + } + ], + "id" : "1_Calculator_autogen::@6890427a1f51a3e7e1df", + "isGeneratorProvided" : true, + "name" : "1_Calculator_autogen", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sourceGroups" : + [ + { + "name" : "", + "sourceIndexes" : + [ + 0 + ] + }, + { + "name" : "CMake Rules", + "sourceIndexes" : + [ + 1, + 2 + ] + } + ], + "sources" : + [ + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/1_Calculator_autogen", + "sourceGroupIndex" : 0 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.rule", + "sourceGroupIndex" : 1 + }, + { + "backtrace" : 0, + "isGenerated" : true, + "path" : "build/Desktop-Debug/1_Calculator_autogen/timestamp.rule", + "sourceGroupIndex" : 1 + } + ], + "type" : "UTILITY" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json new file mode 100755 index 0000000..200ee23 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.cmake/api/v1/reply/target-1_Calculator_autogen_timestamp_deps-Debug-37da397c7bdbb094b53e.json @@ -0,0 +1,27 @@ +{ + "backtrace" : 0, + "backtraceGraph" : + { + "commands" : [], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + } + ] + }, + "id" : "1_Calculator_autogen_timestamp_deps::@6890427a1f51a3e7e1df", + "isGeneratorProvided" : true, + "name" : "1_Calculator_autogen_timestamp_deps", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sources" : [], + "type" : "UTILITY" +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_deps b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_deps new file mode 100755 index 0000000..3e74f68 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_deps differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_log b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_log new file mode 100755 index 0000000..755c656 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.ninja_log @@ -0,0 +1,9 @@ +# ninja log v6 +168 1416 1726074065901842838 CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o d72cd826d4b52de4 +3000 3459 1726303075477636614 1_Calculator 9d042004c4478eec +59 3000 1726303072534328090 CMakeFiles/1_Calculator.dir/mainwindow.cpp.o 88992c7d599ee023 +168 1547 1726074065901842838 CMakeFiles/1_Calculator.dir/main.cpp.o bf3b845f7c15b47b +3 58 1726303072480995211 /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp 31fb23e5b177427a +3 58 1726303072480995211 /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/timestamp 31fb23e5b177427a +3 58 1726303072480995211 1_Calculator_autogen/mocs_compilation.cpp 31fb23e5b177427a +3 58 1726303072480995211 1_Calculator_autogen/timestamp 31fb23e5b177427a diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/LICENSE.conan b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/LICENSE.conan new file mode 100755 index 0000000..541f5a3 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/LICENSE.conan @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake new file mode 100755 index 0000000..628b69c --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake @@ -0,0 +1,269 @@ +# +# Internal Qt Creator variable reference +# +foreach(qtcreator_var + QT_QMAKE_EXECUTABLE CMAKE_PREFIX_PATH CMAKE_C_COMPILER CMAKE_CXX_COMPILER + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO) + set(__just_reference_${qtcreator_var} ${${qtcreator_var}}) +endforeach() + +if (EXISTS "${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake") + include("${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake") +endif() + +if (QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP) + return() +endif() +option(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP "Skip Qt Creator's package manager auto-setup" OFF) + +# Store the C/C++ object output extension +if (CMAKE_VERSION GREATER_EQUAL "3.19") + cmake_language(DEFER CALL set CMAKE_C_OUTPUT_EXTENSION "${CMAKE_C_OUTPUT_EXTENSION}" CACHE STRING "" FORCE) + cmake_language(DEFER CALL set CMAKE_CXX_OUTPUT_EXTENSION "${CMAKE_CXX_OUTPUT_EXTENSION}" CACHE STRING "" FORCE) +endif() + +macro(qtc_auto_setup_compiler_standard toolchainFile) + foreach(lang_var C CXX CUDA OBJC OBJCXX) + foreach(prop_var STANDARD STANDARD_REQUIRED EXTENSIONS) + if (CMAKE_${lang_var}_${prop_var}) + file(APPEND "${toolchainFile}" + "set(CMAKE_${lang_var}_${prop_var} ${CMAKE_${lang_var}_${prop_var}})\n") + endif() + endforeach() + endforeach() + + # Forward important CMake variables to the package manager in the toolchain file + foreach(fwd_var CMAKE_MSVC_RUNTIME_LIBRARY CMAKE_SYSROOT CMAKE_OSX_SYSROOT CMAKE_OSX_ARCHITECTURES) + if (${fwd_var}) + file(APPEND "${toolchainFile}" + "set(${fwd_var} ${${fwd_var}})\n") + endif() + endforeach() +endmacro() + +# +# conan +# +macro(qtc_auto_setup_conan) + foreach(file conanfile.txt conanfile.py) + if (EXISTS "${CMAKE_SOURCE_DIR}/${file}") + set(conanfile_txt "${CMAKE_SOURCE_DIR}/${file}") + break() + endif() + endforeach() + + if (conanfile_txt AND NOT QT_CREATOR_SKIP_CONAN_SETUP) + option(QT_CREATOR_SKIP_CONAN_SETUP "Skip Qt Creator's conan package manager auto-setup" OFF) + set(QT_CREATOR_CONAN_BUILD_POLICY "missing" CACHE STRING "Qt Creator's conan package manager auto-setup build policy. This is used for the BUILD property of cmake_conan_run") + + find_program(conan_program conan) + if (NOT conan_program) + message(WARNING "Qt Creator: conan executable not found. " + "Package manager auto-setup will be skipped. " + "To disable this warning set QT_CREATOR_SKIP_CONAN_SETUP to ON.") + return() + endif() + execute_process(COMMAND ${conan_program} --version + RESULT_VARIABLE result_code + OUTPUT_VARIABLE conan_version_output + ERROR_VARIABLE conan_version_output) + if (NOT result_code EQUAL 0) + message(FATAL_ERROR "conan --version failed='${result_code}: ${conan_version_output}") + endif() + + string(REGEX REPLACE ".*Conan version ([0-9].[0-9]).*" "\\1" conan_version "${conan_version_output}") + + set(conanfile_timestamp_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.timestamp") + file(TIMESTAMP "${conanfile_txt}" conanfile_timestamp) + + set(do_conan_installation ON) + if (EXISTS "${conanfile_timestamp_file}") + file(READ "${conanfile_timestamp_file}" old_conanfile_timestamp) + if ("${conanfile_timestamp}" STREQUAL "${old_conanfile_timestamp}") + set(do_conan_installation OFF) + endif() + endif() + + set(conanfile_build_policy_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.buildpolicy") + if (EXISTS "${conanfile_build_policy_file}") + file(READ "${conanfile_build_policy_file}" build_policy) + if (NOT "${build_policy}" STREQUAL "${QT_CREATOR_CONAN_BUILD_POLICY}") + set(do_conan_installation ON) + endif() + endif() + + if (do_conan_installation) + message(STATUS "Qt Creator: conan package manager auto-setup. " + "Skip this step by setting QT_CREATOR_SKIP_CONAN_SETUP to ON.") + + file(COPY "${conanfile_txt}" DESTINATION "${CMAKE_BINARY_DIR}/conan-dependencies/") + + file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" " + set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\") + set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\") + ") + qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake") + + if (CMAKE_TOOLCHAIN_FILE) + file(APPEND "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" + "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n") + endif() + + file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/CMakeLists.txt" " + cmake_minimum_required(VERSION 3.15) + + unset(CMAKE_PROJECT_INCLUDE_BEFORE CACHE) + project(conan-setup) + + if (${conan_version} VERSION_GREATER_EQUAL 2.0) + set(CONAN_COMMAND \"${conan_program}\") + include(\"${CMAKE_CURRENT_LIST_DIR}/conan_provider.cmake\") + conan_profile_detect_default() + detect_host_profile(\"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\") + + set(build_types \${CMAKE_BUILD_TYPE}) + if (CMAKE_CONFIGURATION_TYPES) + set(build_types \${CMAKE_CONFIGURATION_TYPES}) + endif() + + foreach(type \${build_types}) + conan_install( + -pr \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\" + --build=${QT_CREATOR_CONAN_BUILD_POLICY} + -s build_type=\${type} + -g CMakeDeps) + endforeach() + + get_property(CONAN_INSTALL_SUCCESS GLOBAL PROPERTY CONAN_INSTALL_SUCCESS) + if (CONAN_INSTALL_SUCCESS) + get_property(CONAN_GENERATORS_FOLDER GLOBAL PROPERTY CONAN_GENERATORS_FOLDER) + file(TO_CMAKE_PATH \"\${CONAN_GENERATORS_FOLDER}\" CONAN_GENERATORS_FOLDER) + file(WRITE \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake\" \" + list(PREPEND CMAKE_PREFIX_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(PREPEND CMAKE_MODULE_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(PREPEND CMAKE_FIND_ROOT_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(REMOVE_DUPLICATES CMAKE_PREFIX_PATH) + list(REMOVE_DUPLICATES CMAKE_MODULE_PATH) + list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH) + set(CMAKE_PREFIX_PATH \\\"\\\${CMAKE_PREFIX_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + set(CMAKE_MODULE_PATH \\\"\\\${CMAKE_MODULE_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + set(CMAKE_FIND_ROOT_PATH \\\"\\\${CMAKE_FIND_ROOT_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + \") + endif() + else() + include(\"${CMAKE_CURRENT_LIST_DIR}/conan.cmake\") + conan_cmake_run( + CONANFILE \"${conanfile_txt}\" + INSTALL_FOLDER \"${CMAKE_BINARY_DIR}/conan-dependencies\" + GENERATORS cmake_paths cmake_find_package json + BUILD ${QT_CREATOR_CONAN_BUILD_POLICY} + ENV CONAN_CMAKE_TOOLCHAIN_FILE=\"${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake\" + ) + endif() + ") + + if (NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES) + set(CMAKE_CONFIGURATION_TYPES "Debug;Release") + endif() + + execute_process(COMMAND ${CMAKE_COMMAND} + -S "${CMAKE_BINARY_DIR}/conan-dependencies/" + -B "${CMAKE_BINARY_DIR}/conan-dependencies/build" + -C "${CMAKE_BINARY_DIR}/qtcsettings.cmake" + -D "CMAKE_TOOLCHAIN_FILE=${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" + -G ${CMAKE_GENERATOR} + -D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -D "CMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}" + RESULT_VARIABLE result + ) + if (result EQUAL 0) + file(WRITE "${conanfile_timestamp_file}" "${conanfile_timestamp}") + file(WRITE "${conanfile_build_policy_file}" ${QT_CREATOR_CONAN_BUILD_POLICY}) + else() + message(WARNING "Qt Creator's conan package manager auto-setup failed. Consider setting " + "QT_CREATOR_SKIP_CONAN_SETUP to ON and reconfigure to skip this step.") + return() + endif() + endif() + + include("${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake") + endif() + unset(conanfile_txt) +endmacro() +qtc_auto_setup_conan() + +# +# vcpkg +# +macro(qtc_auto_setup_vcpkg) + if (EXISTS "${CMAKE_SOURCE_DIR}/vcpkg.json" AND NOT QT_CREATOR_SKIP_VCPKG_SETUP) + option(QT_CREATOR_SKIP_VCPKG_SETUP "Skip Qt Creator's vcpkg package manager auto-setup" OFF) + + find_program(vcpkg_program vcpkg $ENV{VCPKG_ROOT} ${CMAKE_SOURCE_DIR}/vcpkg) + if (NOT vcpkg_program) + message(WARNING "Qt Creator: vcpkg executable not found. " + "Package manager auto-setup will be skipped. " + "To disable this warning set QT_CREATOR_SKIP_VCPKG_SETUP to ON.") + return() + endif() + execute_process(COMMAND ${vcpkg_program} version + RESULT_VARIABLE result_code + OUTPUT_VARIABLE vcpkg_version_output + ERROR_VARIABLE vcpkg_version_output) + if (NOT result_code EQUAL 0) + message(FATAL_ERROR "vcpkg version failed='${result_code}: ${vcpkg_version_output}") + endif() + + # Resolve any symlinks + get_filename_component(vpkg_program_real_path ${vcpkg_program} REALPATH) + get_filename_component(vpkg_root ${vpkg_program_real_path} DIRECTORY) + + if (NOT EXISTS "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + message(STATUS "Qt Creator: vcpkg package manager auto-setup. " + "Skip this step by setting QT_CREATOR_SKIP_VCPKG_SETUP to ON.") + + file(WRITE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" " + set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\") + set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\") + ") + qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + + if (CMAKE_TOOLCHAIN_FILE AND NOT + CMAKE_TOOLCHAIN_FILE STREQUAL "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" + "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n") + endif() + + if (VCPKG_TARGET_TRIPLET) + set(vcpkg_triplet ${VCPKG_TARGET_TRIPLET}) + else() + if (WIN32) + set(vcpkg_triplet x64-mingw-static) + if (CMAKE_CXX_COMPILER MATCHES ".*/(.*)/cl.exe") + set(vcpkg_triplet ${CMAKE_MATCH_1}-windows) + endif() + elseif(APPLE) + set(vcpkg_triplet x64-osx) + else() + set(vcpkg_triplet x64-linux) + endif() + endif() + + file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" " + set(VCPKG_TARGET_TRIPLET ${vcpkg_triplet}) + include(\"${vpkg_root}/scripts/buildsystems/vcpkg.cmake\") + ") + endif() + + set(CMAKE_TOOLCHAIN_FILE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" CACHE PATH "" FORCE) + + # Save CMAKE_PREFIX_PATH and CMAKE_MODULE_PATH as cache variables + if (CMAKE_VERSION GREATER_EQUAL "3.19") + cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_PREFIX_PATH) + cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_MODULE_PATH) + cmake_language(DEFER CALL set CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}" CACHE STRING "" FORCE) + cmake_language(DEFER CALL set CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" CACHE STRING "" FORCE) + endif() + endif() +endmacro() +qtc_auto_setup_vcpkg() diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan.cmake new file mode 100755 index 0000000..4f5f67e --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan.cmake @@ -0,0 +1,1026 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 JFrog + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + + +# This file comes from: https://github.com/conan-io/cmake-conan. Please refer +# to this repository for issues and documentation. + +# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called. +# It will take CMake current settings (os, compiler, compiler version, architecture) +# and translate them to conan settings for installing and retrieving dependencies. + +# It is intended to facilitate developers building projects that have conan dependencies, +# but it is only necessary on the end-user side. It is not necessary to create conan +# packages, in fact it shouldn't be use for that. Check the project documentation. + +# version: 0.18.1 + +include(CMakeParseArguments) + +function(_get_msvc_ide_version result) + set(${result} "" PARENT_SCOPE) + if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500) + set(${result} 8 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600) + set(${result} 9 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700) + set(${result} 10 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800) + set(${result} 11 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900) + set(${result} 12 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910) + set(${result} 14 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920) + set(${result} 15 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930) + set(${result} 16 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940) + set(${result} 17 PARENT_SCOPE) + else() + message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]") + endif() +endfunction() + +macro(_conan_detect_build_type) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE}) + elseif(CMAKE_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE}) + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER) + if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG") + set(_CONAN_SETTING_BUILD_TYPE "Debug") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE") + set(_CONAN_SETTING_BUILD_TYPE "Release") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO") + set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL") + set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel") + endif() +endmacro() + +macro(_conan_check_system_name) + #handle -s os setting + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + #use default conan os setting if CMAKE_SYSTEM_NAME is not defined + set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set(CONAN_SYSTEM_NAME Macos) + endif() + if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX") + set(CONAN_SYSTEM_NAME Neutrino) + endif() + set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino) + list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index) + if (${_index} GREATER -1) + #check if the cmake system is a conan supported one + set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME}) + else() + message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}") + endif() + endif() +endmacro() + +macro(_conan_check_language) + get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES) + if (";${_languages};" MATCHES ";CXX;") + set(LANGUAGE CXX) + set(USING_CXX 1) + elseif (";${_languages};" MATCHES ";C;") + set(LANGUAGE C) + set(USING_CXX 0) + else () + message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.") + endif() +endmacro() + +macro(_conan_detect_compiler) + + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_ARCH) + set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH}) + endif() + + if(USING_CXX) + set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD}) + endif() + + if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU) + # using GCC + # TODO: Handle other params + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + if(${MAJOR} GREATER 4) + set(COMPILER_VERSION ${MAJOR}) + endif() + set(_CONAN_SETTING_COMPILER gcc) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + set(_CONAN_SETTING_COMPILER intel) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang) + # using AppleClang + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER apple-clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang + AND NOT "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" + AND NOT "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC") + + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if(APPLE) + cmake_policy(GET CMP0025 APPLE_CLANG_POLICY) + if(NOT APPLE_CLANG_POLICY STREQUAL NEW) + message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it") + set(_CONAN_SETTING_COMPILER apple-clang) + endif() + endif() + if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}) + endif() + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC + OR (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang + AND "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" + AND "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC")) + + set(_VISUAL "Visual Studio") + _get_msvc_ide_version(_VISUAL_VERSION) + if("${_VISUAL_VERSION}" STREQUAL "") + message(FATAL_ERROR "Conan: Visual Studio not recognized") + else() + set(_CONAN_SETTING_COMPILER ${_VISUAL}) + set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION}) + endif() + + if(NOT _CONAN_SETTING_ARCH) + if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64") + set(_CONAN_SETTING_ARCH x86_64) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM") + message(STATUS "Conan: Using default ARM architecture from MSVC") + set(_CONAN_SETTING_ARCH armv6) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86") + set(_CONAN_SETTING_ARCH x86) + else () + message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]") + endif() + endif() + + conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV}) + message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}") + set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime}) + + if (CMAKE_GENERATOR_TOOLSET) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja")) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + endif() + else() + message(FATAL_ERROR "Conan: compiler setup not recognized") + endif() + +endmacro() + +function(conan_cmake_settings result) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER}) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID}) + #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION}) + #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS}) + #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE}) + #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE}) + #message(STATUS "GENERATOR " ${CMAKE_GENERATOR}) + #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64}) + + message(STATUS "Conan: Automatic detection of conan settings from cmake") + + conan_parse_arguments(${ARGV}) + + _conan_detect_build_type(${ARGV}) + + _conan_check_system_name() + + _conan_check_language() + + _conan_detect_compiler(${ARGV}) + + # If profile is defined it is used + if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE}) + elseif(ARGUMENTS_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE}) + endif() + + foreach(ARG ${_APPLIED_PROFILES}) + set(_SETTINGS ${_SETTINGS} -pr=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_PROFILE_BUILD}) + conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET) + set(_SETTINGS ${_SETTINGS} -pr:b=${ARG}) + endforeach() + + if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL") + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset) + endif() + + # remove any manually specified settings from the autodetected settings + foreach(ARG ${ARGUMENTS_SETTINGS}) + string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}") + message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.") + list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}") + endforeach() + + # Automatic from CMake + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + + foreach(ARG ${ARGUMENTS_SETTINGS}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}) + endforeach() + + message(STATUS "Conan: Settings= ${_SETTINGS}") + + set(${result} ${_SETTINGS} PARENT_SCOPE) +endfunction() + + +function(conan_cmake_detect_unix_libcxx result) + # Take into account any -stdlib in compile options + get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) + string(GENEX_STRIP "${compile_options}" compile_options) + + # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions + get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) + string(GENEX_STRIP "${defines}" defines) + + foreach(define ${defines}) + if(define MATCHES "_GLIBCXX_USE_CXX11_ABI") + if(define MATCHES "^-D") + set(compile_options ${compile_options} "${define}") + else() + set(compile_options ${compile_options} "-D${define}") + endif() + endif() + endforeach() + + # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable + set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER}) + if(CMAKE_CXX_COMPILER_ARG1) + # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz" + # without this, ccache, winegcc, or other wrappers might lose all their arguments + separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1}) + list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1}) + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET) + # without --target= we may be calling the wrong underlying GCC + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT) + # without --sysroot= we may find the wrong #include + if(CMAKE_SYSROOT_COMPILE) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}") + elseif(CMAKE_SYSROOT) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}") + endif() + endif() + + separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + + if(CMAKE_OSX_SYSROOT) + set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}") + endif() + + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo "#include " + COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM - + OUTPUT_VARIABLE string_defines + ) + + if(string_defines MATCHES "#define __GLIBCXX__") + # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake + if(DEFINED _GLIBCXX_USE_CXX11_ABI) + if(_GLIBCXX_USE_CXX11_ABI) + set(${result} libstdc++11 PARENT_SCOPE) + return() + else() + set(${result} libstdc++ PARENT_SCOPE) + return() + endif() + endif() + + if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n") + set(${result} libstdc++11 PARENT_SCOPE) + else() + # Either the compiler is missing the define because it is old, and so + # it can't use the new abi, or the compiler was configured to use the + # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS) + set(${result} libstdc++ PARENT_SCOPE) + endif() + else() + set(${result} libc++ PARENT_SCOPE) + endif() +endfunction() + +function(conan_cmake_detect_vs_runtime result) + + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_BUILD_TYPE) + set(build_type "${ARGUMENTS_BUILD_TYPE}") + elseif(CMAKE_BUILD_TYPE) + set(build_type "${CMAKE_BUILD_TYPE}") + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + if(build_type) + string(TOUPPER "${build_type}" build_type) + endif() + set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS) + foreach(variable ${variables}) + if(NOT "${${variable}}" STREQUAL "") + string(REPLACE " " ";" flags "${${variable}}") + foreach (flag ${flags}) + if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd") + string(SUBSTRING "${flag}" 1 -1 runtime) + set(${result} "${runtime}" PARENT_SCOPE) + return() + endif() + endforeach() + endif() + endforeach() + if("${build_type}" STREQUAL "DEBUG") + set(${result} "MDd" PARENT_SCOPE) + else() + set(${result} "MD" PARENT_SCOPE) + endif() +endfunction() + +function(_collect_settings result) + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset + compiler.cppstd) + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + set(${result} ${detected_setings} PARENT_SCOPE) +endfunction() + +function(conan_cmake_autodetect detected_settings) + _conan_detect_build_type(${ARGV}) + _conan_check_system_name() + _conan_check_language() + _conan_detect_compiler(${ARGV}) + _collect_settings(collected_settings) + set(${detected_settings} ${collected_settings} PARENT_SCOPE) +endfunction() + +macro(conan_parse_arguments) + set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD) + set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER OUTPUT_FOLDER CONAN_COMMAND) + set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE + PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO + INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES) + cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) +endmacro() + +function(old_conan_cmake_install) + # Calls "conan install" + # Argument BUILD is equivalant to --build={missing, PkgName,...} or + # --build when argument is 'BUILD all' (which builds all packages from source) + # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source + # cmake does not identify conan as command, even if it is +x and it is in the path + conan_parse_arguments(${ARGV}) + + if(CONAN_CMAKE_MULTI) + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi) + else() + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake) + endif() + + set(CONAN_BUILD_POLICY "") + foreach(ARG ${ARGUMENTS_BUILD}) + if(${ARG} STREQUAL "all") + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build) + break() + else() + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG}) + endif() + endforeach() + if(ARGUMENTS_CONAN_COMMAND) + set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + set(CONAN_OPTIONS "") + if(ARGUMENTS_CONANFILE) + if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE}) + set(CONANFILE ${ARGUMENTS_CONANFILE}) + else() + set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE}) + endif() + else() + set(CONANFILE ".") + endif() + foreach(ARG ${ARGUMENTS_OPTIONS}) + set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG}) + endforeach() + if(ARGUMENTS_UPDATE) + set(CONAN_INSTALL_UPDATE --update) + endif() + if(ARGUMENTS_NO_IMPORTS) + set(CONAN_INSTALL_NO_IMPORTS --no-imports) + endif() + set(CONAN_INSTALL_FOLDER "") + if(ARGUMENTS_INSTALL_FOLDER) + set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER}) + endif() + set(CONAN_OUTPUT_FOLDER "") + if(ARGUMENTS_OUTPUT_FOLDER) + set(CONAN_OUTPUT_FOLDER -of=${ARGUMENTS_OUTPUT_FOLDER}) + endif() + foreach(ARG ${ARGUMENTS_GENERATORS}) + set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_ENV}) + set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG}) + endforeach() + set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS}) + + string (REPLACE ";" " " _conan_args "${conan_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}") + + if(ARGUMENTS_OUTPUT_QUIET) + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_output + ERROR_VARIABLE conan_output + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + else() + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + +endfunction() + +function(conan_cmake_install) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET) + set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER OUTPUT_FOLDER) + set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) + cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN}) + foreach(arg ${installOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID") + set(flag "--lockfile-node-id") + elseif("${arg}" STREQUAL "INSTALL_FOLDER") + set(flag "--install-folder") + elseif("${arg}" STREQUAL "OUTPUT_FOLDER") + set(flag "--output-folder") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "GENERATOR") + set(flag "--generator") + elseif("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED NO_IMPORTS) + set(NO_IMPORTS --no-imports) + endif() + set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} ${OUTPUT_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) + + string(REPLACE ";" " " _install_args "${install_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${install_args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan install failed='${return_code}'") + else() + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + endif() + +endfunction() + +function(conan_cmake_lock_create) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(lockCreateOptions UPDATE BASE OUTPUT_QUIET ERROR_QUIET) + set(lockCreateOneValueArgs PATH REFERENCE REMOTE LOCKFILE LOCKFILE_OUT) + set(lockCreateMultiValueArgs BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) + cmake_parse_arguments(ARGS "${lockCreateOptions}" "${lockCreateOneValueArgs}" "${lockCreateMultiValueArgs}" ${ARGN}) + foreach(arg ${lockCreateOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${lockCreateOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${lockCreateMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED BASE) + set(BASE --base) + endif() + set(lock_create_Args lock create ${PATH} ${REFERENCE} ${UPDATE} ${BASE} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) + + string(REPLACE ";" " " _lock_create_Args "${lock_create_Args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_lock_create_Args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${lock_create_Args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan lock create failed='${return_code}'") + else() + message(FATAL_ERROR "Conan lock create failed='${return_code}'") + endif() + endif() +endfunction() + +function(conan_cmake_setup_conanfile) + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_CONANFILE) + get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME) + # configure_file will make sure cmake re-runs when conanfile is updated + configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY) + file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk) + else() + conan_cmake_generate_conanfile(ON ${ARGV}) + endif() +endfunction() + +function(conan_cmake_configure) + conan_cmake_generate_conanfile(OFF ${ARGV}) +endfunction() + +# Generate, writing in disk a conanfile.txt with the requires, options, and imports +# specified as arguments +# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR) +function(conan_cmake_generate_conanfile DEFAULT_GENERATOR) + + conan_parse_arguments(${ARGV}) + + set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt") + file(WRITE ${_FN} "") + + if(DEFINED ARGUMENTS_REQUIRES) + file(APPEND ${_FN} "[requires]\n") + foreach(REQUIRE ${ARGUMENTS_REQUIRES}) + file(APPEND ${_FN} ${REQUIRE} "\n") + endforeach() + endif() + + if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS) + file(APPEND ${_FN} "[generators]\n") + if (DEFAULT_GENERATOR) + file(APPEND ${_FN} "cmake\n") + endif() + if (DEFINED ARGUMENTS_GENERATORS) + foreach(GENERATOR ${ARGUMENTS_GENERATORS}) + file(APPEND ${_FN} ${GENERATOR} "\n") + endforeach() + endif() + endif() + + if(DEFINED ARGUMENTS_BUILD_REQUIRES) + file(APPEND ${_FN} "[build_requires]\n") + foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES}) + file(APPEND ${_FN} ${BUILD_REQUIRE} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_IMPORTS) + file(APPEND ${_FN} "[imports]\n") + foreach(IMPORTS ${ARGUMENTS_IMPORTS}) + file(APPEND ${_FN} ${IMPORTS} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_OPTIONS) + file(APPEND ${_FN} "[options]\n") + foreach(OPTION ${ARGUMENTS_OPTIONS}) + file(APPEND ${_FN} ${OPTION} "\n") + endforeach() + endif() + +endfunction() + + +macro(conan_load_buildinfo) + if(CONAN_CMAKE_MULTI) + set(_CONANBUILDINFO conanbuildinfo_multi.cmake) + else() + set(_CONANBUILDINFO conanbuildinfo.cmake) + endif() + if(ARGUMENTS_INSTALL_FOLDER) + set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER}) + else() + set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR}) + endif() + # Checks for the existence of conanbuildinfo.cmake, and loads it + # important that it is macro, so variables defined at parent scope + if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}") + message(STATUS "Conan: Loading ${_CONANBUILDINFO}") + include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}) + else() + message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}") + endif() +endmacro() + + +macro(conan_cmake_run) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES) + message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators") + elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE) + message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.") + endif() + + if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED + AND NOT ARGUMENTS_BUILD_TYPE) + set(CONAN_CMAKE_MULTI ON) + if (NOT ARGUMENTS_CONFIGURATION_TYPES) + set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug") + endif() + message(STATUS "Conan: Using cmake-multi generator") + else() + set(CONAN_CMAKE_MULTI OFF) + endif() + + if(NOT CONAN_EXPORTED) + conan_cmake_setup_conanfile(${ARGV}) + if(CONAN_CMAKE_MULTI) + foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES}) + set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE}) + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endforeach() + set(CMAKE_BUILD_TYPE) + else() + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endif() + endif() + + if (NOT ARGUMENTS_NO_LOAD) + conan_load_buildinfo() + endif() + + if(ARGUMENTS_BASIC_SETUP) + foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD) + if(ARGUMENTS_${_option}) + if(${_option} STREQUAL "CMAKE_TARGETS") + list(APPEND _setup_options "TARGETS") + else() + list(APPEND _setup_options ${_option}) + endif() + endif() + endforeach() + conan_basic_setup(${_setup_options}) + endif() +endmacro() + +macro(conan_check) + # Checks conan availability in PATH + # Arguments REQUIRED, DETECT_QUIET and VERSION are optional + # Example usage: + # conan_check(VERSION 1.0.0 REQUIRED) + set(options REQUIRED DETECT_QUIET) + set(oneValueArgs VERSION) + cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN}) + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: checking conan executable") + endif() + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found! Please install conan.") + endif() + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: Found program ${CONAN_CMD}") + endif() + execute_process(COMMAND ${CONAN_CMD} --version + RESULT_VARIABLE return_code + OUTPUT_VARIABLE CONAN_VERSION_OUTPUT + ERROR_VARIABLE CONAN_VERSION_OUTPUT) + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan --version failed='${return_code}'") + endif() + + if(NOT CONAN_DETECT_QUIET) + string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT) + message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}") + endif() + + if(DEFINED CONAN_VERSION) + string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO + "${CONAN_VERSION_OUTPUT}") + if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION}) + message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \ + required: ${CONAN_VERSION}. Consider updating via 'pip \ + install conan==${CONAN_VERSION}'.") + endif() + endif() +endmacro() + +function(conan_add_remote) + # Adds a remote + # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional + # Example usage: + # conan_add_remote(NAME bincrafters INDEX 1 + # URL https://api.bintray.com/conan/bincrafters/public-conan + # VERIFY_SSL True) + set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN}) + + if(DEFINED CONAN_INDEX) + set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}") + endif() + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED DETECT_QUIET) + endif() + set(CONAN_VERIFY_SSL_ARG "True") + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL}) + endif() + message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})") + execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan remote failed='${return_code}'") + endif() +endfunction() + +macro(conan_config_install) + # install a full configuration from a local or remote zip file + # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional + # Example usage: + # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git + # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false) + set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL) + set(multiValueArgs ARGS) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}") + endif() + + if(DEFINED CONAN_TYPE) + set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}") + endif() + + if(DEFINED CONAN_ARGS) + set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"") + endif() + + if(DEFINED CONAN_SOURCE) + set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}") + endif() + + if(DEFINED CONAN_TARGET) + set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}") + endif() + + set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG} + ${CONAN_TYPE_ARG} + ${CONAN_ARGS_ARGS} + ${CONAN_SOURCE_ARGS} + ${CONAN_TARGET_ARGS}) + + message(STATUS "Conan: Installing config from ${CONAN_ITEM}") + execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan config failed='${return_code}'") + endif() +endmacro() diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan_provider.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan_provider.cmake new file mode 100755 index 0000000..e5fa9ce --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc/package-manager/conan_provider.cmake @@ -0,0 +1,655 @@ +# https://github.com/conan-io/cmake-conan/blob/develop2/conan_provider.cmake +# commit: f6464d1e13ef7a47c569f5061f9607ea63339d39 +# +# The MIT License (MIT) +# +# Copyright (c) 2019 JFrog +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +set(CONAN_MINIMUM_VERSION 2.0.5) + + +function(detect_os OS OS_API_LEVEL OS_SDK OS_SUBSYSTEM OS_VERSION) + # it could be cross compilation + message(STATUS "CMake-Conan: cmake_system_name=${CMAKE_SYSTEM_NAME}") + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(${OS} Macos PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX") + set(${OS} Neutrino PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN") + set(${OS} Windows PARENT_SCOPE) + set(${OS_SUBSYSTEM} cygwin PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME MATCHES "^MSYS") + set(${OS} Windows PARENT_SCOPE) + set(${OS_SUBSYSTEM} msys2 PARENT_SCOPE) + else() + set(${OS} ${CMAKE_SYSTEM_NAME} PARENT_SCOPE) + endif() + if(CMAKE_SYSTEM_NAME STREQUAL "Android") + if(DEFINED ANDROID_PLATFORM) + string(REGEX MATCH "[0-9]+" _OS_API_LEVEL ${ANDROID_PLATFORM}) + elseif(DEFINED CMAKE_SYSTEM_VERSION) + set(_OS_API_LEVEL ${CMAKE_SYSTEM_VERSION}) + endif() + message(STATUS "CMake-Conan: android api level=${_OS_API_LEVEL}") + set(${OS_API_LEVEL} ${_OS_API_LEVEL} PARENT_SCOPE) + endif() + if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS") + # CMAKE_OSX_SYSROOT contains the full path to the SDK for MakeFile/Ninja + # generators, but just has the original input string for Xcode. + if(NOT IS_DIRECTORY ${CMAKE_OSX_SYSROOT}) + set(_OS_SDK ${CMAKE_OSX_SYSROOT}) + else() + if(CMAKE_OSX_SYSROOT MATCHES Simulator) + set(apple_platform_suffix simulator) + else() + set(apple_platform_suffix os) + endif() + if(CMAKE_OSX_SYSROOT MATCHES AppleTV) + set(_OS_SDK "appletv${apple_platform_suffix}") + elseif(CMAKE_OSX_SYSROOT MATCHES iPhone) + set(_OS_SDK "iphone${apple_platform_suffix}") + elseif(CMAKE_OSX_SYSROOT MATCHES Watch) + set(_OS_SDK "watch${apple_platform_suffix}") + endif() + endif() + if(DEFINED _OS_SDK) + message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}") + set(${OS_SDK} ${_OS_SDK} PARENT_SCOPE) + endif() + if(DEFINED CMAKE_OSX_DEPLOYMENT_TARGET) + message(STATUS "CMake-Conan: cmake_osx_deployment_target=${CMAKE_OSX_DEPLOYMENT_TARGET}") + set(${OS_VERSION} ${CMAKE_OSX_DEPLOYMENT_TARGET} PARENT_SCOPE) + endif() + endif() + endif() +endfunction() + + +function(detect_arch ARCH) + # CMAKE_OSX_ARCHITECTURES can contain multiple architectures, but Conan only supports one. + # Therefore this code only finds one. If the recipes support multiple architectures, the + # build will work. Otherwise, there will be a linker error for the missing architecture(s). + if(DEFINED CMAKE_OSX_ARCHITECTURES) + string(REPLACE " " ";" apple_arch_list "${CMAKE_OSX_ARCHITECTURES}") + list(LENGTH apple_arch_list apple_arch_count) + if(apple_arch_count GREATER 1) + message(WARNING "CMake-Conan: Multiple architectures detected, this will only work if Conan recipe(s) produce fat binaries.") + endif() + endif() + if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS" AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "") + set(host_arch ${CMAKE_OSX_ARCHITECTURES}) + elseif(MSVC) + set(host_arch ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}) + else() + set(host_arch ${CMAKE_SYSTEM_PROCESSOR}) + endif() + if(host_arch MATCHES "aarch64|arm64|ARM64") + set(_ARCH armv8) + elseif(host_arch MATCHES "armv7|armv7-a|armv7l|ARMV7") + set(_ARCH armv7) + elseif(host_arch MATCHES armv7s) + set(_ARCH armv7s) + elseif(host_arch MATCHES "i686|i386|X86") + set(_ARCH x86) + elseif(host_arch MATCHES "AMD64|amd64|x86_64|x64") + set(_ARCH x86_64) + endif() + message(STATUS "CMake-Conan: cmake_system_processor=${_ARCH}") + set(${ARCH} ${_ARCH} PARENT_SCOPE) +endfunction() + + +function(detect_cxx_standard CXX_STANDARD) + set(${CXX_STANDARD} ${CMAKE_CXX_STANDARD} PARENT_SCOPE) + if(CMAKE_CXX_EXTENSIONS) + set(${CXX_STANDARD} "gnu${CMAKE_CXX_STANDARD}" PARENT_SCOPE) + endif() +endfunction() + + +macro(detect_gnu_libstdcxx) + # _CONAN_IS_GNU_LIBSTDCXX true if GNU libstdc++ + check_cxx_source_compiles(" + #include + #if !defined(__GLIBCXX__) && !defined(__GLIBCPP__) + static_assert(false); + #endif + int main(){}" _CONAN_IS_GNU_LIBSTDCXX) + + # _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI true if C++11 ABI + check_cxx_source_compiles(" + #include + static_assert(sizeof(std::string) != sizeof(void*), \"using libstdc++\"); + int main () {}" _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) + + set(_CONAN_GNU_LIBSTDCXX_SUFFIX "") + if(_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) + set(_CONAN_GNU_LIBSTDCXX_SUFFIX "11") + endif() + unset (_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) +endmacro() + + +macro(detect_libcxx) + # _CONAN_IS_LIBCXX true if LLVM libc++ + check_cxx_source_compiles(" + #include + #if !defined(_LIBCPP_VERSION) + static_assert(false); + #endif + int main(){}" _CONAN_IS_LIBCXX) +endmacro() + + +function(detect_lib_cxx LIB_CXX) + if(CMAKE_SYSTEM_NAME STREQUAL "Android") + message(STATUS "CMake-Conan: android_stl=${CMAKE_ANDROID_STL_TYPE}") + set(${LIB_CXX} ${CMAKE_ANDROID_STL_TYPE} PARENT_SCOPE) + return() + endif() + + include(CheckCXXSourceCompiles) + + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + detect_gnu_libstdcxx() + set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang") + set(${LIB_CXX} "libc++" PARENT_SCOPE) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows") + # Check for libc++ + detect_libcxx() + if(_CONAN_IS_LIBCXX) + set(${LIB_CXX} "libc++" PARENT_SCOPE) + return() + endif() + + # Check for libstdc++ + detect_gnu_libstdcxx() + if(_CONAN_IS_GNU_LIBSTDCXX) + set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE) + return() + endif() + + # TODO: it would be an error if we reach this point + elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + # Do nothing - compiler.runtime and compiler.runtime_type + # should be handled separately: https://github.com/conan-io/cmake-conan/pull/516 + return() + else() + # TODO: unable to determine, ask user to provide a full profile file instead + endif() +endfunction() + + +function(detect_compiler COMPILER COMPILER_VERSION COMPILER_RUNTIME COMPILER_RUNTIME_TYPE) + if(DEFINED CMAKE_CXX_COMPILER_ID) + set(_COMPILER ${CMAKE_CXX_COMPILER_ID}) + set(_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION}) + else() + if(NOT DEFINED CMAKE_C_COMPILER_ID) + message(FATAL_ERROR "C or C++ compiler not defined") + endif() + set(_COMPILER ${CMAKE_C_COMPILER_ID}) + set(_COMPILER_VERSION ${CMAKE_C_COMPILER_VERSION}) + endif() + + message(STATUS "CMake-Conan: CMake compiler=${_COMPILER}") + message(STATUS "CMake-Conan: CMake compiler version=${_COMPILER_VERSION}") + + if(_COMPILER MATCHES MSVC) + set(_COMPILER "msvc") + string(SUBSTRING ${MSVC_VERSION} 0 3 _COMPILER_VERSION) + # Configure compiler.runtime and compiler.runtime_type settings for MSVC + if(CMAKE_MSVC_RUNTIME_LIBRARY) + set(_msvc_runtime_library ${CMAKE_MSVC_RUNTIME_LIBRARY}) + else() + set(_msvc_runtime_library MultiThreaded$<$:Debug>DLL) # default value documented by CMake + endif() + + set(_KNOWN_MSVC_RUNTIME_VALUES "") + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded MultiThreadedDLL) + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreadedDebug MultiThreadedDebugDLL) + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded$<$:Debug> MultiThreaded$<$:Debug>DLL) + + # only accept the 6 possible values, otherwise we don't don't know to map this + if(NOT _msvc_runtime_library IN_LIST _KNOWN_MSVC_RUNTIME_VALUES) + message(FATAL_ERROR "CMake-Conan: unable to map MSVC runtime: ${_msvc_runtime_library} to Conan settings") + endif() + + # Runtime is "dynamic" in all cases if it ends in DLL + if(_msvc_runtime_library MATCHES ".*DLL$") + set(_COMPILER_RUNTIME "dynamic") + else() + set(_COMPILER_RUNTIME "static") + endif() + message(STATUS "CMake-Conan: CMake compiler.runtime=${_COMPILER_RUNTIME}") + + # Only define compiler.runtime_type when explicitly requested + # If a generator expression is used, let Conan handle it conditional on build_type + if(NOT _msvc_runtime_library MATCHES ":Debug>") + if(_msvc_runtime_library MATCHES "Debug") + set(_COMPILER_RUNTIME_TYPE "Debug") + else() + set(_COMPILER_RUNTIME_TYPE "Release") + endif() + message(STATUS "CMake-Conan: CMake compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}") + endif() + + unset(_KNOWN_MSVC_RUNTIME_VALUES) + + elseif(_COMPILER MATCHES AppleClang) + set(_COMPILER "apple-clang") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + elseif(_COMPILER MATCHES Clang) + set(_COMPILER "clang") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + elseif(_COMPILER MATCHES GNU) + set(_COMPILER "gcc") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + endif() + + message(STATUS "CMake-Conan: [settings] compiler=${_COMPILER}") + message(STATUS "CMake-Conan: [settings] compiler.version=${_COMPILER_VERSION}") + if (_COMPILER_RUNTIME) + message(STATUS "CMake-Conan: [settings] compiler.runtime=${_COMPILER_RUNTIME}") + endif() + if (_COMPILER_RUNTIME_TYPE) + message(STATUS "CMake-Conan: [settings] compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}") + endif() + + set(${COMPILER} ${_COMPILER} PARENT_SCOPE) + set(${COMPILER_VERSION} ${_COMPILER_VERSION} PARENT_SCOPE) + set(${COMPILER_RUNTIME} ${_COMPILER_RUNTIME} PARENT_SCOPE) + set(${COMPILER_RUNTIME_TYPE} ${_COMPILER_RUNTIME_TYPE} PARENT_SCOPE) +endfunction() + + +function(detect_build_type BUILD_TYPE) + get_property(_MULTICONFIG_GENERATOR GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(NOT _MULTICONFIG_GENERATOR) + # Only set when we know we are in a single-configuration generator + # Note: we may want to fail early if `CMAKE_BUILD_TYPE` is not defined + set(${BUILD_TYPE} ${CMAKE_BUILD_TYPE} PARENT_SCOPE) + endif() +endfunction() + +macro(set_conan_compiler_if_appleclang lang command output_variable) + if(CMAKE_${lang}_COMPILER_ID STREQUAL "AppleClang") + execute_process(COMMAND xcrun --find ${command} + OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE) + cmake_path(GET _xcrun_out PARENT_PATH _xcrun_toolchain_path) + cmake_path(GET CMAKE_${lang}_COMPILER PARENT_PATH _compiler_parent_path) + if ("${_xcrun_toolchain_path}" STREQUAL "${_compiler_parent_path}") + set(${output_variable} "") + endif() + unset(_xcrun_out) + unset(_xcrun_toolchain_path) + unset(_compiler_parent_path) + endif() +endmacro() + + +macro(append_compiler_executables_configuration) + set(_conan_c_compiler "") + set(_conan_cpp_compiler "") + if(CMAKE_C_COMPILER) + set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\",") + set_conan_compiler_if_appleclang(C cc _conan_c_compiler) + else() + message(WARNING "CMake-Conan: The C compiler is not defined. " + "Please define CMAKE_C_COMPILER or enable the C language.") + endif() + if(CMAKE_CXX_COMPILER) + set(_conan_cpp_compiler "\"cpp\":\"${CMAKE_CXX_COMPILER}\"") + set_conan_compiler_if_appleclang(CXX c++ _conan_cpp_compiler) + else() + message(WARNING "CMake-Conan: The C++ compiler is not defined. " + "Please define CMAKE_CXX_COMPILER or enable the C++ language.") + endif() + + if(NOT "x${_conan_c_compiler}${_conan_cpp_compiler}" STREQUAL "x") + string(APPEND PROFILE "tools.build:compiler_executables={${_conan_c_compiler}${_conan_cpp_compiler}}\n") + endif() + unset(_conan_c_compiler) + unset(_conan_cpp_compiler) +endmacro() + + +function(detect_host_profile output_file) + detect_os(MYOS MYOS_API_LEVEL MYOS_SDK MYOS_SUBSYSTEM MYOS_VERSION) + detect_arch(MYARCH) + detect_compiler(MYCOMPILER MYCOMPILER_VERSION MYCOMPILER_RUNTIME MYCOMPILER_RUNTIME_TYPE) + detect_cxx_standard(MYCXX_STANDARD) + detect_lib_cxx(MYLIB_CXX) + detect_build_type(MYBUILD_TYPE) + + set(PROFILE "") + string(APPEND PROFILE "[settings]\n") + if(MYARCH) + string(APPEND PROFILE arch=${MYARCH} "\n") + endif() + if(MYOS) + string(APPEND PROFILE os=${MYOS} "\n") + endif() + if(MYOS_API_LEVEL) + string(APPEND PROFILE os.api_level=${MYOS_API_LEVEL} "\n") + endif() + if(MYOS_VERSION) + string(APPEND PROFILE os.version=${MYOS_VERSION} "\n") + endif() + if(MYOS_SDK) + string(APPEND PROFILE os.sdk=${MYOS_SDK} "\n") + endif() + if(MYOS_SUBSYSTEM) + string(APPEND PROFILE os.subsystem=${MYOS_SUBSYSTEM} "\n") + endif() + if(MYCOMPILER) + string(APPEND PROFILE compiler=${MYCOMPILER} "\n") + endif() + if(MYCOMPILER_VERSION) + string(APPEND PROFILE compiler.version=${MYCOMPILER_VERSION} "\n") + endif() + if(MYCOMPILER_RUNTIME) + string(APPEND PROFILE compiler.runtime=${MYCOMPILER_RUNTIME} "\n") + endif() + if(MYCOMPILER_RUNTIME_TYPE) + string(APPEND PROFILE compiler.runtime_type=${MYCOMPILER_RUNTIME_TYPE} "\n") + endif() + if(MYCXX_STANDARD) + string(APPEND PROFILE compiler.cppstd=${MYCXX_STANDARD} "\n") + endif() + if(MYLIB_CXX) + string(APPEND PROFILE compiler.libcxx=${MYLIB_CXX} "\n") + endif() + if(MYBUILD_TYPE) + string(APPEND PROFILE "build_type=${MYBUILD_TYPE}\n") + endif() + + if(NOT DEFINED output_file) + set(_FN "${CMAKE_BINARY_DIR}/profile") + else() + set(_FN ${output_file}) + endif() + + string(APPEND PROFILE "[conf]\n") + string(APPEND PROFILE "tools.cmake.cmaketoolchain:generator=${CMAKE_GENERATOR}\n") + + # propagate compilers via profile + append_compiler_executables_configuration() + + if(MYOS STREQUAL "Android") + string(APPEND PROFILE "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n") + endif() + + message(STATUS "CMake-Conan: Creating profile ${_FN}") + file(WRITE ${_FN} ${PROFILE}) + message(STATUS "CMake-Conan: Profile: \n${PROFILE}") +endfunction() + + +function(conan_profile_detect_default) + message(STATUS "CMake-Conan: Checking if a default profile exists") + execute_process(COMMAND ${CONAN_COMMAND} profile path default + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + ECHO_OUTPUT_VARIABLE + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + if(NOT ${return_code} EQUAL "0") + message(STATUS "CMake-Conan: The default profile doesn't exist, detecting it.") + execute_process(COMMAND ${CONAN_COMMAND} profile detect + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + ECHO_OUTPUT_VARIABLE + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() +endfunction() + + +function(conan_install) + cmake_parse_arguments(ARGS CONAN_ARGS ${ARGN}) + set(CONAN_OUTPUT_FOLDER ${CMAKE_BINARY_DIR}/conan) + # Invoke "conan install" with the provided arguments + set(CONAN_ARGS ${CONAN_ARGS} -of=${CONAN_OUTPUT_FOLDER}) + message(STATUS "CMake-Conan: conan install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN}") + + + # In case there was not a valid cmake executable in the PATH, we inject the + # same we used to invoke the provider to the PATH + if(DEFINED PATH_TO_CMAKE_BIN) + set(_OLD_PATH $ENV{PATH}) + set(ENV{PATH} "$ENV{PATH}:${PATH_TO_CMAKE_BIN}") + endif() + + execute_process(COMMAND ${CONAN_COMMAND} install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN} --format=json + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(DEFINED PATH_TO_CMAKE_BIN) + set(ENV{PATH} "${_OLD_PATH}") + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + else() + # the files are generated in a folder that depends on the layout used, if + # one is specified, but we don't know a priori where this is. + # TODO: this can be made more robust if Conan can provide this in the json output + string(JSON CONAN_GENERATORS_FOLDER GET ${conan_stdout} graph nodes 0 generators_folder) + cmake_path(CONVERT ${CONAN_GENERATORS_FOLDER} TO_CMAKE_PATH_LIST CONAN_GENERATORS_FOLDER) + # message("conan stdout: ${conan_stdout}") + message(STATUS "CMake-Conan: CONAN_GENERATORS_FOLDER=${CONAN_GENERATORS_FOLDER}") + set_property(GLOBAL PROPERTY CONAN_GENERATORS_FOLDER "${CONAN_GENERATORS_FOLDER}") + # reconfigure on conanfile changes + string(JSON CONANFILE GET ${conan_stdout} graph nodes 0 label) + message(STATUS "CMake-Conan: CONANFILE=${CMAKE_SOURCE_DIR}/${CONANFILE}") + set_property(DIRECTORY ${CMAKE_SOURCE_DIR} APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/${CONANFILE}") + # success + set_property(GLOBAL PROPERTY CONAN_INSTALL_SUCCESS TRUE) + endif() +endfunction() + + +function(conan_get_version conan_command conan_current_version) + execute_process( + COMMAND ${conan_command} --version + OUTPUT_VARIABLE conan_output + RESULT_VARIABLE conan_result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(conan_result) + message(FATAL_ERROR "CMake-Conan: Error when trying to run Conan") + endif() + + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" conan_version ${conan_output}) + set(${conan_current_version} ${conan_version} PARENT_SCOPE) +endfunction() + + +function(conan_version_check) + set(options ) + set(oneValueArgs MINIMUM CURRENT) + set(multiValueArgs ) + cmake_parse_arguments(CONAN_VERSION_CHECK + "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT CONAN_VERSION_CHECK_MINIMUM) + message(FATAL_ERROR "CMake-Conan: Required parameter MINIMUM not set!") + endif() + if(NOT CONAN_VERSION_CHECK_CURRENT) + message(FATAL_ERROR "CMake-Conan: Required parameter CURRENT not set!") + endif() + + if(CONAN_VERSION_CHECK_CURRENT VERSION_LESS CONAN_VERSION_CHECK_MINIMUM) + message(FATAL_ERROR "CMake-Conan: Conan version must be ${CONAN_VERSION_CHECK_MINIMUM} or later") + endif() +endfunction() + + +macro(construct_profile_argument argument_variable profile_list) + set(${argument_variable} "") + if("${profile_list}" STREQUAL "CONAN_HOST_PROFILE") + set(_arg_flag "--profile:host=") + elseif("${profile_list}" STREQUAL "CONAN_BUILD_PROFILE") + set(_arg_flag "--profile:build=") + endif() + + set(_profile_list "${${profile_list}}") + list(TRANSFORM _profile_list REPLACE "auto-cmake" "${CMAKE_BINARY_DIR}/conan_host_profile") + list(TRANSFORM _profile_list PREPEND ${_arg_flag}) + set(${argument_variable} ${_profile_list}) + + unset(_arg_flag) + unset(_profile_list) +endmacro() + + +macro(conan_provide_dependency method package_name) + set_property(GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED TRUE) + get_property(_conan_install_success GLOBAL PROPERTY CONAN_INSTALL_SUCCESS) + if(NOT _conan_install_success) + find_program(CONAN_COMMAND "conan" REQUIRED) + conan_get_version(${CONAN_COMMAND} CONAN_CURRENT_VERSION) + conan_version_check(MINIMUM ${CONAN_MINIMUM_VERSION} CURRENT ${CONAN_CURRENT_VERSION}) + message(STATUS "CMake-Conan: first find_package() found. Installing dependencies with Conan") + if("default" IN_LIST CONAN_HOST_PROFILE OR "default" IN_LIST CONAN_BUILD_PROFILE) + conan_profile_detect_default() + endif() + if("auto-cmake" IN_LIST CONAN_HOST_PROFILE) + detect_host_profile(${CMAKE_BINARY_DIR}/conan_host_profile) + endif() + construct_profile_argument(_host_profile_flags CONAN_HOST_PROFILE) + construct_profile_argument(_build_profile_flags CONAN_BUILD_PROFILE) + if(EXISTS "${CMAKE_SOURCE_DIR}/conanfile.py") + file(READ "${CMAKE_SOURCE_DIR}/conanfile.py" outfile) + if(NOT "${outfile}" MATCHES ".*CMakeDeps.*") + message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile") + endif() + set(generator "") + elseif (EXISTS "${CMAKE_SOURCE_DIR}/conanfile.txt") + file(READ "${CMAKE_SOURCE_DIR}/conanfile.txt" outfile) + if(NOT "${outfile}" MATCHES ".*CMakeDeps.*") + message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile. " + "Please define the generator as it will be mandatory in the future") + endif() + set(generator "-g;CMakeDeps") + endif() + get_property(_multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(NOT _multiconfig_generator) + message(STATUS "CMake-Conan: Installing single configuration ${CMAKE_BUILD_TYPE}") + conan_install(${_host_profile_flags} ${_build_profile_flags} ${CONAN_INSTALL_ARGS} ${generator}) + else() + message(STATUS "CMake-Conan: Installing both Debug and Release") + conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Release ${CONAN_INSTALL_ARGS} ${generator}) + conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Debug ${CONAN_INSTALL_ARGS} ${generator}) + endif() + unset(_host_profile_flags) + unset(_build_profile_flags) + unset(_multiconfig_generator) + unset(_conan_install_success) + else() + message(STATUS "CMake-Conan: find_package(${ARGV1}) found, 'conan install' already ran") + unset(_conan_install_success) + endif() + + get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER) + + # Ensure that we consider Conan-provided packages ahead of any other, + # irrespective of other settings that modify the search order or search paths + # This follows the guidelines from the find_package documentation + # (https://cmake.org/cmake/help/latest/command/find_package.html): + # find_package ( PATHS paths... NO_DEFAULT_PATH) + # find_package () + + # Filter out `REQUIRED` from the argument list, as the first call may fail + set(_find_args_${package_name} "${ARGN}") + list(REMOVE_ITEM _find_args_${package_name} "REQUIRED") + if(NOT "MODULE" IN_LIST _find_args_${package_name}) + find_package(${package_name} ${_find_args_${package_name}} BYPASS_PROVIDER PATHS "${_conan_generators_folder}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) + unset(_find_args_${package_name}) + endif() + + # Invoke find_package a second time - if the first call succeeded, + # this will simply reuse the result. If not, fall back to CMake default search + # behaviour, also allowing modules to be searched. + if(NOT ${package_name}_FOUND) + list(FIND CMAKE_MODULE_PATH "${_conan_generators_folder}" _index) + if(_index EQUAL -1) + list(PREPEND CMAKE_MODULE_PATH "${_conan_generators_folder}") + endif() + unset(_index) + find_package(${package_name} ${ARGN} BYPASS_PROVIDER) + list(REMOVE_ITEM CMAKE_MODULE_PATH "${_conan_generators_folder}") + endif() +endmacro() + +#[=[ not needed by Qt Creator, and if not commented it would break the auto-setup feature + +cmake_language( + SET_DEPENDENCY_PROVIDER conan_provide_dependency + SUPPORTED_METHODS FIND_PACKAGE +) + + +macro(conan_provide_dependency_check) + set(_CONAN_PROVIDE_DEPENDENCY_INVOKED FALSE) + get_property(_CONAN_PROVIDE_DEPENDENCY_INVOKED GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED) + if(NOT _CONAN_PROVIDE_DEPENDENCY_INVOKED) + message(WARNING "Conan is correctly configured as dependency provider, " + "but Conan has not been invoked. Please add at least one " + "call to `find_package()`.") + if(DEFINED CONAN_COMMAND) + # supress warning in case `CONAN_COMMAND` was specified but unused. + set(_CONAN_COMMAND ${CONAN_COMMAND}) + unset(_CONAN_COMMAND) + endif() + endif() + unset(_CONAN_PROVIDE_DEPENDENCY_INVOKED) +endmacro() + + +# Add a deferred call at the end of processing the top-level directory +# to check if the dependency provider was invoked at all. +cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL conan_provide_dependency_check) + +]=] + +# Configurable variables for Conan profiles +set(CONAN_HOST_PROFILE "default;auto-cmake" CACHE STRING "Conan host profile") +set(CONAN_BUILD_PROFILE "default" CACHE STRING "Conan build profile") +set(CONAN_INSTALL_ARGS "--build=missing" CACHE STRING "Command line arguments for conan install") + +find_program(_cmake_program NAMES cmake NO_PACKAGE_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH) +if(NOT _cmake_program) + get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY) + set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is") +endif() + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/FILE.h.846F156B181C5A07.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/FILE.h.846F156B181C5A07.idx new file mode 100755 index 0000000..11ea5f2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/FILE.h.846F156B181C5A07.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QAction.A39779A3CBFCC7C4.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QAction.A39779A3CBFCC7C4.idx new file mode 100755 index 0000000..726db23 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QAction.A39779A3CBFCC7C4.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QApplication.A64C023440588392.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QApplication.A64C023440588392.idx new file mode 100755 index 0000000..8bd8379 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QApplication.A64C023440588392.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QLabel.49ABC8C207AFEBCD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QLabel.49ABC8C207AFEBCD.idx new file mode 100755 index 0000000..83cae34 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QLabel.49ABC8C207AFEBCD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMainWindow.12C385FA427130BB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMainWindow.12C385FA427130BB.idx new file mode 100755 index 0000000..302e5d6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMainWindow.12C385FA427130BB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenu.A28F44737C9908E3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenu.A28F44737C9908E3.idx new file mode 100755 index 0000000..81a0f2f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenu.A28F44737C9908E3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenuBar.C8900C0BBD83CBCD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenuBar.C8900C0BBD83CBCD.idx new file mode 100755 index 0000000..9c2c80d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QMenuBar.C8900C0BBD83CBCD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QPushButton.181FCD452291607E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QPushButton.181FCD452291607E.idx new file mode 100755 index 0000000..feb65ca Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QPushButton.181FCD452291607E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QVariant.EC9C6F8766BB8801.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QVariant.EC9C6F8766BB8801.idx new file mode 100755 index 0000000..276e876 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QVariant.EC9C6F8766BB8801.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QWidget.5EE30F6B5C28EB7D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QWidget.5EE30F6B5C28EB7D.idx new file mode 100755 index 0000000..beb4ab1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/QWidget.5EE30F6B5C28EB7D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__FILE.h.BEEE5A6696CD3CC3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__FILE.h.BEEE5A6696CD3CC3.idx new file mode 100755 index 0000000..8871c49 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__FILE.h.BEEE5A6696CD3CC3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos64_t.h.2EADFCA8D822C455.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos64_t.h.2EADFCA8D822C455.idx new file mode 100755 index 0000000..b561574 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos64_t.h.2EADFCA8D822C455.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos_t.h.53A3712523DD5217.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos_t.h.53A3712523DD5217.idx new file mode 100755 index 0000000..9e17f1e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__fpos_t.h.53A3712523DD5217.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__locale_t.h.4EF4C6F2FD1F70EF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__locale_t.h.4EF4C6F2FD1F70EF.idx new file mode 100755 index 0000000..f8f16ae Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__locale_t.h.4EF4C6F2FD1F70EF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__mbstate_t.h.7482AF58BE8A6D98.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__mbstate_t.h.7482AF58BE8A6D98.idx new file mode 100755 index 0000000..a21fc4e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__mbstate_t.h.7482AF58BE8A6D98.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__sigset_t.h.660A044352C66985.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__sigset_t.h.660A044352C66985.idx new file mode 100755 index 0000000..4008c4d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__sigset_t.h.660A044352C66985.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___gnuc_va_list.h.A79EC21D920823BD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___gnuc_va_list.h.A79EC21D920823BD.idx new file mode 100755 index 0000000..ab86020 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___gnuc_va_list.h.A79EC21D920823BD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___va_copy.h.836F5157CC346C4F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___va_copy.h.836F5157CC346C4F.idx new file mode 100755 index 0000000..1f647d0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg___va_copy.h.836F5157CC346C4F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_arg.h.5EC5C543F1B872A9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_arg.h.5EC5C543F1B872A9.idx new file mode 100755 index 0000000..5d70ed0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_arg.h.5EC5C543F1B872A9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_copy.h.3E264452A0E4B406.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_copy.h.3E264452A0E4B406.idx new file mode 100755 index 0000000..69c3a47 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_copy.h.3E264452A0E4B406.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_list.h.A3A515E2488032B1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_list.h.A3A515E2488032B1.idx new file mode 100755 index 0000000..eeba59e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stdarg_va_list.h.A3A515E2488032B1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_max_align_t.h.52E4E8107D054E2F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_max_align_t.h.52E4E8107D054E2F.idx new file mode 100755 index 0000000..564d20b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_max_align_t.h.52E4E8107D054E2F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_null.h.BFF639976FF8B28B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_null.h.BFF639976FF8B28B.idx new file mode 100755 index 0000000..0109f2d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_null.h.BFF639976FF8B28B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_nullptr_t.h.E1FA26364DE56116.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_nullptr_t.h.E1FA26364DE56116.idx new file mode 100755 index 0000000..d0c7c15 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_nullptr_t.h.E1FA26364DE56116.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_offsetof.h.4DBFDF8A36D01F76.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_offsetof.h.4DBFDF8A36D01F76.idx new file mode 100755 index 0000000..636aa83 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_offsetof.h.4DBFDF8A36D01F76.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_ptrdiff_t.h.4B3FA438EF5E4696.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_ptrdiff_t.h.4B3FA438EF5E4696.idx new file mode 100755 index 0000000..01c5e7b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_ptrdiff_t.h.4B3FA438EF5E4696.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_size_t.h.306005792F55F16E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_size_t.h.306005792F55F16E.idx new file mode 100755 index 0000000..68a2da1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_size_t.h.306005792F55F16E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_wchar_t.h.AB8CE4E78A67BAB0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_wchar_t.h.AB8CE4E78A67BAB0.idx new file mode 100755 index 0000000..f201931 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/__stddef_wchar_t.h.AB8CE4E78A67BAB0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithm.8A5FD69C51DF8BA3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithm.8A5FD69C51DF8BA3.idx new file mode 100755 index 0000000..535161f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithm.8A5FD69C51DF8BA3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithmfwd.h.EEF38AAB61E9FB85.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithmfwd.h.EEF38AAB61E9FB85.idx new file mode 100755 index 0000000..358303d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/algorithmfwd.h.EEF38AAB61E9FB85.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/align.h.D66C59AAFBA9E530.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/align.h.D66C59AAFBA9E530.idx new file mode 100755 index 0000000..c7cbbd5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/align.h.D66C59AAFBA9E530.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/aligned_buffer.h.DF77FA2019695964.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/aligned_buffer.h.DF77FA2019695964.idx new file mode 100755 index 0000000..cdcc8e2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/aligned_buffer.h.DF77FA2019695964.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.4CD61724FABEEFBA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.4CD61724FABEEFBA.idx new file mode 100755 index 0000000..830a73b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.4CD61724FABEEFBA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.A844DC2D52719F34.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.A844DC2D52719F34.idx new file mode 100755 index 0000000..738cf01 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloc_traits.h.A844DC2D52719F34.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloca.h.793370BF9878CFB6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloca.h.793370BF9878CFB6.idx new file mode 100755 index 0000000..c898571 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/alloca.h.793370BF9878CFB6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocated_ptr.h.70410E8C62EC6C3B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocated_ptr.h.70410E8C62EC6C3B.idx new file mode 100755 index 0000000..45753e9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocated_ptr.h.70410E8C62EC6C3B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocator.h.E1943E26F0F3E7CA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocator.h.E1943E26F0F3E7CA.idx new file mode 100755 index 0000000..c85b58e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/allocator.h.E1943E26F0F3E7CA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/array.2B0F72C0ACC52B1B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/array.2B0F72C0ACC52B1B.idx new file mode 100755 index 0000000..6eec120 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/array.2B0F72C0ACC52B1B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assert.h.9895EEC17E1D2A2B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assert.h.9895EEC17E1D2A2B.idx new file mode 100755 index 0000000..bf10b02 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assert.h.9895EEC17E1D2A2B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assertions.h.98AA23E28F95F002.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assertions.h.98AA23E28F95F002.idx new file mode 100755 index 0000000..dcb1972 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/assertions.h.98AA23E28F95F002.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic.BC6FAD3ED3922564.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic.BC6FAD3ED3922564.idx new file mode 100755 index 0000000..148448e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic.BC6FAD3ED3922564.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_base.h.5CAE7DD0D5FEA870.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_base.h.5CAE7DD0D5FEA870.idx new file mode 100755 index 0000000..1d1ee97 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_base.h.5CAE7DD0D5FEA870.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_lockfree_defines.h.674B1B15FD3617C9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_lockfree_defines.h.674B1B15FD3617C9.idx new file mode 100755 index 0000000..9cb5c00 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_lockfree_defines.h.674B1B15FD3617C9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_wide_counter.h.807A3792D29058FD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_wide_counter.h.807A3792D29058FD.idx new file mode 100755 index 0000000..e519b37 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_wide_counter.h.807A3792D29058FD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_word.h.315DFF396293B977.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_word.h.315DFF396293B977.idx new file mode 100755 index 0000000..883bee5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomic_word.h.315DFF396293B977.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomicity.h.F6DA33F8D86DA4DB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomicity.h.F6DA33F8D86DA4DB.idx new file mode 100755 index 0000000..326dfe0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/atomicity.h.F6DA33F8D86DA4DB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/auto_ptr.h.F72E6F8ABA6777B5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/auto_ptr.h.F72E6F8ABA6777B5.idx new file mode 100755 index 0000000..3382500 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/auto_ptr.h.F72E6F8ABA6777B5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.h.B9561F8084341EB6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.h.B9561F8084341EB6.idx new file mode 100755 index 0000000..9fac718 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.h.B9561F8084341EB6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.tcc.5394D20EDF5176EF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.tcc.5394D20EDF5176EF.idx new file mode 100755 index 0000000..69abb3a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/basic_string.tcc.5394D20EDF5176EF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bessel_function.tcc.F2CCB1901AC2BAAE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bessel_function.tcc.F2CCB1901AC2BAAE.idx new file mode 100755 index 0000000..11b459d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bessel_function.tcc.F2CCB1901AC2BAAE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/beta_function.tcc.EDAA91939666D6F8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/beta_function.tcc.EDAA91939666D6F8.idx new file mode 100755 index 0000000..b25d57c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/beta_function.tcc.EDAA91939666D6F8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/binders.h.E4473413194420AE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/binders.h.E4473413194420AE.idx new file mode 100755 index 0000000..6632d61 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/binders.h.E4473413194420AE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bit.F0221561CAE936F7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bit.F0221561CAE936F7.idx new file mode 100755 index 0000000..bba2752 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/bit.F0221561CAE936F7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/byteswap.h.5CF682CD30C8245A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/byteswap.h.5CF682CD30C8245A.idx new file mode 100755 index 0000000..092454f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/byteswap.h.5CF682CD30C8245A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++allocator.h.BD11A1C6167FF5D6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++allocator.h.BD11A1C6167FF5D6.idx new file mode 100755 index 0000000..e5b3a80 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++allocator.h.BD11A1C6167FF5D6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++config.h.9F7F2721C3A599A9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++config.h.9F7F2721C3A599A9.idx new file mode 100755 index 0000000..d4bb0b5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++config.h.9F7F2721C3A599A9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++locale.h.6892B700408CAE8B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++locale.h.6892B700408CAE8B.idx new file mode 100755 index 0000000..d7946dd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/c++locale.h.6892B700408CAE8B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cctype.45FE81067E51AD8A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cctype.45FE81067E51AD8A.idx new file mode 100755 index 0000000..83543c0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cctype.45FE81067E51AD8A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cdefs.h.020FDF15FD4FDEBD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cdefs.h.020FDF15FD4FDEBD.idx new file mode 100755 index 0000000..1635295 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cdefs.h.020FDF15FD4FDEBD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cerrno.819D5F5C3A7B0B43.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cerrno.819D5F5C3A7B0B43.idx new file mode 100755 index 0000000..a4945cc Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cerrno.819D5F5C3A7B0B43.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/char_traits.h.9A95CE3D19650974.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/char_traits.h.9A95CE3D19650974.idx new file mode 100755 index 0000000..474bc4e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/char_traits.h.9A95CE3D19650974.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/charconv.h.6E7B845F62D9C4D9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/charconv.h.6E7B845F62D9C4D9.idx new file mode 100755 index 0000000..ffb370d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/charconv.h.6E7B845F62D9C4D9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.837B225288D9AEC6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.837B225288D9AEC6.idx new file mode 100755 index 0000000..a626158 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.837B225288D9AEC6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.h.FA23AAA3A8BA2411.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.h.FA23AAA3A8BA2411.idx new file mode 100755 index 0000000..66d1cb4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/chrono.h.FA23AAA3A8BA2411.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clocale.A25E3E105AA18D05.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clocale.A25E3E105AA18D05.idx new file mode 100755 index 0000000..863c50e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clocale.A25E3E105AA18D05.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clock_t.h.D43CAB77D0D0D2BD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clock_t.h.D43CAB77D0D0D2BD.idx new file mode 100755 index 0000000..9b3af94 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clock_t.h.D43CAB77D0D0D2BD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clockid_t.h.4E370254AE2D9FBB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clockid_t.h.4E370254AE2D9FBB.idx new file mode 100755 index 0000000..4bf39dd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/clockid_t.h.4E370254AE2D9FBB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cmath.7F94A5DC886C08DF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cmath.7F94A5DC886C08DF.idx new file mode 100755 index 0000000..b6b7cb2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cmath.7F94A5DC886C08DF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/compare.8A3B1CEA5A51B1AA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/compare.8A3B1CEA5A51B1AA.idx new file mode 100755 index 0000000..adfec90 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/compare.8A3B1CEA5A51B1AA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concept_check.h.17FF2CABAE227A23.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concept_check.h.17FF2CABAE227A23.idx new file mode 100755 index 0000000..a1fd7bd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concept_check.h.17FF2CABAE227A23.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concepts.23B00030032C36A4.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concepts.23B00030032C36A4.idx new file mode 100755 index 0000000..733452a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concepts.23B00030032C36A4.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concurrence.h.45C28A9206DBCB63.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concurrence.h.45C28A9206DBCB63.idx new file mode 100755 index 0000000..f26eb6c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/concurrence.h.45C28A9206DBCB63.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cookie_io_functions_t.h.E3E6C5414DB00C0C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cookie_io_functions_t.h.E3E6C5414DB00C0C.idx new file mode 100755 index 0000000..3457b21 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cookie_io_functions_t.h.E3E6C5414DB00C0C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpp_type_traits.h.FAB6676B3F7EBD5F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpp_type_traits.h.FAB6676B3F7EBD5F.idx new file mode 100755 index 0000000..c5466c9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpp_type_traits.h.FAB6676B3F7EBD5F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu-set.h.FE0C2BA06F27155D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu-set.h.FE0C2BA06F27155D.idx new file mode 100755 index 0000000..58e2b0f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu-set.h.FE0C2BA06F27155D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu_defines.h.44BD5FB90612A390.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu_defines.h.44BD5FB90612A390.idx new file mode 100755 index 0000000..e48ef44 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cpu_defines.h.44BD5FB90612A390.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstddef.C90E39AFC31D658E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstddef.C90E39AFC31D658E.idx new file mode 100755 index 0000000..3f1168f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstddef.C90E39AFC31D658E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdint.DC7D59978AF20695.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdint.DC7D59978AF20695.idx new file mode 100755 index 0000000..11d91e6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdint.DC7D59978AF20695.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdio.9B23E761FDEAE3D3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdio.9B23E761FDEAE3D3.idx new file mode 100755 index 0000000..4c01d0b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdio.9B23E761FDEAE3D3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdlib.BED9304B76EAD3E7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdlib.BED9304B76EAD3E7.idx new file mode 100755 index 0000000..c6f4ccb Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cstdlib.BED9304B76EAD3E7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctime.025AAAB79EE86A8B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctime.025AAAB79EE86A8B.idx new file mode 100755 index 0000000..50576b0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctime.025AAAB79EE86A8B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctype.h.B268CEA0CECCFC59.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctype.h.B268CEA0CECCFC59.idx new file mode 100755 index 0000000..d5a2659 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ctype.h.B268CEA0CECCFC59.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cwchar.F6AB8DAFCD2C1DE9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cwchar.F6AB8DAFCD2C1DE9.idx new file mode 100755 index 0000000..7a456ce Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cwchar.F6AB8DAFCD2C1DE9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_forced.h.BC431100D1277D23.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_forced.h.BC431100D1277D23.idx new file mode 100755 index 0000000..937c13f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_forced.h.BC431100D1277D23.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_init_exception.h.ECDB397F73647209.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_init_exception.h.ECDB397F73647209.idx new file mode 100755 index 0000000..039df46 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/cxxabi_init_exception.h.ECDB397F73647209.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/debug.h.8D12E14D7FCC30DF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/debug.h.8D12E14D7FCC30DF.idx new file mode 100755 index 0000000..6adf93c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/debug.h.8D12E14D7FCC30DF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ell_integral.tcc.133F835CD79F336E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ell_integral.tcc.133F835CD79F336E.idx new file mode 100755 index 0000000..874c484 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ell_integral.tcc.133F835CD79F336E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/enable_special_members.h.F0E2D096AFDF7392.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/enable_special_members.h.F0E2D096AFDF7392.idx new file mode 100755 index 0000000..690cd93 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/enable_special_members.h.F0E2D096AFDF7392.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.1FC6A4D6D2846204.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.1FC6A4D6D2846204.idx new file mode 100755 index 0000000..71f6749 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.1FC6A4D6D2846204.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.34A83B053A733CA8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.34A83B053A733CA8.idx new file mode 100755 index 0000000..cf6441c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endian.h.34A83B053A733CA8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endianness.h.BDC6F260DCC6E0EC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endianness.h.BDC6F260DCC6E0EC.idx new file mode 100755 index 0000000..dd75847 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/endianness.h.BDC6F260DCC6E0EC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/erase_if.h.C70B56BAE300760C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/erase_if.h.C70B56BAE300760C.idx new file mode 100755 index 0000000..d77218f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/erase_if.h.C70B56BAE300760C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno-base.h.23FC55A99C73A727.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno-base.h.23FC55A99C73A727.idx new file mode 100755 index 0000000..06e3d50 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno-base.h.23FC55A99C73A727.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.10013861918E601A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.10013861918E601A.idx new file mode 100755 index 0000000..bc7b404 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.10013861918E601A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.19BCCCD58DA5623E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.19BCCCD58DA5623E.idx new file mode 100755 index 0000000..ec5e5d9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.19BCCCD58DA5623E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.3F8ECD84FB880B64.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.3F8ECD84FB880B64.idx new file mode 100755 index 0000000..4311cef Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.3F8ECD84FB880B64.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.45DFD70EF343D681.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.45DFD70EF343D681.idx new file mode 100755 index 0000000..ef0cb7a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.45DFD70EF343D681.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.55CA4DE1F1B35462.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.55CA4DE1F1B35462.idx new file mode 100755 index 0000000..27b7c93 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/errno.h.55CA4DE1F1B35462.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_constants.h.927D1265F681EABC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_constants.h.927D1265F681EABC.idx new file mode 100755 index 0000000..06c24d4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_constants.h.927D1265F681EABC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_t.h.AA215EF04C62C72A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_t.h.AA215EF04C62C72A.idx new file mode 100755 index 0000000..989c568 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/error_t.h.AA215EF04C62C72A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.C777F958B4D13BD7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.C777F958B4D13BD7.idx new file mode 100755 index 0000000..f89de95 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.C777F958B4D13BD7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.h.65011B501144EF4E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.h.65011B501144EF4E.idx new file mode 100755 index 0000000..9244d35 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception.h.65011B501144EF4E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_defines.h.82D6331A0914594C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_defines.h.82D6331A0914594C.idx new file mode 100755 index 0000000..88e6965 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_defines.h.82D6331A0914594C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_ptr.h.A8994D5CA5988A56.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_ptr.h.A8994D5CA5988A56.idx new file mode 100755 index 0000000..f5810df Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exception_ptr.h.A8994D5CA5988A56.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/execution_defs.h.0F2D8F8289D5CCD2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/execution_defs.h.0F2D8F8289D5CCD2.idx new file mode 100755 index 0000000..5501f81 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/execution_defs.h.0F2D8F8289D5CCD2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exp_integral.tcc.AC5BA0141D2C0DD6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exp_integral.tcc.AC5BA0141D2C0DD6.idx new file mode 100755 index 0000000..fcee171 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/exp_integral.tcc.AC5BA0141D2C0DD6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features-time64.h.BFBA8D3CA0316037.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features-time64.h.BFBA8D3CA0316037.idx new file mode 100755 index 0000000..c80486c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features-time64.h.BFBA8D3CA0316037.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features.h.5A4ED7C80201A723.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features.h.5A4ED7C80201A723.idx new file mode 100755 index 0000000..6f3db53 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/features.h.5A4ED7C80201A723.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn-common.h.975EC49F61A3C703.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn-common.h.975EC49F61A3C703.idx new file mode 100755 index 0000000..14dcf25 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn-common.h.975EC49F61A3C703.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn.h.F3C6759637F0C3C2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn.h.F3C6759637F0C3C2.idx new file mode 100755 index 0000000..25baa2d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/floatn.h.F3C6759637F0C3C2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/flt-eval-method.h.3344EA8D5853532A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/flt-eval-method.h.3344EA8D5853532A.idx new file mode 100755 index 0000000..538d5e9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/flt-eval-method.h.3344EA8D5853532A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-fast.h.91A0AAED89DDB8E8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-fast.h.91A0AAED89DDB8E8.idx new file mode 100755 index 0000000..865c1f8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-fast.h.91A0AAED89DDB8E8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-logb.h.943A50A5C0A2DEE2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-logb.h.943A50A5C0A2DEE2.idx new file mode 100755 index 0000000..e5da21e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/fp-logb.h.943A50A5C0A2DEE2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functexcept.h.D2FF6C9EF46BA786.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functexcept.h.D2FF6C9EF46BA786.idx new file mode 100755 index 0000000..499ed96 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functexcept.h.D2FF6C9EF46BA786.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional.EF55750FEAD838CA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional.EF55750FEAD838CA.idx new file mode 100755 index 0000000..a4c1c84 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional.EF55750FEAD838CA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional_hash.h.155E7DCEBAD33A0E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional_hash.h.155E7DCEBAD33A0E.idx new file mode 100755 index 0000000..592ace5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/functional_hash.h.155E7DCEBAD33A0E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gamma.tcc.CF41377F3B0E30B0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gamma.tcc.CF41377F3B0E30B0.idx new file mode 100755 index 0000000..1dd699e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gamma.tcc.CF41377F3B0E30B0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_algorithm_defs.h.107EB02E97FED0E8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_algorithm_defs.h.107EB02E97FED0E8.idx new file mode 100755 index 0000000..5988089 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_algorithm_defs.h.107EB02E97FED0E8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_memory_defs.h.F7716F53E1442902.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_memory_defs.h.F7716F53E1442902.idx new file mode 100755 index 0000000..60d067e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_memory_defs.h.F7716F53E1442902.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_numeric_defs.h.8C779E293F0BD4D6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_numeric_defs.h.8C779E293F0BD4D6.idx new file mode 100755 index 0000000..1ab8b7f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/glue_numeric_defs.h.8C779E293F0BD4D6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr-default.h.95AA53DC0DF582C5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr-default.h.95AA53DC0DF582C5.idx new file mode 100755 index 0000000..f881532 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr-default.h.95AA53DC0DF582C5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr.h.45C92866D368FC62.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr.h.45C92866D368FC62.idx new file mode 100755 index 0000000..228cc9f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/gthr.h.45C92866D368FC62.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hash_bytes.h.7FC3233290B236EE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hash_bytes.h.7FC3233290B236EE.idx new file mode 100755 index 0000000..e949265 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hash_bytes.h.7FC3233290B236EE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable.h.A591D40F603AB5C1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable.h.A591D40F603AB5C1.idx new file mode 100755 index 0000000..1df222e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable.h.A591D40F603AB5C1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable_policy.h.191F01AB574A2AB7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable_policy.h.191F01AB574A2AB7.idx new file mode 100755 index 0000000..5d16e2d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hashtable_policy.h.191F01AB574A2AB7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hypergeometric.tcc.000204CBFF30D2B9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hypergeometric.tcc.000204CBFF30D2B9.idx new file mode 100755 index 0000000..df77fe8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/hypergeometric.tcc.000204CBFF30D2B9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/initializer_list.8392AF237AD0F8BC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/initializer_list.8392AF237AD0F8BC.idx new file mode 100755 index 0000000..c4f5882 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/initializer_list.8392AF237AD0F8BC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/invoke.h.84E589785E3F87D5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/invoke.h.84E589785E3F87D5.idx new file mode 100755 index 0000000..45f8f00 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/invoke.h.84E589785E3F87D5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ios_base.h.B059AA8CF4852507.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ios_base.h.B059AA8CF4852507.idx new file mode 100755 index 0000000..025c66a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ios_base.h.B059AA8CF4852507.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iosfwd.1FB24537359793BB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iosfwd.1FB24537359793BB.idx new file mode 100755 index 0000000..6d17055 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iosfwd.1FB24537359793BB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iscanonical.h.BDB713BBC126F94E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iscanonical.h.BDB713BBC126F94E.idx new file mode 100755 index 0000000..35a83b8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iscanonical.h.BDB713BBC126F94E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iterator.383EADE1BD3CA65C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iterator.383EADE1BD3CA65C.idx new file mode 100755 index 0000000..e2efdbd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/iterator.383EADE1BD3CA65C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/legendre_function.tcc.CDCF14C01A1BF745.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/legendre_function.tcc.CDCF14C01A1BF745.idx new file mode 100755 index 0000000..f00baae Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/legendre_function.tcc.CDCF14C01A1BF745.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libc-header-start.h.1C0FBEF85547B680.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libc-header-start.h.1C0FBEF85547B680.idx new file mode 100755 index 0000000..45e1cc3 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libc-header-start.h.1C0FBEF85547B680.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libm-simd-decl-stubs.h.A6CB3BD9B4EB41BB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libm-simd-decl-stubs.h.A6CB3BD9B4EB41BB.idx new file mode 100755 index 0000000..e53c290 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/libm-simd-decl-stubs.h.A6CB3BD9B4EB41BB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.3F8E18340D58C8CB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.3F8E18340D58C8CB.idx new file mode 100755 index 0000000..eb0c5d8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.3F8E18340D58C8CB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.1DFE7D0FE6434B13.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.1DFE7D0FE6434B13.idx new file mode 100755 index 0000000..30ae52d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.1DFE7D0FE6434B13.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.A6E9167E78935B6F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.A6E9167E78935B6F.idx new file mode 100755 index 0000000..bd500d1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.A6E9167E78935B6F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.C293B8934AC926BB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.C293B8934AC926BB.idx new file mode 100755 index 0000000..2839b1a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/limits.h.C293B8934AC926BB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.FC912D82678614C1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.FC912D82678614C1.idx new file mode 100755 index 0000000..e3df66e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.FC912D82678614C1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.tcc.B7E0A0BAFF6A2234.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.tcc.B7E0A0BAFF6A2234.idx new file mode 100755 index 0000000..6807888 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/list.tcc.B7E0A0BAFF6A2234.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/local_lim.h.A1F0B5161BD6CDAD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/local_lim.h.A1F0B5161BD6CDAD.idx new file mode 100755 index 0000000..e4a4e42 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/local_lim.h.A1F0B5161BD6CDAD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.7039615D8288AE78.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.7039615D8288AE78.idx new file mode 100755 index 0000000..7ace6f7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.7039615D8288AE78.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.F1B51844858762D2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.F1B51844858762D2.idx new file mode 100755 index 0000000..555221a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale.h.F1B51844858762D2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.h.E65A593E46CCA8C5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.h.E65A593E46CCA8C5.idx new file mode 100755 index 0000000..1a77c22 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.h.E65A593E46CCA8C5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.tcc.96AE9DF36EC8CAD2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.tcc.96AE9DF36EC8CAD2.idx new file mode 100755 index 0000000..f7120ec Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_classes.tcc.96AE9DF36EC8CAD2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_t.h.5DC2F79D1FD1D177.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_t.h.5DC2F79D1FD1D177.idx new file mode 100755 index 0000000..35489b2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/locale_t.h.5DC2F79D1FD1D177.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/localefwd.h.7B029A698677350D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/localefwd.h.7B029A698677350D.idx new file mode 100755 index 0000000..1df6cdb Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/localefwd.h.7B029A698677350D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/long-double.h.D4BCC892B95DB530.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/long-double.h.D4BCC892B95DB530.idx new file mode 100755 index 0000000..1f24964 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/long-double.h.D4BCC892B95DB530.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/main.cpp.43034122E5F50F0D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/main.cpp.43034122E5F50F0D.idx new file mode 100755 index 0000000..810b48f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/main.cpp.43034122E5F50F0D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.cpp.51FB66BABD37AF66.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.cpp.51FB66BABD37AF66.idx new file mode 100755 index 0000000..983a525 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.cpp.51FB66BABD37AF66.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.h.E8B6FC2E2AF3280A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.h.E8B6FC2E2AF3280A.idx new file mode 100755 index 0000000..5fad229 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mainwindow.h.E8B6FC2E2AF3280A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/map.E485429270CA0E20.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/map.E485429270CA0E20.idx new file mode 100755 index 0000000..86bccaf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/map.E485429270CA0E20.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math-vector.h.EA6B90E1EDD4798B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math-vector.h.EA6B90E1EDD4798B.idx new file mode 100755 index 0000000..54edca2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math-vector.h.EA6B90E1EDD4798B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math.h.DE4D39AAF5AC2C76.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math.h.DE4D39AAF5AC2C76.idx new file mode 100755 index 0000000..82e3635 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/math.h.DE4D39AAF5AC2C76.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-helper-functions.h.6C9F0E670CB48DE2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-helper-functions.h.6C9F0E670CB48DE2.idx new file mode 100755 index 0000000..e21cee1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-helper-functions.h.6C9F0E670CB48DE2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-narrow.h.3DFB1F2663B4A290.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-narrow.h.3DFB1F2663B4A290.idx new file mode 100755 index 0000000..42d1d76 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls-narrow.h.3DFB1F2663B4A290.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls.h.37D6C5C19208639E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls.h.37D6C5C19208639E.idx new file mode 100755 index 0000000..5e1163a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mathcalls.h.37D6C5C19208639E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mbstate_t.h.E3102927D7065B9A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mbstate_t.h.E3102927D7065B9A.idx new file mode 100755 index 0000000..5aebe17 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/mbstate_t.h.E3102927D7065B9A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory.AF0EDB0E9D3D7B30.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory.AF0EDB0E9D3D7B30.idx new file mode 100755 index 0000000..221ae59 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory.AF0EDB0E9D3D7B30.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory_resource.h.E8F59FDA5247AFFA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory_resource.h.E8F59FDA5247AFFA.idx new file mode 100755 index 0000000..5026938 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memory_resource.h.E8F59FDA5247AFFA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memoryfwd.h.1E6537F09BD5D2FE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memoryfwd.h.1E6537F09BD5D2FE.idx new file mode 100755 index 0000000..028b716 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/memoryfwd.h.1E6537F09BD5D2FE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/modified_bessel_func.tcc.8D9178AED792D9CC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/modified_bessel_func.tcc.8D9178AED792D9CC.idx new file mode 100755 index 0000000..72f00dc Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/modified_bessel_func.tcc.8D9178AED792D9CC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/move.h.5B95BE0F4574679D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/move.h.5B95BE0F4574679D.idx new file mode 100755 index 0000000..64b420b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/move.h.5B95BE0F4574679D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/nested_exception.h.0E761DFE18FAD65E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/nested_exception.h.0E761DFE18FAD65E.idx new file mode 100755 index 0000000..5f1668a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/nested_exception.h.0E761DFE18FAD65E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new.B03CDBCDC1F66F94.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new.B03CDBCDC1F66F94.idx new file mode 100755 index 0000000..dc348c5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new.B03CDBCDC1F66F94.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new_allocator.h.6F3025B263C2DE1C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new_allocator.h.6F3025B263C2DE1C.idx new file mode 100755 index 0000000..78662d7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/new_allocator.h.6F3025B263C2DE1C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/node_handle.h.DA50502310B0F6F3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/node_handle.h.DA50502310B0F6F3.idx new file mode 100755 index 0000000..e4b3863 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/node_handle.h.DA50502310B0F6F3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric.E72FE61DC7A3B6C5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric.E72FE61DC7A3B6C5.idx new file mode 100755 index 0000000..da3ad3e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric.E72FE61DC7A3B6C5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric_traits.h.A16C05D3D297EBCD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric_traits.h.A16C05D3D297EBCD.idx new file mode 100755 index 0000000..1a56825 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/numeric_traits.h.A16C05D3D297EBCD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/os_defines.h.049168AF55E969E9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/os_defines.h.049168AF55E969E9.idx new file mode 100755 index 0000000..d0f3c76 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/os_defines.h.049168AF55E969E9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ostream_insert.h.B47ACD977F7DBCB7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ostream_insert.h.B47ACD977F7DBCB7.idx new file mode 100755 index 0000000..561914e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ostream_insert.h.B47ACD977F7DBCB7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/parse_numbers.h.B335047336F93165.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/parse_numbers.h.B335047336F93165.idx new file mode 100755 index 0000000..27bce20 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/parse_numbers.h.B335047336F93165.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_hermite.tcc.D413A3EF77FEEBAF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_hermite.tcc.D413A3EF77FEEBAF.idx new file mode 100755 index 0000000..1fbdfaf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_hermite.tcc.D413A3EF77FEEBAF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_laguerre.tcc.6EB83F039A07CFFB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_laguerre.tcc.6EB83F039A07CFFB.idx new file mode 100755 index 0000000..28105e6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/poly_laguerre.tcc.6EB83F039A07CFFB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix1_lim.h.F32309C974B4FD51.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix1_lim.h.F32309C974B4FD51.idx new file mode 100755 index 0000000..e4874ea Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix1_lim.h.F32309C974B4FD51.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix2_lim.h.3A58038C48DCD449.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix2_lim.h.3A58038C48DCD449.idx new file mode 100755 index 0000000..f49f74c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/posix2_lim.h.3A58038C48DCD449.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/postypes.h.947CAC52BBE48470.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/postypes.h.947CAC52BBE48470.idx new file mode 100755 index 0000000..7da43a1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/postypes.h.947CAC52BBE48470.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/predefined_ops.h.B81F650AE057C2DF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/predefined_ops.h.B81F650AE057C2DF.idx new file mode 100755 index 0000000..31d348f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/predefined_ops.h.B81F650AE057C2DF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pstl_config.h.C4AA1DAF2C9D1A9F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pstl_config.h.C4AA1DAF2C9D1A9F.idx new file mode 100755 index 0000000..eb01c35 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pstl_config.h.C4AA1DAF2C9D1A9F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread.h.022320E0CE01A46D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread.h.022320E0CE01A46D.idx new file mode 100755 index 0000000..61bcb8f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread.h.022320E0CE01A46D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread_stack_min-dynamic.h.7B19ECE3A843B2BF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread_stack_min-dynamic.h.7B19ECE3A843B2BF.idx new file mode 100755 index 0000000..07b5cdf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthread_stack_min-dynamic.h.7B19ECE3A843B2BF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes-arch.h.026BFE264B629FFA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes-arch.h.026BFE264B629FFA.idx new file mode 100755 index 0000000..b11bbc2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes-arch.h.026BFE264B629FFA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes.h.078F29FDF072791A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes.h.078F29FDF072791A.idx new file mode 100755 index 0000000..7de5f76 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/pthreadtypes.h.078F29FDF072791A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ptr_traits.h.F274F2F238D39D4A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ptr_traits.h.F274F2F238D39D4A.idx new file mode 100755 index 0000000..86c3ae6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ptr_traits.h.F274F2F238D39D4A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qabstractbutton.h.1FCA3C2F0FD9D533.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qabstractbutton.h.1FCA3C2F0FD9D533.idx new file mode 100755 index 0000000..f23a2ef Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qabstractbutton.h.1FCA3C2F0FD9D533.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qaction.h.4B9360BFECB50634.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qaction.h.4B9360BFECB50634.idx new file mode 100755 index 0000000..de25180 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qaction.h.4B9360BFECB50634.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qactiongroup.h.E15B98082A694D04.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qactiongroup.h.E15B98082A694D04.idx new file mode 100755 index 0000000..b827072 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qactiongroup.h.E15B98082A694D04.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qalgorithms.h.8983119C3A4F4410.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qalgorithms.h.8983119C3A4F4410.idx new file mode 100755 index 0000000..5c4e879 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qalgorithms.h.8983119C3A4F4410.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qapplication.h.C5525526FBDAE327.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qapplication.h.C5525526FBDAE327.idx new file mode 100755 index 0000000..ba2a625 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qapplication.h.C5525526FBDAE327.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qarraydata.h.8C35AF31B1A8D8B1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qarraydata.h.8C35AF31B1A8D8B1.idx new file mode 100755 index 0000000..1f75d98 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qarraydata.h.8C35AF31B1A8D8B1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic.h.B0914DBBCCD2EE14.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic.h.B0914DBBCCD2EE14.idx new file mode 100755 index 0000000..b8f3294 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic.h.B0914DBBCCD2EE14.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic_cxx11.h.08EE66F83AB5A6F2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic_cxx11.h.08EE66F83AB5A6F2.idx new file mode 100755 index 0000000..d15d0ea Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qatomic_cxx11.h.08EE66F83AB5A6F2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbasicatomic.h.63256410097FF75F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbasicatomic.h.63256410097FF75F.idx new file mode 100755 index 0000000..da059f9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbasicatomic.h.63256410097FF75F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbrush.h.7E70557F57527A3C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbrush.h.7E70557F57527A3C.idx new file mode 100755 index 0000000..39d60b2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbrush.h.7E70557F57527A3C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearray.h.14B83AB724E57617.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearray.h.14B83AB724E57617.idx new file mode 100755 index 0000000..2addd8e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearray.h.14B83AB724E57617.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearraylist.h.6A1B83D7A9999883.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearraylist.h.6A1B83D7A9999883.idx new file mode 100755 index 0000000..7d38440 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qbytearraylist.h.6A1B83D7A9999883.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qchar.h.4C2FDF4ACE5F2476.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qchar.h.4C2FDF4ACE5F2476.idx new file mode 100755 index 0000000..b69c751 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qchar.h.4C2FDF4ACE5F2476.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcolor.h.2314EE28406DFDAD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcolor.h.2314EE28406DFDAD.idx new file mode 100755 index 0000000..609194f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcolor.h.2314EE28406DFDAD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcompilerdetection.h.D8DDF38A5B16F2DD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcompilerdetection.h.D8DDF38A5B16F2DD.idx new file mode 100755 index 0000000..050ef70 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcompilerdetection.h.D8DDF38A5B16F2DD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qconfig.h.DD52620D98CD71D8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qconfig.h.DD52620D98CD71D8.idx new file mode 100755 index 0000000..9e054d2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qconfig.h.DD52620D98CD71D8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainerfwd.h.9B95FDD35A94B3B9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainerfwd.h.9B95FDD35A94B3B9.idx new file mode 100755 index 0000000..9ab7c71 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainerfwd.h.9B95FDD35A94B3B9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainertools_impl.h.3BF5A0BF131F841D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainertools_impl.h.3BF5A0BF131F841D.idx new file mode 100755 index 0000000..39f1a28 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcontainertools_impl.h.3BF5A0BF131F841D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreapplication.h.D2DA47DDCD73F194.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreapplication.h.D2DA47DDCD73F194.idx new file mode 100755 index 0000000..b02dfc7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreapplication.h.D2DA47DDCD73F194.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreevent.h.F6DFC70BE6732E39.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreevent.h.F6DFC70BE6732E39.idx new file mode 100755 index 0000000..f3824cd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcoreevent.h.F6DFC70BE6732E39.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcursor.h.B14F6C03BE03596C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcursor.h.B14F6C03BE03596C.idx new file mode 100755 index 0000000..305fd14 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qcursor.h.B14F6C03BE03596C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qdatastream.h.E8607458ED4738AD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qdatastream.h.E8607458ED4738AD.idx new file mode 100755 index 0000000..4e6293c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qdatastream.h.E8607458ED4738AD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qeventloop.h.5B4833A318E7B4A2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qeventloop.h.5B4833A318E7B4A2.idx new file mode 100755 index 0000000..7bcf416 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qeventloop.h.5B4833A318E7B4A2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qflags.h.D6817491BF95B797.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qflags.h.D6817491BF95B797.idx new file mode 100755 index 0000000..3d41c78 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qflags.h.D6817491BF95B797.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfont.h.30A6136236B43DBD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfont.h.30A6136236B43DBD.idx new file mode 100755 index 0000000..2866755 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfont.h.30A6136236B43DBD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontinfo.h.49373CB8952CBD73.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontinfo.h.49373CB8952CBD73.idx new file mode 100755 index 0000000..c96de75 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontinfo.h.49373CB8952CBD73.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontmetrics.h.B7F2CBDEBC1A2963.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontmetrics.h.B7F2CBDEBC1A2963.idx new file mode 100755 index 0000000..04745b5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qfontmetrics.h.B7F2CBDEBC1A2963.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qframe.h.0BF62272EBB08DC0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qframe.h.0BF62272EBB08DC0.idx new file mode 100755 index 0000000..686c5b3 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qframe.h.0BF62272EBB08DC0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qgenericatomic.h.9FAAA619221AF0D5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qgenericatomic.h.9FAAA619221AF0D5.idx new file mode 100755 index 0000000..ffb94a7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qgenericatomic.h.9FAAA619221AF0D5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobal.h.93A9010AA43A08E0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobal.h.93A9010AA43A08E0.idx new file mode 100755 index 0000000..78f8b56 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobal.h.93A9010AA43A08E0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobalstatic.h.2EE861508AEFAA99.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobalstatic.h.2EE861508AEFAA99.idx new file mode 100755 index 0000000..bea4ebf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qglobalstatic.h.2EE861508AEFAA99.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qguiapplication.h.E7CBBB8F767B075A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qguiapplication.h.E7CBBB8F767B075A.idx new file mode 100755 index 0000000..2cac465 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qguiapplication.h.E7CBBB8F767B075A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhash.h.F69B0A5C83656EAE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhash.h.F69B0A5C83656EAE.idx new file mode 100755 index 0000000..36f25e2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhash.h.F69B0A5C83656EAE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhashfunctions.h.1108A6B33776A583.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhashfunctions.h.1108A6B33776A583.idx new file mode 100755 index 0000000..d09f983 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qhashfunctions.h.1108A6B33776A583.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qicon.h.B3592B7E570CC8AB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qicon.h.B3592B7E570CC8AB.idx new file mode 100755 index 0000000..387ac97 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qicon.h.B3592B7E570CC8AB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qimage.h.0CEE9376E77AC8D6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qimage.h.0CEE9376E77AC8D6.idx new file mode 100755 index 0000000..ce531b9 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qimage.h.0CEE9376E77AC8D6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qinputmethod.h.79CDCB9A7CFD9E6D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qinputmethod.h.79CDCB9A7CFD9E6D.idx new file mode 100755 index 0000000..d100296 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qinputmethod.h.79CDCB9A7CFD9E6D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiodevice.h.6EF8D8E75865A0CC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiodevice.h.6EF8D8E75865A0CC.idx new file mode 100755 index 0000000..1b09c8c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiodevice.h.6EF8D8E75865A0CC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiterator.h.983EA3D0B8C3CA5D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiterator.h.983EA3D0B8C3CA5D.idx new file mode 100755 index 0000000..3ebb500 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qiterator.h.983EA3D0B8C3CA5D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qkeysequence.h.DA3C348959D992A0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qkeysequence.h.DA3C348959D992A0.idx new file mode 100755 index 0000000..590d368 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qkeysequence.h.DA3C348959D992A0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlabel.h.92EE3372C2ECF51E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlabel.h.92EE3372C2ECF51E.idx new file mode 100755 index 0000000..dca95f1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlabel.h.92EE3372C2ECF51E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qline.h.A7B86CD9AE1399D1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qline.h.A7B86CD9AE1399D1.idx new file mode 100755 index 0000000..86ea939 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qline.h.A7B86CD9AE1399D1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlist.h.026C05CAB6060E55.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlist.h.026C05CAB6060E55.idx new file mode 100755 index 0000000..fc78877 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlist.h.026C05CAB6060E55.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlocale.h.997A07B856CBFC74.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlocale.h.997A07B856CBFC74.idx new file mode 100755 index 0000000..885b541 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlocale.h.997A07B856CBFC74.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlogging.h.5416806879F5CC50.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlogging.h.5416806879F5CC50.idx new file mode 100755 index 0000000..66a2ebf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qlogging.h.5416806879F5CC50.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmainwindow.h.70A34316211948A7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmainwindow.h.70A34316211948A7.idx new file mode 100755 index 0000000..617dc65 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmainwindow.h.70A34316211948A7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmap.h.5EBB2D3DF559E147.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmap.h.5EBB2D3DF559E147.idx new file mode 100755 index 0000000..86a42f6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmap.h.5EBB2D3DF559E147.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmargins.h.502FAADBB748DA0A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmargins.h.502FAADBB748DA0A.idx new file mode 100755 index 0000000..1249f50 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmargins.h.502FAADBB748DA0A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmatrix.h.00C470FEF7ABD601.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmatrix.h.00C470FEF7ABD601.idx new file mode 100755 index 0000000..edca391 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmatrix.h.00C470FEF7ABD601.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenu.h.19EA7D056BDD44C7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenu.h.19EA7D056BDD44C7.idx new file mode 100755 index 0000000..f4193cc Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenu.h.19EA7D056BDD44C7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenubar.h.A66D88CA379D2DFD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenubar.h.A66D88CA379D2DFD.idx new file mode 100755 index 0000000..1468fb0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmenubar.h.A66D88CA379D2DFD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmetatype.h.C7E90A2324BCDCB8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmetatype.h.C7E90A2324BCDCB8.idx new file mode 100755 index 0000000..79ca851 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qmetatype.h.C7E90A2324BCDCB8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnamespace.h.810D42BB5BDD6863.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnamespace.h.810D42BB5BDD6863.idx new file mode 100755 index 0000000..14c35d2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnamespace.h.810D42BB5BDD6863.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnumeric.h.F3162EE0B1D312D3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnumeric.h.F3162EE0B1D312D3.idx new file mode 100755 index 0000000..e2d9a3f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qnumeric.h.F3162EE0B1D312D3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject.h.281C384D4D8724B1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject.h.281C384D4D8724B1.idx new file mode 100755 index 0000000..b3b2f03 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject.h.281C384D4D8724B1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject_impl.h.B2844C845F547AC5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject_impl.h.B2844C845F547AC5.idx new file mode 100755 index 0000000..be7c73b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobject_impl.h.B2844C845F547AC5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.598B10433A0B063A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.598B10433A0B063A.idx new file mode 100755 index 0000000..2604229 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.598B10433A0B063A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.927E55F18448F0C7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.927E55F18448F0C7.idx new file mode 100755 index 0000000..a5c9513 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs.h.927E55F18448F0C7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs_impl.h.3781C22193C0D6D7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs_impl.h.3781C22193C0D6D7.idx new file mode 100755 index 0000000..8ed39e8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qobjectdefs_impl.h.3781C22193C0D6D7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpaintdevice.h.8F3DA60E535F64D4.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpaintdevice.h.8F3DA60E535F64D4.idx new file mode 100755 index 0000000..58cc67a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpaintdevice.h.8F3DA60E535F64D4.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpair.h.435B12CF8A0C29D3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpair.h.435B12CF8A0C29D3.idx new file mode 100755 index 0000000..9389738 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpair.h.435B12CF8A0C29D3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpalette.h.9129DB26820CBE82.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpalette.h.9129DB26820CBE82.idx new file mode 100755 index 0000000..f1297d6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpalette.h.9129DB26820CBE82.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixelformat.h.F833720AE57659E0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixelformat.h.F833720AE57659E0.idx new file mode 100755 index 0000000..31e15e0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixelformat.h.F833720AE57659E0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixmap.h.BFF8EA8EE67F2A29.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixmap.h.BFF8EA8EE67F2A29.idx new file mode 100755 index 0000000..ae7a5bd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpixmap.h.BFF8EA8EE67F2A29.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpoint.h.38C91BCE47F7DA0A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpoint.h.38C91BCE47F7DA0A.idx new file mode 100755 index 0000000..77b731a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpoint.h.38C91BCE47F7DA0A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpolygon.h.8B4AE9B0B44118CB.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpolygon.h.8B4AE9B0B44118CB.idx new file mode 100755 index 0000000..349db72 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpolygon.h.8B4AE9B0B44118CB.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qprocessordetection.h.78CE39FB72DA2B98.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qprocessordetection.h.78CE39FB72DA2B98.idx new file mode 100755 index 0000000..b00cd9f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qprocessordetection.h.78CE39FB72DA2B98.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpushbutton.h.98B857D20241E82C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpushbutton.h.98B857D20241E82C.idx new file mode 100755 index 0000000..0d8fd25 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qpushbutton.h.98B857D20241E82C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrect.h.8577C49A8799EFE5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrect.h.8577C49A8799EFE5.idx new file mode 100755 index 0000000..d23ca15 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrect.h.8577C49A8799EFE5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrefcount.h.A40E6231913EB62C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrefcount.h.A40E6231913EB62C.idx new file mode 100755 index 0000000..4a2bfb4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrefcount.h.A40E6231913EB62C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregexp.h.C7B370D4BBD4D4BE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregexp.h.C7B370D4BBD4D4BE.idx new file mode 100755 index 0000000..b0c8eee Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregexp.h.C7B370D4BBD4D4BE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregion.h.27B296E551A6DA37.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregion.h.27B296E551A6DA37.idx new file mode 100755 index 0000000..d2a3c64 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qregion.h.27B296E551A6DA37.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgb.h.02313375437209F7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgb.h.02313375437209F7.idx new file mode 100755 index 0000000..d85036b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgb.h.02313375437209F7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgba64.h.B8DA4A49231CC498.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgba64.h.B8DA4A49231CC498.idx new file mode 100755 index 0000000..6ee80ed Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qrgba64.h.B8DA4A49231CC498.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qscopedpointer.h.78E26E62C20F6148.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qscopedpointer.h.78E26E62C20F6148.idx new file mode 100755 index 0000000..cf12af4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qscopedpointer.h.78E26E62C20F6148.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qshareddata.h.0399C8FFB22C999F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qshareddata.h.0399C8FFB22C999F.idx new file mode 100755 index 0000000..0a7d5b2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qshareddata.h.0399C8FFB22C999F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer.h.1BDB99CBEF3CC49B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer.h.1BDB99CBEF3CC49B.idx new file mode 100755 index 0000000..bf1b2c0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer.h.1BDB99CBEF3CC49B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer_impl.h.51B11AEF9FD8963F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer_impl.h.51B11AEF9FD8963F.idx new file mode 100755 index 0000000..6863034 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsharedpointer_impl.h.51B11AEF9FD8963F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsize.h.894FC553861FA135.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsize.h.894FC553861FA135.idx new file mode 100755 index 0000000..c1f7c9e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsize.h.894FC553861FA135.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsizepolicy.h.99B0028090FC1FD7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsizepolicy.h.99B0028090FC1FD7.idx new file mode 100755 index 0000000..69c0da1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsizepolicy.h.99B0028090FC1FD7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstring.h.F88D922A4EE35C88.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstring.h.F88D922A4EE35C88.idx new file mode 100755 index 0000000..8f8946d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstring.h.F88D922A4EE35C88.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringalgorithms.h.09B2AF6E8080031D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringalgorithms.h.09B2AF6E8080031D.idx new file mode 100755 index 0000000..85492c4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringalgorithms.h.09B2AF6E8080031D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringlist.h.C73224F4A51B28D6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringlist.h.C73224F4A51B28D6.idx new file mode 100755 index 0000000..dc3de61 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringlist.h.C73224F4A51B28D6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringliteral.h.5806ABEB4D4DCBD3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringliteral.h.5806ABEB4D4DCBD3.idx new file mode 100755 index 0000000..79c509b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringliteral.h.5806ABEB4D4DCBD3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringmatcher.h.1C31726340DF9B59.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringmatcher.h.1C31726340DF9B59.idx new file mode 100755 index 0000000..ad61225 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringmatcher.h.1C31726340DF9B59.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringview.h.575B24F9E73E2F90.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringview.h.575B24F9E73E2F90.idx new file mode 100755 index 0000000..84464c2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qstringview.h.575B24F9E73E2F90.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsysinfo.h.F887A9E04699B60E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsysinfo.h.F887A9E04699B60E.idx new file mode 100755 index 0000000..7571ff0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsysinfo.h.F887A9E04699B60E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsystemdetection.h.D2536931B8ED2B9F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsystemdetection.h.D2536931B8ED2B9F.idx new file mode 100755 index 0000000..f10b980 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qsystemdetection.h.D2536931B8ED2B9F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtabwidget.h.40CB5414C72ED352.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtabwidget.h.40CB5414C72ED352.idx new file mode 100755 index 0000000..d20ce47 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtabwidget.h.40CB5414C72ED352.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtcore-config.h.85E4AD1530DE6EDF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtcore-config.h.85E4AD1530DE6EDF.idx new file mode 100755 index 0000000..6f3cc55 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtcore-config.h.85E4AD1530DE6EDF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtgui-config.h.0AECA8132DE3369D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtgui-config.h.0AECA8132DE3369D.idx new file mode 100755 index 0000000..759ee7a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtgui-config.h.0AECA8132DE3369D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtguiglobal.h.20A174910D038679.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtguiglobal.h.20A174910D038679.idx new file mode 100755 index 0000000..ad52aa8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtguiglobal.h.20A174910D038679.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtransform.h.AA60039EFB721986.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtransform.h.AA60039EFB721986.idx new file mode 100755 index 0000000..e8d07bf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtransform.h.AA60039EFB721986.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgets-config.h.CFF0B1C2C04C2304.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgets-config.h.CFF0B1C2C04C2304.idx new file mode 100755 index 0000000..3389cec Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgets-config.h.CFF0B1C2C04C2304.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgetsglobal.h.2150ACA0E8F865B3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgetsglobal.h.2150ACA0E8F865B3.idx new file mode 100755 index 0000000..42d6577 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtwidgetsglobal.h.2150ACA0E8F865B3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtypeinfo.h.735D630403E478F4.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtypeinfo.h.735D630403E478F4.idx new file mode 100755 index 0000000..617f108 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qtypeinfo.h.735D630403E478F4.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvariant.h.831304B117EB091F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvariant.h.831304B117EB091F.idx new file mode 100755 index 0000000..794a14d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvariant.h.831304B117EB091F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvarlengtharray.h.2F99B038A6B0B257.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvarlengtharray.h.2F99B038A6B0B257.idx new file mode 100755 index 0000000..7c62c7f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvarlengtharray.h.2F99B038A6B0B257.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvector.h.BD3BEDA719E00E88.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvector.h.BD3BEDA719E00E88.idx new file mode 100755 index 0000000..7db4876 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qvector.h.BD3BEDA719E00E88.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qversiontagging.h.2644BC937C55A361.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qversiontagging.h.2644BC937C55A361.idx new file mode 100755 index 0000000..6f46ef1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qversiontagging.h.2644BC937C55A361.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwidget.h.55EC046429410313.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwidget.h.55EC046429410313.idx new file mode 100755 index 0000000..582b633 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwidget.h.55EC046429410313.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwindowdefs.h.BC90157CA7EC89EE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwindowdefs.h.BC90157CA7EC89EE.idx new file mode 100755 index 0000000..5f8fb0e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/qwindowdefs.h.BC90157CA7EC89EE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/range_access.h.4DCBE76E4C8376BA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/range_access.h.4DCBE76E4C8376BA.idx new file mode 100755 index 0000000..09efe9f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/range_access.h.4DCBE76E4C8376BA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ratio.3D26AC804185A4D9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ratio.3D26AC804185A4D9.idx new file mode 100755 index 0000000..bcaa7d5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ratio.3D26AC804185A4D9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/refwrap.h.90C41551777C705E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/refwrap.h.90C41551777C705E.idx new file mode 100755 index 0000000..03dd2ce Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/refwrap.h.90C41551777C705E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/requires_hosted.h.7FA40C8E6EA5C9F8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/requires_hosted.h.7FA40C8E6EA5C9F8.idx new file mode 100755 index 0000000..9488d01 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/requires_hosted.h.7FA40C8E6EA5C9F8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/riemann_zeta.tcc.262BC87DE326D651.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/riemann_zeta.tcc.262BC87DE326D651.idx new file mode 100755 index 0000000..a5db93c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/riemann_zeta.tcc.262BC87DE326D651.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.3B96B0F03E6EBEC7.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.3B96B0F03E6EBEC7.idx new file mode 100755 index 0000000..0fe7265 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.3B96B0F03E6EBEC7.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.E8530EF262253892.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.E8530EF262253892.idx new file mode 100755 index 0000000..4ac3eaf Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sched.h.E8530EF262253892.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.B782DFA7AF82626C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.B782DFA7AF82626C.idx new file mode 100755 index 0000000..2942d15 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.B782DFA7AF82626C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.E66249F12D3AF654.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.E66249F12D3AF654.idx new file mode 100755 index 0000000..a7a9c6b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/select.h.E66249F12D3AF654.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/setjmp.h.6CF72ED99D57E7CF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/setjmp.h.6CF72ED99D57E7CF.idx new file mode 100755 index 0000000..dc5dc89 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/setjmp.h.6CF72ED99D57E7CF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr.h.28A1E26C45CF6C70.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr.h.28A1E26C45CF6C70.idx new file mode 100755 index 0000000..f4851b1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr.h.28A1E26C45CF6C70.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_atomic.h.46177A5082E22D27.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_atomic.h.46177A5082E22D27.idx new file mode 100755 index 0000000..dae4dac Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_atomic.h.46177A5082E22D27.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_base.h.3CD12CA08E534E2A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_base.h.3CD12CA08E534E2A.idx new file mode 100755 index 0000000..cd3a58c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/shared_ptr_base.h.3CD12CA08E534E2A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sigset_t.h.90E8434286D517E1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sigset_t.h.90E8434286D517E1.idx new file mode 100755 index 0000000..3903b2e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/sigset_t.h.90E8434286D517E1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/single_threaded.h.42668328F7DC2E1F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/single_threaded.h.42668328F7DC2E1F.idx new file mode 100755 index 0000000..c60c5ef Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/single_threaded.h.42668328F7DC2E1F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/specfun.h.35594A6C9CE44488.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/specfun.h.35594A6C9CE44488.idx new file mode 100755 index 0000000..fbc94e0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/specfun.h.35594A6C9CE44488.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/special_function_util.h.D4B9F9F9E5F0C5C5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/special_function_util.h.D4B9F9F9E5F0C5C5.idx new file mode 100755 index 0000000..2380037 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/special_function_util.h.D4B9F9F9E5F0C5C5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_abs.h.E82A13146AF1CA61.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_abs.h.E82A13146AF1CA61.idx new file mode 100755 index 0000000..0f69547 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_abs.h.E82A13146AF1CA61.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_function.h.52B44B380783E733.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_function.h.52B44B380783E733.idx new file mode 100755 index 0000000..a1f70f7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/std_function.h.52B44B380783E733.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdarg.h.0F61034D918E194E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdarg.h.0F61034D918E194E.idx new file mode 100755 index 0000000..ccfa97c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdarg.h.0F61034D918E194E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdc-predef.h.9EA93D70716BF84B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdc-predef.h.9EA93D70716BF84B.idx new file mode 100755 index 0000000..30de0be Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdc-predef.h.9EA93D70716BF84B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stddef.h.AE2DA21BC2124F78.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stddef.h.AE2DA21BC2124F78.idx new file mode 100755 index 0000000..b662a35 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stddef.h.AE2DA21BC2124F78.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdexcept.1AD51D38DA738116.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdexcept.1AD51D38DA738116.idx new file mode 100755 index 0000000..3616a95 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdexcept.1AD51D38DA738116.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-intn.h.1B33604E07F2EC64.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-intn.h.1B33604E07F2EC64.idx new file mode 100755 index 0000000..f357be2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-intn.h.1B33604E07F2EC64.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-least.h.E1EEA43D7328057E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-least.h.E1EEA43D7328057E.idx new file mode 100755 index 0000000..f1218a6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-least.h.E1EEA43D7328057E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-uintn.h.C3F4DADBEB0A0F7D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-uintn.h.C3F4DADBEB0A0F7D.idx new file mode 100755 index 0000000..4826f21 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint-uintn.h.C3F4DADBEB0A0F7D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.22B451C129B23D79.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.22B451C129B23D79.idx new file mode 100755 index 0000000..782ac12 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.22B451C129B23D79.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.B9BC61D451873DA9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.B9BC61D451873DA9.idx new file mode 100755 index 0000000..c7fe201 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdint.h.B9BC61D451873DA9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio.h.6919C07CB89D47AD.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio.h.6919C07CB89D47AD.idx new file mode 100755 index 0000000..bcd30f1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio.h.6919C07CB89D47AD.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio_lim.h.E27D5CAD1DA797FA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio_lim.h.E27D5CAD1DA797FA.idx new file mode 100755 index 0000000..6667989 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdio_lim.h.E27D5CAD1DA797FA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib-float.h.2403F3F56D6FE40D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib-float.h.2403F3F56D6FE40D.idx new file mode 100755 index 0000000..6fad6c5 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib-float.h.2403F3F56D6FE40D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.2EFEF76FBD46C0CF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.2EFEF76FBD46C0CF.idx new file mode 100755 index 0000000..b88d30c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.2EFEF76FBD46C0CF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.61AA7B9EED10C430.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.61AA7B9EED10C430.idx new file mode 100755 index 0000000..326cf03 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stdlib.h.61AA7B9EED10C430.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algo.h.9405E152B100F27E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algo.h.9405E152B100F27E.idx new file mode 100755 index 0000000..0528e6b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algo.h.9405E152B100F27E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algobase.h.6EC4E1DD2AF56F64.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algobase.h.6EC4E1DD2AF56F64.idx new file mode 100755 index 0000000..dce80f7 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_algobase.h.6EC4E1DD2AF56F64.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_bvector.h.2A70990EC5690265.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_bvector.h.2A70990EC5690265.idx new file mode 100755 index 0000000..ca4c66a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_bvector.h.2A70990EC5690265.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_construct.h.6244B138823B9ED3.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_construct.h.6244B138823B9ED3.idx new file mode 100755 index 0000000..936fbbe Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_construct.h.6244B138823B9ED3.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_function.h.11D26C7975DA7673.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_function.h.11D26C7975DA7673.idx new file mode 100755 index 0000000..97f4b9f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_function.h.11D26C7975DA7673.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_heap.h.DA3ECABD32626DA6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_heap.h.DA3ECABD32626DA6.idx new file mode 100755 index 0000000..2654f3d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_heap.h.DA3ECABD32626DA6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator.h.7277B71F89457363.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator.h.7277B71F89457363.idx new file mode 100755 index 0000000..0c1640e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator.h.7277B71F89457363.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_funcs.h.F7490410D12D4913.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_funcs.h.F7490410D12D4913.idx new file mode 100755 index 0000000..8bef064 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_funcs.h.F7490410D12D4913.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_types.h.3C1DBC49B7584936.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_types.h.3C1DBC49B7584936.idx new file mode 100755 index 0000000..e10e48e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_iterator_base_types.h.3C1DBC49B7584936.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_list.h.FACF262634BCC4E9.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_list.h.FACF262634BCC4E9.idx new file mode 100755 index 0000000..63eda10 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_list.h.FACF262634BCC4E9.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_map.h.7195FA1B76E02227.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_map.h.7195FA1B76E02227.idx new file mode 100755 index 0000000..58ed301 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_map.h.7195FA1B76E02227.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_multimap.h.5EEA71C508621A5C.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_multimap.h.5EEA71C508621A5C.idx new file mode 100755 index 0000000..135e831 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_multimap.h.5EEA71C508621A5C.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_numeric.h.7C41F9627869230F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_numeric.h.7C41F9627869230F.idx new file mode 100755 index 0000000..5db9a7e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_numeric.h.7C41F9627869230F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_pair.h.5D88892FEA0C6D99.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_pair.h.5D88892FEA0C6D99.idx new file mode 100755 index 0000000..4e1f395 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_pair.h.5D88892FEA0C6D99.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_raw_storage_iter.h.E414377E1BCB8773.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_raw_storage_iter.h.E414377E1BCB8773.idx new file mode 100755 index 0000000..d458d6b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_raw_storage_iter.h.E414377E1BCB8773.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_relops.h.DE50F1B7F3D646A8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_relops.h.DE50F1B7F3D646A8.idx new file mode 100755 index 0000000..f85d62b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_relops.h.DE50F1B7F3D646A8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tempbuf.h.4794057264A8802F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tempbuf.h.4794057264A8802F.idx new file mode 100755 index 0000000..4a3eea3 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tempbuf.h.4794057264A8802F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tree.h.E586939CDDF41177.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tree.h.E586939CDDF41177.idx new file mode 100755 index 0000000..3263328 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_tree.h.E586939CDDF41177.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_uninitialized.h.BAB2EB8FAF1B7447.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_uninitialized.h.BAB2EB8FAF1B7447.idx new file mode 100755 index 0000000..44cae6f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_uninitialized.h.BAB2EB8FAF1B7447.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_vector.h.54FDE39F88213089.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_vector.h.54FDE39F88213089.idx new file mode 100755 index 0000000..9937e76 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stl_vector.h.54FDE39F88213089.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stream_iterator.h.5DC0D25D981545E2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stream_iterator.h.5DC0D25D981545E2.idx new file mode 100755 index 0000000..c4d2db0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stream_iterator.h.5DC0D25D981545E2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.E3BEEB1140D783A0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.E3BEEB1140D783A0.idx new file mode 100755 index 0000000..ec7128c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.E3BEEB1140D783A0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.tcc.196CE349FAD0EB92.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.tcc.196CE349FAD0EB92.idx new file mode 100755 index 0000000..0afec6a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf.tcc.196CE349FAD0EB92.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf_iterator.h.3892C42D2CE6C537.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf_iterator.h.3892C42D2CE6C537.idx new file mode 100755 index 0000000..5e150a1 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/streambuf_iterator.h.3892C42D2CE6C537.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.C27A714773539828.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.C27A714773539828.idx new file mode 100755 index 0000000..98d0d8b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.C27A714773539828.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.h.979B97B48AB27554.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.h.979B97B48AB27554.idx new file mode 100755 index 0000000..b48cad4 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string.h.979B97B48AB27554.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_conversions.h.B8EE39FF446BAE7B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_conversions.h.B8EE39FF446BAE7B.idx new file mode 100755 index 0000000..60229b6 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_conversions.h.B8EE39FF446BAE7B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.E111423CF73AA4C8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.E111423CF73AA4C8.idx new file mode 100755 index 0000000..c3c671b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.E111423CF73AA4C8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.tcc.BE1C60A6D9C9FBCC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.tcc.BE1C60A6D9C9FBCC.idx new file mode 100755 index 0000000..d4b7daa Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/string_view.tcc.BE1C60A6D9C9FBCC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stringfwd.h.A68CB508CF7C1701.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stringfwd.h.A68CB508CF7C1701.idx new file mode 100755 index 0000000..e61090e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stringfwd.h.A68CB508CF7C1701.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/strings.h.9EB46A34EB89BB5D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/strings.h.9EB46A34EB89BB5D.idx new file mode 100755 index 0000000..d3d371a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/strings.h.9EB46A34EB89BB5D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_FILE.h.BD746D724FA26A14.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_FILE.h.BD746D724FA26A14.idx new file mode 100755 index 0000000..59f4890 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_FILE.h.BD746D724FA26A14.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct___jmp_buf_tag.h.A22635099DBEC9CF.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct___jmp_buf_tag.h.A22635099DBEC9CF.idx new file mode 100755 index 0000000..ea31802 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct___jmp_buf_tag.h.A22635099DBEC9CF.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_itimerspec.h.5B266D5900E24BB5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_itimerspec.h.5B266D5900E24BB5.idx new file mode 100755 index 0000000..e7dc272 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_itimerspec.h.5B266D5900E24BB5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_mutex.h.4C3362835A033C07.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_mutex.h.4C3362835A033C07.idx new file mode 100755 index 0000000..f3c1390 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_mutex.h.4C3362835A033C07.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_rwlock.h.015225931B7E9A45.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_rwlock.h.015225931B7E9A45.idx new file mode 100755 index 0000000..f874db2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_rwlock.h.015225931B7E9A45.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_sched_param.h.3F36B920743964D0.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_sched_param.h.3F36B920743964D0.idx new file mode 100755 index 0000000..11255a8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_sched_param.h.3F36B920743964D0.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timespec.h.84E4D8A674C22D31.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timespec.h.84E4D8A674C22D31.idx new file mode 100755 index 0000000..468bbde Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timespec.h.84E4D8A674C22D31.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timeval.h.E5EFAE6351E57E37.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timeval.h.E5EFAE6351E57E37.idx new file mode 100755 index 0000000..0b8b805 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_timeval.h.E5EFAE6351E57E37.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_tm.h.6F6EC6D30ECF5E52.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_tm.h.6F6EC6D30ECF5E52.idx new file mode 100755 index 0000000..2071999 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/struct_tm.h.6F6EC6D30ECF5E52.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs-64.h.C9B9EF9F85A49B89.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs-64.h.C9B9EF9F85A49B89.idx new file mode 100755 index 0000000..ea96db0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs-64.h.C9B9EF9F85A49B89.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs.h.082359ACEA197EE8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs.h.082359ACEA197EE8.idx new file mode 100755 index 0000000..ea12bba Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/stubs.h.082359ACEA197EE8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/system_error.1EEC7C42E0D6BAE2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/system_error.1EEC7C42E0D6BAE2.idx new file mode 100755 index 0000000..48ec28a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/system_error.1EEC7C42E0D6BAE2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/thread-shared-types.h.3BF83EAF2453B9EE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/thread-shared-types.h.3BF83EAF2453B9EE.idx new file mode 100755 index 0000000..ab76a1d Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/thread-shared-types.h.3BF83EAF2453B9EE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.83E62EFE4747EE1B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.83E62EFE4747EE1B.idx new file mode 100755 index 0000000..a260076 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.83E62EFE4747EE1B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.EDC06F0AFB6EC7EC.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.EDC06F0AFB6EC7EC.idx new file mode 100755 index 0000000..a0cbd2f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time.h.EDC06F0AFB6EC7EC.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time64.h.CB321F1760C06220.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time64.h.CB321F1760C06220.idx new file mode 100755 index 0000000..fc3696b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time64.h.CB321F1760C06220.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time_t.h.BAF6123CBDB646D6.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time_t.h.BAF6123CBDB646D6.idx new file mode 100755 index 0000000..4e51602 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/time_t.h.BAF6123CBDB646D6.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timer_t.h.DE52AF3543DCC14B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timer_t.h.DE52AF3543DCC14B.idx new file mode 100755 index 0000000..a35c45c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timer_t.h.DE52AF3543DCC14B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timesize.h.B987EAFC7C6E7540.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timesize.h.B987EAFC7C6E7540.idx new file mode 100755 index 0000000..d4f3360 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timesize.h.B987EAFC7C6E7540.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timex.h.529D3176CEFB16C2.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timex.h.529D3176CEFB16C2.idx new file mode 100755 index 0000000..fea894e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/timex.h.529D3176CEFB16C2.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/tuple.0BADC7F0062AC6B5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/tuple.0BADC7F0062AC6B5.idx new file mode 100755 index 0000000..6fbde7a Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/tuple.0BADC7F0062AC6B5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.422189490C064711.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.422189490C064711.idx new file mode 100755 index 0000000..d906efc Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.422189490C064711.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.h.163184A3252344BA.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.h.163184A3252344BA.idx new file mode 100755 index 0000000..55fac9e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/type_traits.h.163184A3252344BA.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typeinfo.085FA8A13242911A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typeinfo.085FA8A13242911A.idx new file mode 100755 index 0000000..1c6593c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typeinfo.085FA8A13242911A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.03E112F1187911D8.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.03E112F1187911D8.idx new file mode 100755 index 0000000..e8f0519 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.03E112F1187911D8.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.A9C854B704566561.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.A9C854B704566561.idx new file mode 100755 index 0000000..1ccc083 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/types.h.A9C854B704566561.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typesizes.h.458576AD7CBC208B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typesizes.h.458576AD7CBC208B.idx new file mode 100755 index 0000000..edee01e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/typesizes.h.458576AD7CBC208B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ui_mainwindow.h.F6BC49BE2DB3B23E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ui_mainwindow.h.F6BC49BE2DB3B23E.idx new file mode 100755 index 0000000..1fa35fd Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/ui_mainwindow.h.F6BC49BE2DB3B23E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uintn-identity.h.1CA9207577CEA5E1.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uintn-identity.h.1CA9207577CEA5E1.idx new file mode 100755 index 0000000..5eeee73 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uintn-identity.h.1CA9207577CEA5E1.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uio_lim.h.58CBF8BD1DEA587F.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uio_lim.h.58CBF8BD1DEA587F.idx new file mode 100755 index 0000000..02bc888 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uio_lim.h.58CBF8BD1DEA587F.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uniform_int_dist.h.71E677A1DCCFBF49.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uniform_int_dist.h.71E677A1DCCFBF49.idx new file mode 100755 index 0000000..43b056f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uniform_int_dist.h.71E677A1DCCFBF49.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unique_ptr.h.8425F457D485DB8A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unique_ptr.h.8425F457D485DB8A.idx new file mode 100755 index 0000000..2ca8c3b Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unique_ptr.h.8425F457D485DB8A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.C50186D922C13142.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.C50186D922C13142.idx new file mode 100755 index 0000000..0742e2f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.C50186D922C13142.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.h.3BCF46B70CD44A7A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.h.3BCF46B70CD44A7A.idx new file mode 100755 index 0000000..6cdaa40 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/unordered_map.h.3BCF46B70CD44A7A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator.h.2AEBF88BDC7A8DC5.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator.h.2AEBF88BDC7A8DC5.idx new file mode 100755 index 0000000..0579826 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator.h.2AEBF88BDC7A8DC5.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator_args.h.34D312B0A21C734A.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator_args.h.34D312B0A21C734A.idx new file mode 100755 index 0000000..b82784c Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/uses_allocator_args.h.34D312B0A21C734A.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.68AACC9B6FD91F5E.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.68AACC9B6FD91F5E.idx new file mode 100755 index 0000000..5cad38f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.68AACC9B6FD91F5E.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.h.D7F2631911D87119.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.h.D7F2631911D87119.idx new file mode 100755 index 0000000..2b4bcf0 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/utility.h.D7F2631911D87119.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/variant.099AFEABD40E712D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/variant.099AFEABD40E712D.idx new file mode 100755 index 0000000..0128921 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/variant.099AFEABD40E712D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.E5134B7F97F70CAE.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.E5134B7F97F70CAE.idx new file mode 100755 index 0000000..a66fd42 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.E5134B7F97F70CAE.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.tcc.8206317A39F11217.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.tcc.8206317A39F11217.idx new file mode 100755 index 0000000..34c9bb3 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/vector.tcc.8206317A39F11217.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/version.h.8DE8B626C9B02874.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/version.h.8DE8B626C9B02874.idx new file mode 100755 index 0000000..cfba4b2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/version.h.8DE8B626C9B02874.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitflags.h.1480026F0BFFE024.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitflags.h.1480026F0BFFE024.idx new file mode 100755 index 0000000..5bfd928 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitflags.h.1480026F0BFFE024.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitstatus.h.C8A83CD20FAF0338.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitstatus.h.C8A83CD20FAF0338.idx new file mode 100755 index 0000000..dd13dac Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/waitstatus.h.C8A83CD20FAF0338.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.83BD995621576773.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.83BD995621576773.idx new file mode 100755 index 0000000..0440ba8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.83BD995621576773.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.CA624B234FF5EB1D.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.CA624B234FF5EB1D.idx new file mode 100755 index 0000000..429f4c3 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wchar.h.CA624B234FF5EB1D.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wint_t.h.CEEF00AA17514887.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wint_t.h.CEEF00AA17514887.idx new file mode 100755 index 0000000..55b726e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wint_t.h.CEEF00AA17514887.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wordsize.h.B3DEF3D506FCA17B.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wordsize.h.B3DEF3D506FCA17B.idx new file mode 100755 index 0000000..a009c70 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/wordsize.h.B3DEF3D506FCA17B.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/xopen_lim.h.A1D830D18B7E0691.idx b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/xopen_lim.h.A1D830D18B7E0691.idx new file mode 100755 index 0000000..8abf3a8 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/.cache/clangd/index/xopen_lim.h.A1D830D18B7E0691.idx differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/compile_commands.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/compile_commands.json new file mode 100755 index 0000000..c231755 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/.qtc_clangd/compile_commands.json @@ -0,0 +1 @@ +[{"arguments":["clang","-Wno-documentation-unknown-command","-Wno-unknown-warning-option","-Wno-unknown-pragmas","-nostdinc","-nostdinc++","-DQT_QML_DEBUG","-g","-std=gnu++17","-fdiagnostics-color=always","-fPIC","-fsyntax-only","-m64","--target=x86_64-pc-linux-gnu","-DQT_CORE_LIB","-DQT_GUI_LIB","-DQT_WIDGETS_LIB","-DQ_CREATOR_RUN","-DQT_ANNOTATE_FUNCTION(x)=__attribute__((annotate(#x)))","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders/QtCore","-I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include","-isystem","/usr/include/qt","-isystem","/usr/include/qt/QtWidgets","-isystem","/usr/include/qt/QtGui","-isystem","/usr/include/qt/QtCore","-isystem","/usr/lib/qt/mkspecs/linux-g++","-isystem","/usr/include/c++/14.2.1","-isystem","/usr/include/c++/14.2.1/x86_64-pc-linux-gnu","-isystem","/usr/include/c++/14.2.1/backward","-isystem","/usr/local/include","-isystem","/usr/lib/clang/18/include","-isystem","/usr/include","-fmessage-length=0","-fdiagnostics-show-note-include-stack","-fretain-comments-from-system-headers","-fmacro-backtrace-limit=0","-ferror-limit=1000","-x","c++","/home/nktkln/Documents/1_Calculator/main.cpp"],"directory":"/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc_clangd","file":"/home/nktkln/Documents/1_Calculator/main.cpp"},{"arguments":["clang","-Wno-documentation-unknown-command","-Wno-unknown-warning-option","-Wno-unknown-pragmas","-nostdinc","-nostdinc++","-DQT_QML_DEBUG","-g","-std=gnu++17","-fdiagnostics-color=always","-fPIC","-fsyntax-only","-m64","--target=x86_64-pc-linux-gnu","-DQT_CORE_LIB","-DQT_GUI_LIB","-DQT_WIDGETS_LIB","-DQ_CREATOR_RUN","-DQT_ANNOTATE_FUNCTION(x)=__attribute__((annotate(#x)))","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders/QtCore","-I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include","-isystem","/usr/include/qt","-isystem","/usr/include/qt/QtWidgets","-isystem","/usr/include/qt/QtGui","-isystem","/usr/include/qt/QtCore","-isystem","/usr/lib/qt/mkspecs/linux-g++","-isystem","/usr/include/c++/14.2.1","-isystem","/usr/include/c++/14.2.1/x86_64-pc-linux-gnu","-isystem","/usr/include/c++/14.2.1/backward","-isystem","/usr/local/include","-isystem","/usr/lib/clang/18/include","-isystem","/usr/include","-fmessage-length=0","-fdiagnostics-show-note-include-stack","-fretain-comments-from-system-headers","-fmacro-backtrace-limit=0","-ferror-limit=1000","-x","c++","/home/nktkln/Documents/1_Calculator/mainwindow.cpp"],"directory":"/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc_clangd","file":"/home/nktkln/Documents/1_Calculator/mainwindow.cpp"},{"arguments":["clang","-Wno-documentation-unknown-command","-Wno-unknown-warning-option","-Wno-unknown-pragmas","-nostdinc","-nostdinc++","-DQT_QML_DEBUG","-g","-std=gnu++17","-fdiagnostics-color=always","-fPIC","-fsyntax-only","-m64","--target=x86_64-pc-linux-gnu","-DQT_CORE_LIB","-DQT_GUI_LIB","-DQT_WIDGETS_LIB","-DQ_CREATOR_RUN","-DQT_ANNOTATE_FUNCTION(x)=__attribute__((annotate(#x)))","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders","-I/usr/share/qtcreator/cplusplus/wrappedQtHeaders/QtCore","-I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include","-isystem","/usr/include/qt","-isystem","/usr/include/qt/QtWidgets","-isystem","/usr/include/qt/QtGui","-isystem","/usr/include/qt/QtCore","-isystem","/usr/lib/qt/mkspecs/linux-g++","-isystem","/usr/include/c++/14.2.1","-isystem","/usr/include/c++/14.2.1/x86_64-pc-linux-gnu","-isystem","/usr/include/c++/14.2.1/backward","-isystem","/usr/local/include","-isystem","/usr/lib/clang/18/include","-isystem","/usr/include","-fmessage-length=0","-fdiagnostics-show-note-include-stack","-fretain-comments-from-system-headers","-fmacro-backtrace-limit=0","-ferror-limit=1000","-x","c++-header","/home/nktkln/Documents/1_Calculator/mainwindow.h"],"directory":"/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc_clangd","file":"/home/nktkln/Documents/1_Calculator/mainwindow.h"}] \ No newline at end of file diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator new file mode 100755 index 0000000..b1fa16f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp new file mode 100755 index 0000000..664f121 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp @@ -0,0 +1,162 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'mainwindow.h' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.14) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include +#include "../../../../mainwindow.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'mainwindow.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.15.14. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED +struct qt_meta_stringdata_MainWindow_t { + QByteArrayData data[13]; + char stringdata0[162]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + qptrdiff(offsetof(qt_meta_stringdata_MainWindow_t, stringdata0) + ofs \ + - idx * sizeof(QByteArrayData)) \ + ) +static const qt_meta_stringdata_MainWindow_t qt_meta_stringdata_MainWindow = { + { +QT_MOC_LITERAL(0, 0, 10), // "MainWindow" +QT_MOC_LITERAL(1, 11, 12), // "digitClicked" +QT_MOC_LITERAL(2, 24, 0), // "" +QT_MOC_LITERAL(3, 25, 10), // "dotClicked" +QT_MOC_LITERAL(4, 36, 10), // "addClicked" +QT_MOC_LITERAL(5, 47, 15), // "subtractClicked" +QT_MOC_LITERAL(6, 63, 15), // "multiplyClicked" +QT_MOC_LITERAL(7, 79, 13), // "divideClicked" +QT_MOC_LITERAL(8, 93, 13), // "equalsClicked" +QT_MOC_LITERAL(9, 107, 12), // "clearClicked" +QT_MOC_LITERAL(10, 120, 17), // "changeSignClicked" +QT_MOC_LITERAL(11, 138, 10), // "powClicked" +QT_MOC_LITERAL(12, 149, 12) // "printDisplay" + + }, + "MainWindow\0digitClicked\0\0dotClicked\0" + "addClicked\0subtractClicked\0multiplyClicked\0" + "divideClicked\0equalsClicked\0clearClicked\0" + "changeSignClicked\0powClicked\0printDisplay" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_MainWindow[] = { + + // content: + 8, // revision + 0, // classname + 0, 0, // classinfo + 11, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // slots: name, argc, parameters, tag, flags + 1, 0, 69, 2, 0x08 /* Private */, + 3, 0, 70, 2, 0x08 /* Private */, + 4, 0, 71, 2, 0x08 /* Private */, + 5, 0, 72, 2, 0x08 /* Private */, + 6, 0, 73, 2, 0x08 /* Private */, + 7, 0, 74, 2, 0x08 /* Private */, + 8, 0, 75, 2, 0x08 /* Private */, + 9, 0, 76, 2, 0x08 /* Private */, + 10, 0, 77, 2, 0x08 /* Private */, + 11, 0, 78, 2, 0x08 /* Private */, + 12, 0, 79, 2, 0x08 /* Private */, + + // slots: parameters + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + QMetaType::Void, + + 0 // eod +}; + +void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + auto *_t = static_cast(_o); + (void)_t; + switch (_id) { + case 0: _t->digitClicked(); break; + case 1: _t->dotClicked(); break; + case 2: _t->addClicked(); break; + case 3: _t->subtractClicked(); break; + case 4: _t->multiplyClicked(); break; + case 5: _t->divideClicked(); break; + case 6: _t->equalsClicked(); break; + case 7: _t->clearClicked(); break; + case 8: _t->changeSignClicked(); break; + case 9: _t->powClicked(); break; + case 10: _t->printDisplay(); break; + default: ; + } + } + (void)_a; +} + +QT_INIT_METAOBJECT const QMetaObject MainWindow::staticMetaObject = { { + QMetaObject::SuperData::link(), + qt_meta_stringdata_MainWindow.data, + qt_meta_data_MainWindow, + qt_static_metacall, + nullptr, + nullptr +} }; + + +const QMetaObject *MainWindow::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *MainWindow::qt_metacast(const char *_clname) +{ + if (!_clname) return nullptr; + if (!strcmp(_clname, qt_meta_stringdata_MainWindow.stringdata0)) + return static_cast(this); + return QMainWindow::qt_metacast(_clname); +} + +int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QMainWindow::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 11) + qt_static_metacall(this, _c, _id, _a); + _id -= 11; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 11) + *reinterpret_cast(_a[0]) = -1; + _id -= 11; + } + return _id; +} +QT_WARNING_POP +QT_END_MOC_NAMESPACE diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp.d b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp.d new file mode 100755 index 0000000..05e6f87 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp.d @@ -0,0 +1,337 @@ +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/EWIEGA46WW/moc_mainwindow.cpp: /home/nktkln/Documents/1_Calculator/mainwindow.h \ + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm/errno.h \ + /usr/include/asm/unistd.h \ + /usr/include/asm/unistd_64.h \ + /usr/include/assert.h \ + /usr/include/bits/atomic_wide_counter.h \ + /usr/include/bits/confname.h \ + /usr/include/bits/cpu-set.h \ + /usr/include/bits/endian.h \ + /usr/include/bits/endianness.h \ + /usr/include/bits/environments.h \ + /usr/include/bits/errno.h \ + /usr/include/bits/floatn-common.h \ + /usr/include/bits/floatn.h \ + /usr/include/bits/getopt_core.h \ + /usr/include/bits/getopt_posix.h \ + /usr/include/bits/libc-header-start.h \ + /usr/include/bits/locale.h \ + /usr/include/bits/long-double.h \ + /usr/include/bits/posix_opt.h \ + /usr/include/bits/pthread_stack_min-dynamic.h \ + /usr/include/bits/pthreadtypes-arch.h \ + /usr/include/bits/pthreadtypes.h \ + /usr/include/bits/sched.h \ + /usr/include/bits/setjmp.h \ + /usr/include/bits/struct_mutex.h \ + /usr/include/bits/struct_rwlock.h \ + /usr/include/bits/syscall.h \ + /usr/include/bits/thread-shared-types.h \ + /usr/include/bits/time.h \ + /usr/include/bits/time64.h \ + /usr/include/bits/timesize.h \ + /usr/include/bits/timex.h \ + /usr/include/bits/types.h \ + /usr/include/bits/types/FILE.h \ + /usr/include/bits/types/__FILE.h \ + /usr/include/bits/types/__locale_t.h \ + /usr/include/bits/types/__mbstate_t.h \ + /usr/include/bits/types/__sigset_t.h \ + /usr/include/bits/types/clock_t.h \ + /usr/include/bits/types/clockid_t.h \ + /usr/include/bits/types/error_t.h \ + /usr/include/bits/types/locale_t.h \ + /usr/include/bits/types/mbstate_t.h \ + /usr/include/bits/types/struct___jmp_buf_tag.h \ + /usr/include/bits/types/struct_itimerspec.h \ + /usr/include/bits/types/struct_sched_param.h \ + /usr/include/bits/types/struct_timespec.h \ + /usr/include/bits/types/struct_timeval.h \ + /usr/include/bits/types/struct_tm.h \ + /usr/include/bits/types/time_t.h \ + /usr/include/bits/types/timer_t.h \ + /usr/include/bits/types/wint_t.h \ + /usr/include/bits/typesizes.h \ + /usr/include/bits/unistd_ext.h \ + /usr/include/bits/wchar.h \ + /usr/include/bits/wctype-wchar.h \ + /usr/include/bits/wordsize.h \ + /usr/include/c++/14.2.1/algorithm \ + /usr/include/c++/14.2.1/array \ + /usr/include/c++/14.2.1/atomic \ + /usr/include/c++/14.2.1/backward/auto_ptr.h \ + /usr/include/c++/14.2.1/backward/binders.h \ + /usr/include/c++/14.2.1/bit \ + /usr/include/c++/14.2.1/bits/algorithmfwd.h \ + /usr/include/c++/14.2.1/bits/align.h \ + /usr/include/c++/14.2.1/bits/alloc_traits.h \ + /usr/include/c++/14.2.1/bits/allocated_ptr.h \ + /usr/include/c++/14.2.1/bits/allocator.h \ + /usr/include/c++/14.2.1/bits/atomic_base.h \ + /usr/include/c++/14.2.1/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14.2.1/bits/atomic_wait.h \ + /usr/include/c++/14.2.1/bits/basic_ios.h \ + /usr/include/c++/14.2.1/bits/basic_ios.tcc \ + /usr/include/c++/14.2.1/bits/basic_string.h \ + /usr/include/c++/14.2.1/bits/basic_string.tcc \ + /usr/include/c++/14.2.1/bits/c++0x_warning.h \ + /usr/include/c++/14.2.1/bits/char_traits.h \ + /usr/include/c++/14.2.1/bits/charconv.h \ + /usr/include/c++/14.2.1/bits/concept_check.h \ + /usr/include/c++/14.2.1/bits/cpp_type_traits.h \ + /usr/include/c++/14.2.1/bits/cxxabi_forced.h \ + /usr/include/c++/14.2.1/bits/cxxabi_init_exception.h \ + /usr/include/c++/14.2.1/bits/erase_if.h \ + /usr/include/c++/14.2.1/bits/exception.h \ + /usr/include/c++/14.2.1/bits/exception_defines.h \ + /usr/include/c++/14.2.1/bits/exception_ptr.h \ + /usr/include/c++/14.2.1/bits/functexcept.h \ + /usr/include/c++/14.2.1/bits/functional_hash.h \ + /usr/include/c++/14.2.1/bits/hash_bytes.h \ + /usr/include/c++/14.2.1/bits/invoke.h \ + /usr/include/c++/14.2.1/bits/ios_base.h \ + /usr/include/c++/14.2.1/bits/iterator_concepts.h \ + /usr/include/c++/14.2.1/bits/list.tcc \ + /usr/include/c++/14.2.1/bits/locale_classes.h \ + /usr/include/c++/14.2.1/bits/locale_classes.tcc \ + /usr/include/c++/14.2.1/bits/locale_facets.h \ + /usr/include/c++/14.2.1/bits/locale_facets.tcc \ + /usr/include/c++/14.2.1/bits/localefwd.h \ + /usr/include/c++/14.2.1/bits/max_size_type.h \ + /usr/include/c++/14.2.1/bits/memory_resource.h \ + /usr/include/c++/14.2.1/bits/memoryfwd.h \ + /usr/include/c++/14.2.1/bits/mofunc_impl.h \ + /usr/include/c++/14.2.1/bits/move.h \ + /usr/include/c++/14.2.1/bits/move_only_function.h \ + /usr/include/c++/14.2.1/bits/nested_exception.h \ + /usr/include/c++/14.2.1/bits/new_allocator.h \ + /usr/include/c++/14.2.1/bits/node_handle.h \ + /usr/include/c++/14.2.1/bits/ostream.tcc \ + /usr/include/c++/14.2.1/bits/ostream_insert.h \ + /usr/include/c++/14.2.1/bits/out_ptr.h \ + /usr/include/c++/14.2.1/bits/postypes.h \ + /usr/include/c++/14.2.1/bits/predefined_ops.h \ + /usr/include/c++/14.2.1/bits/ptr_traits.h \ + /usr/include/c++/14.2.1/bits/range_access.h \ + /usr/include/c++/14.2.1/bits/ranges_algo.h \ + /usr/include/c++/14.2.1/bits/ranges_algobase.h \ + /usr/include/c++/14.2.1/bits/ranges_base.h \ + /usr/include/c++/14.2.1/bits/ranges_cmp.h \ + /usr/include/c++/14.2.1/bits/ranges_uninitialized.h \ + /usr/include/c++/14.2.1/bits/ranges_util.h \ + /usr/include/c++/14.2.1/bits/refwrap.h \ + /usr/include/c++/14.2.1/bits/requires_hosted.h \ + /usr/include/c++/14.2.1/bits/sat_arith.h \ + /usr/include/c++/14.2.1/bits/shared_ptr.h \ + /usr/include/c++/14.2.1/bits/shared_ptr_atomic.h \ + /usr/include/c++/14.2.1/bits/shared_ptr_base.h \ + /usr/include/c++/14.2.1/bits/std_abs.h \ + /usr/include/c++/14.2.1/bits/std_function.h \ + /usr/include/c++/14.2.1/bits/std_mutex.h \ + /usr/include/c++/14.2.1/bits/stl_algo.h \ + /usr/include/c++/14.2.1/bits/stl_algobase.h \ + /usr/include/c++/14.2.1/bits/stl_bvector.h \ + /usr/include/c++/14.2.1/bits/stl_construct.h \ + /usr/include/c++/14.2.1/bits/stl_function.h \ + /usr/include/c++/14.2.1/bits/stl_heap.h \ + /usr/include/c++/14.2.1/bits/stl_iterator.h \ + /usr/include/c++/14.2.1/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14.2.1/bits/stl_iterator_base_types.h \ + /usr/include/c++/14.2.1/bits/stl_list.h \ + /usr/include/c++/14.2.1/bits/stl_map.h \ + /usr/include/c++/14.2.1/bits/stl_multimap.h \ + /usr/include/c++/14.2.1/bits/stl_numeric.h \ + /usr/include/c++/14.2.1/bits/stl_pair.h \ + /usr/include/c++/14.2.1/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14.2.1/bits/stl_relops.h \ + /usr/include/c++/14.2.1/bits/stl_tempbuf.h \ + /usr/include/c++/14.2.1/bits/stl_tree.h \ + /usr/include/c++/14.2.1/bits/stl_uninitialized.h \ + /usr/include/c++/14.2.1/bits/stl_vector.h \ + /usr/include/c++/14.2.1/bits/stream_iterator.h \ + /usr/include/c++/14.2.1/bits/streambuf.tcc \ + /usr/include/c++/14.2.1/bits/streambuf_iterator.h \ + /usr/include/c++/14.2.1/bits/string_view.tcc \ + /usr/include/c++/14.2.1/bits/stringfwd.h \ + /usr/include/c++/14.2.1/bits/uniform_int_dist.h \ + /usr/include/c++/14.2.1/bits/unique_ptr.h \ + /usr/include/c++/14.2.1/bits/uses_allocator.h \ + /usr/include/c++/14.2.1/bits/uses_allocator_args.h \ + /usr/include/c++/14.2.1/bits/utility.h \ + /usr/include/c++/14.2.1/bits/vector.tcc \ + /usr/include/c++/14.2.1/bits/version.h \ + /usr/include/c++/14.2.1/cctype \ + /usr/include/c++/14.2.1/cerrno \ + /usr/include/c++/14.2.1/charconv \ + /usr/include/c++/14.2.1/climits \ + /usr/include/c++/14.2.1/clocale \ + /usr/include/c++/14.2.1/compare \ + /usr/include/c++/14.2.1/concepts \ + /usr/include/c++/14.2.1/cstddef \ + /usr/include/c++/14.2.1/cstdint \ + /usr/include/c++/14.2.1/cstdlib \ + /usr/include/c++/14.2.1/cwchar \ + /usr/include/c++/14.2.1/cwctype \ + /usr/include/c++/14.2.1/debug/assertions.h \ + /usr/include/c++/14.2.1/debug/debug.h \ + /usr/include/c++/14.2.1/exception \ + /usr/include/c++/14.2.1/ext/aligned_buffer.h \ + /usr/include/c++/14.2.1/ext/alloc_traits.h \ + /usr/include/c++/14.2.1/ext/atomicity.h \ + /usr/include/c++/14.2.1/ext/concurrence.h \ + /usr/include/c++/14.2.1/ext/numeric_traits.h \ + /usr/include/c++/14.2.1/ext/string_conversions.h \ + /usr/include/c++/14.2.1/ext/type_traits.h \ + /usr/include/c++/14.2.1/format \ + /usr/include/c++/14.2.1/functional \ + /usr/include/c++/14.2.1/initializer_list \ + /usr/include/c++/14.2.1/ios \ + /usr/include/c++/14.2.1/iosfwd \ + /usr/include/c++/14.2.1/iterator \ + /usr/include/c++/14.2.1/limits \ + /usr/include/c++/14.2.1/list \ + /usr/include/c++/14.2.1/map \ + /usr/include/c++/14.2.1/memory \ + /usr/include/c++/14.2.1/new \ + /usr/include/c++/14.2.1/numbers \ + /usr/include/c++/14.2.1/numeric \ + /usr/include/c++/14.2.1/optional \ + /usr/include/c++/14.2.1/ostream \ + /usr/include/c++/14.2.1/pstl/execution_defs.h \ + /usr/include/c++/14.2.1/pstl/glue_numeric_defs.h \ + /usr/include/c++/14.2.1/stdexcept \ + /usr/include/c++/14.2.1/stdlib.h \ + /usr/include/c++/14.2.1/streambuf \ + /usr/include/c++/14.2.1/string \ + /usr/include/c++/14.2.1/string_view \ + /usr/include/c++/14.2.1/text_encoding \ + /usr/include/c++/14.2.1/tuple \ + /usr/include/c++/14.2.1/type_traits \ + /usr/include/c++/14.2.1/typeinfo \ + /usr/include/c++/14.2.1/unordered_map \ + /usr/include/c++/14.2.1/utility \ + /usr/include/c++/14.2.1/vector \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++locale.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/error_constants.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/gnu/stubs-64.h \ + /usr/include/gnu/stubs.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/qt/QtCore/qalgorithms.h \ + /usr/include/qt/QtCore/qarraydata.h \ + /usr/include/qt/QtCore/qatomic.h \ + /usr/include/qt/QtCore/qatomic_cxx11.h \ + /usr/include/qt/QtCore/qbasicatomic.h \ + /usr/include/qt/QtCore/qbytearray.h \ + /usr/include/qt/QtCore/qbytearraylist.h \ + /usr/include/qt/QtCore/qchar.h \ + /usr/include/qt/QtCore/qcompilerdetection.h \ + /usr/include/qt/QtCore/qconfig.h \ + /usr/include/qt/QtCore/qcontainerfwd.h \ + /usr/include/qt/QtCore/qcontainertools_impl.h \ + /usr/include/qt/QtCore/qdatastream.h \ + /usr/include/qt/QtCore/qflags.h \ + /usr/include/qt/QtCore/qgenericatomic.h \ + /usr/include/qt/QtCore/qglobal.h \ + /usr/include/qt/QtCore/qglobalstatic.h \ + /usr/include/qt/QtCore/qhash.h \ + /usr/include/qt/QtCore/qhashfunctions.h \ + /usr/include/qt/QtCore/qiodevice.h \ + /usr/include/qt/QtCore/qiterator.h \ + /usr/include/qt/QtCore/qline.h \ + /usr/include/qt/QtCore/qlist.h \ + /usr/include/qt/QtCore/qlogging.h \ + /usr/include/qt/QtCore/qmargins.h \ + /usr/include/qt/QtCore/qmetatype.h \ + /usr/include/qt/QtCore/qnamespace.h \ + /usr/include/qt/QtCore/qnumeric.h \ + /usr/include/qt/QtCore/qobject.h \ + /usr/include/qt/QtCore/qobject_impl.h \ + /usr/include/qt/QtCore/qobjectdefs.h \ + /usr/include/qt/QtCore/qobjectdefs_impl.h \ + /usr/include/qt/QtCore/qpair.h \ + /usr/include/qt/QtCore/qpoint.h \ + /usr/include/qt/QtCore/qprocessordetection.h \ + /usr/include/qt/QtCore/qrect.h \ + /usr/include/qt/QtCore/qrefcount.h \ + /usr/include/qt/QtCore/qregexp.h \ + /usr/include/qt/QtCore/qscopedpointer.h \ + /usr/include/qt/QtCore/qshareddata.h \ + /usr/include/qt/QtCore/qsharedpointer.h \ + /usr/include/qt/QtCore/qsharedpointer_impl.h \ + /usr/include/qt/QtCore/qsize.h \ + /usr/include/qt/QtCore/qstring.h \ + /usr/include/qt/QtCore/qstringalgorithms.h \ + /usr/include/qt/QtCore/qstringlist.h \ + /usr/include/qt/QtCore/qstringliteral.h \ + /usr/include/qt/QtCore/qstringmatcher.h \ + /usr/include/qt/QtCore/qstringview.h \ + /usr/include/qt/QtCore/qsysinfo.h \ + /usr/include/qt/QtCore/qsystemdetection.h \ + /usr/include/qt/QtCore/qtcore-config.h \ + /usr/include/qt/QtCore/qtypeinfo.h \ + /usr/include/qt/QtCore/qvarlengtharray.h \ + /usr/include/qt/QtCore/qvector.h \ + /usr/include/qt/QtCore/qversiontagging.h \ + /usr/include/qt/QtGui/qbrush.h \ + /usr/include/qt/QtGui/qcolor.h \ + /usr/include/qt/QtGui/qcursor.h \ + /usr/include/qt/QtGui/qfont.h \ + /usr/include/qt/QtGui/qfontinfo.h \ + /usr/include/qt/QtGui/qfontmetrics.h \ + /usr/include/qt/QtGui/qicon.h \ + /usr/include/qt/QtGui/qimage.h \ + /usr/include/qt/QtGui/qkeysequence.h \ + /usr/include/qt/QtGui/qmatrix.h \ + /usr/include/qt/QtGui/qpaintdevice.h \ + /usr/include/qt/QtGui/qpalette.h \ + /usr/include/qt/QtGui/qpixelformat.h \ + /usr/include/qt/QtGui/qpixmap.h \ + /usr/include/qt/QtGui/qpolygon.h \ + /usr/include/qt/QtGui/qregion.h \ + /usr/include/qt/QtGui/qrgb.h \ + /usr/include/qt/QtGui/qrgba64.h \ + /usr/include/qt/QtGui/qtgui-config.h \ + /usr/include/qt/QtGui/qtguiglobal.h \ + /usr/include/qt/QtGui/qtransform.h \ + /usr/include/qt/QtGui/qwindowdefs.h \ + /usr/include/qt/QtWidgets/QMainWindow \ + /usr/include/qt/QtWidgets/qmainwindow.h \ + /usr/include/qt/QtWidgets/qsizepolicy.h \ + /usr/include/qt/QtWidgets/qtabwidget.h \ + /usr/include/qt/QtWidgets/qtwidgets-config.h \ + /usr/include/qt/QtWidgets/qtwidgetsglobal.h \ + /usr/include/qt/QtWidgets/qwidget.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/sys/cdefs.h \ + /usr/include/sys/syscall.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdint.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/deps b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/deps new file mode 100755 index 0000000..a5bcd39 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/deps @@ -0,0 +1,472 @@ +1_Calculator_autogen/timestamp: \ + /home/nktkln/Documents/1_Calculator/CMakeLists.txt \ + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake \ + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h \ + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake \ + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake \ + /home/nktkln/Documents/1_Calculator/main.cpp \ + /home/nktkln/Documents/1_Calculator/mainwindow.cpp \ + /home/nktkln/Documents/1_Calculator/mainwindow.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm/errno.h \ + /usr/include/asm/unistd.h \ + /usr/include/asm/unistd_64.h \ + /usr/include/assert.h \ + /usr/include/bits/atomic_wide_counter.h \ + /usr/include/bits/confname.h \ + /usr/include/bits/cpu-set.h \ + /usr/include/bits/endian.h \ + /usr/include/bits/endianness.h \ + /usr/include/bits/environments.h \ + /usr/include/bits/errno.h \ + /usr/include/bits/floatn-common.h \ + /usr/include/bits/floatn.h \ + /usr/include/bits/getopt_core.h \ + /usr/include/bits/getopt_posix.h \ + /usr/include/bits/libc-header-start.h \ + /usr/include/bits/locale.h \ + /usr/include/bits/long-double.h \ + /usr/include/bits/posix_opt.h \ + /usr/include/bits/pthread_stack_min-dynamic.h \ + /usr/include/bits/pthreadtypes-arch.h \ + /usr/include/bits/pthreadtypes.h \ + /usr/include/bits/sched.h \ + /usr/include/bits/setjmp.h \ + /usr/include/bits/struct_mutex.h \ + /usr/include/bits/struct_rwlock.h \ + /usr/include/bits/syscall.h \ + /usr/include/bits/thread-shared-types.h \ + /usr/include/bits/time.h \ + /usr/include/bits/time64.h \ + /usr/include/bits/timesize.h \ + /usr/include/bits/timex.h \ + /usr/include/bits/types.h \ + /usr/include/bits/types/FILE.h \ + /usr/include/bits/types/__FILE.h \ + /usr/include/bits/types/__locale_t.h \ + /usr/include/bits/types/__mbstate_t.h \ + /usr/include/bits/types/__sigset_t.h \ + /usr/include/bits/types/clock_t.h \ + /usr/include/bits/types/clockid_t.h \ + /usr/include/bits/types/error_t.h \ + /usr/include/bits/types/locale_t.h \ + /usr/include/bits/types/mbstate_t.h \ + /usr/include/bits/types/struct___jmp_buf_tag.h \ + /usr/include/bits/types/struct_itimerspec.h \ + /usr/include/bits/types/struct_sched_param.h \ + /usr/include/bits/types/struct_timespec.h \ + /usr/include/bits/types/struct_timeval.h \ + /usr/include/bits/types/struct_tm.h \ + /usr/include/bits/types/time_t.h \ + /usr/include/bits/types/timer_t.h \ + /usr/include/bits/types/wint_t.h \ + /usr/include/bits/typesizes.h \ + /usr/include/bits/unistd_ext.h \ + /usr/include/bits/wchar.h \ + /usr/include/bits/wctype-wchar.h \ + /usr/include/bits/wordsize.h \ + /usr/include/c++/14.2.1/algorithm \ + /usr/include/c++/14.2.1/array \ + /usr/include/c++/14.2.1/atomic \ + /usr/include/c++/14.2.1/backward/auto_ptr.h \ + /usr/include/c++/14.2.1/backward/binders.h \ + /usr/include/c++/14.2.1/bit \ + /usr/include/c++/14.2.1/bits/algorithmfwd.h \ + /usr/include/c++/14.2.1/bits/align.h \ + /usr/include/c++/14.2.1/bits/alloc_traits.h \ + /usr/include/c++/14.2.1/bits/allocated_ptr.h \ + /usr/include/c++/14.2.1/bits/allocator.h \ + /usr/include/c++/14.2.1/bits/atomic_base.h \ + /usr/include/c++/14.2.1/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14.2.1/bits/atomic_wait.h \ + /usr/include/c++/14.2.1/bits/basic_ios.h \ + /usr/include/c++/14.2.1/bits/basic_ios.tcc \ + /usr/include/c++/14.2.1/bits/basic_string.h \ + /usr/include/c++/14.2.1/bits/basic_string.tcc \ + /usr/include/c++/14.2.1/bits/c++0x_warning.h \ + /usr/include/c++/14.2.1/bits/char_traits.h \ + /usr/include/c++/14.2.1/bits/charconv.h \ + /usr/include/c++/14.2.1/bits/concept_check.h \ + /usr/include/c++/14.2.1/bits/cpp_type_traits.h \ + /usr/include/c++/14.2.1/bits/cxxabi_forced.h \ + /usr/include/c++/14.2.1/bits/cxxabi_init_exception.h \ + /usr/include/c++/14.2.1/bits/erase_if.h \ + /usr/include/c++/14.2.1/bits/exception.h \ + /usr/include/c++/14.2.1/bits/exception_defines.h \ + /usr/include/c++/14.2.1/bits/exception_ptr.h \ + /usr/include/c++/14.2.1/bits/functexcept.h \ + /usr/include/c++/14.2.1/bits/functional_hash.h \ + /usr/include/c++/14.2.1/bits/hash_bytes.h \ + /usr/include/c++/14.2.1/bits/invoke.h \ + /usr/include/c++/14.2.1/bits/ios_base.h \ + /usr/include/c++/14.2.1/bits/iterator_concepts.h \ + /usr/include/c++/14.2.1/bits/list.tcc \ + /usr/include/c++/14.2.1/bits/locale_classes.h \ + /usr/include/c++/14.2.1/bits/locale_classes.tcc \ + /usr/include/c++/14.2.1/bits/locale_facets.h \ + /usr/include/c++/14.2.1/bits/locale_facets.tcc \ + /usr/include/c++/14.2.1/bits/localefwd.h \ + /usr/include/c++/14.2.1/bits/max_size_type.h \ + /usr/include/c++/14.2.1/bits/memory_resource.h \ + /usr/include/c++/14.2.1/bits/memoryfwd.h \ + /usr/include/c++/14.2.1/bits/mofunc_impl.h \ + /usr/include/c++/14.2.1/bits/move.h \ + /usr/include/c++/14.2.1/bits/move_only_function.h \ + /usr/include/c++/14.2.1/bits/nested_exception.h \ + /usr/include/c++/14.2.1/bits/new_allocator.h \ + /usr/include/c++/14.2.1/bits/node_handle.h \ + /usr/include/c++/14.2.1/bits/ostream.tcc \ + /usr/include/c++/14.2.1/bits/ostream_insert.h \ + /usr/include/c++/14.2.1/bits/out_ptr.h \ + /usr/include/c++/14.2.1/bits/postypes.h \ + /usr/include/c++/14.2.1/bits/predefined_ops.h \ + /usr/include/c++/14.2.1/bits/ptr_traits.h \ + /usr/include/c++/14.2.1/bits/range_access.h \ + /usr/include/c++/14.2.1/bits/ranges_algo.h \ + /usr/include/c++/14.2.1/bits/ranges_algobase.h \ + /usr/include/c++/14.2.1/bits/ranges_base.h \ + /usr/include/c++/14.2.1/bits/ranges_cmp.h \ + /usr/include/c++/14.2.1/bits/ranges_uninitialized.h \ + /usr/include/c++/14.2.1/bits/ranges_util.h \ + /usr/include/c++/14.2.1/bits/refwrap.h \ + /usr/include/c++/14.2.1/bits/requires_hosted.h \ + /usr/include/c++/14.2.1/bits/sat_arith.h \ + /usr/include/c++/14.2.1/bits/shared_ptr.h \ + /usr/include/c++/14.2.1/bits/shared_ptr_atomic.h \ + /usr/include/c++/14.2.1/bits/shared_ptr_base.h \ + /usr/include/c++/14.2.1/bits/std_abs.h \ + /usr/include/c++/14.2.1/bits/std_function.h \ + /usr/include/c++/14.2.1/bits/std_mutex.h \ + /usr/include/c++/14.2.1/bits/stl_algo.h \ + /usr/include/c++/14.2.1/bits/stl_algobase.h \ + /usr/include/c++/14.2.1/bits/stl_bvector.h \ + /usr/include/c++/14.2.1/bits/stl_construct.h \ + /usr/include/c++/14.2.1/bits/stl_function.h \ + /usr/include/c++/14.2.1/bits/stl_heap.h \ + /usr/include/c++/14.2.1/bits/stl_iterator.h \ + /usr/include/c++/14.2.1/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14.2.1/bits/stl_iterator_base_types.h \ + /usr/include/c++/14.2.1/bits/stl_list.h \ + /usr/include/c++/14.2.1/bits/stl_map.h \ + /usr/include/c++/14.2.1/bits/stl_multimap.h \ + /usr/include/c++/14.2.1/bits/stl_numeric.h \ + /usr/include/c++/14.2.1/bits/stl_pair.h \ + /usr/include/c++/14.2.1/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14.2.1/bits/stl_relops.h \ + /usr/include/c++/14.2.1/bits/stl_tempbuf.h \ + /usr/include/c++/14.2.1/bits/stl_tree.h \ + /usr/include/c++/14.2.1/bits/stl_uninitialized.h \ + /usr/include/c++/14.2.1/bits/stl_vector.h \ + /usr/include/c++/14.2.1/bits/stream_iterator.h \ + /usr/include/c++/14.2.1/bits/streambuf.tcc \ + /usr/include/c++/14.2.1/bits/streambuf_iterator.h \ + /usr/include/c++/14.2.1/bits/string_view.tcc \ + /usr/include/c++/14.2.1/bits/stringfwd.h \ + /usr/include/c++/14.2.1/bits/uniform_int_dist.h \ + /usr/include/c++/14.2.1/bits/unique_ptr.h \ + /usr/include/c++/14.2.1/bits/uses_allocator.h \ + /usr/include/c++/14.2.1/bits/uses_allocator_args.h \ + /usr/include/c++/14.2.1/bits/utility.h \ + /usr/include/c++/14.2.1/bits/vector.tcc \ + /usr/include/c++/14.2.1/bits/version.h \ + /usr/include/c++/14.2.1/cctype \ + /usr/include/c++/14.2.1/cerrno \ + /usr/include/c++/14.2.1/charconv \ + /usr/include/c++/14.2.1/climits \ + /usr/include/c++/14.2.1/clocale \ + /usr/include/c++/14.2.1/compare \ + /usr/include/c++/14.2.1/concepts \ + /usr/include/c++/14.2.1/cstddef \ + /usr/include/c++/14.2.1/cstdint \ + /usr/include/c++/14.2.1/cstdlib \ + /usr/include/c++/14.2.1/cwchar \ + /usr/include/c++/14.2.1/cwctype \ + /usr/include/c++/14.2.1/debug/assertions.h \ + /usr/include/c++/14.2.1/debug/debug.h \ + /usr/include/c++/14.2.1/exception \ + /usr/include/c++/14.2.1/ext/aligned_buffer.h \ + /usr/include/c++/14.2.1/ext/alloc_traits.h \ + /usr/include/c++/14.2.1/ext/atomicity.h \ + /usr/include/c++/14.2.1/ext/concurrence.h \ + /usr/include/c++/14.2.1/ext/numeric_traits.h \ + /usr/include/c++/14.2.1/ext/string_conversions.h \ + /usr/include/c++/14.2.1/ext/type_traits.h \ + /usr/include/c++/14.2.1/format \ + /usr/include/c++/14.2.1/functional \ + /usr/include/c++/14.2.1/initializer_list \ + /usr/include/c++/14.2.1/ios \ + /usr/include/c++/14.2.1/iosfwd \ + /usr/include/c++/14.2.1/iterator \ + /usr/include/c++/14.2.1/limits \ + /usr/include/c++/14.2.1/list \ + /usr/include/c++/14.2.1/map \ + /usr/include/c++/14.2.1/memory \ + /usr/include/c++/14.2.1/new \ + /usr/include/c++/14.2.1/numbers \ + /usr/include/c++/14.2.1/numeric \ + /usr/include/c++/14.2.1/optional \ + /usr/include/c++/14.2.1/ostream \ + /usr/include/c++/14.2.1/pstl/execution_defs.h \ + /usr/include/c++/14.2.1/pstl/glue_numeric_defs.h \ + /usr/include/c++/14.2.1/stdexcept \ + /usr/include/c++/14.2.1/stdlib.h \ + /usr/include/c++/14.2.1/streambuf \ + /usr/include/c++/14.2.1/string \ + /usr/include/c++/14.2.1/string_view \ + /usr/include/c++/14.2.1/text_encoding \ + /usr/include/c++/14.2.1/tuple \ + /usr/include/c++/14.2.1/type_traits \ + /usr/include/c++/14.2.1/typeinfo \ + /usr/include/c++/14.2.1/unordered_map \ + /usr/include/c++/14.2.1/utility \ + /usr/include/c++/14.2.1/vector \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++locale.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/error_constants.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr.h \ + /usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/gnu/stubs-64.h \ + /usr/include/gnu/stubs.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/qt/QtCore/qalgorithms.h \ + /usr/include/qt/QtCore/qarraydata.h \ + /usr/include/qt/QtCore/qatomic.h \ + /usr/include/qt/QtCore/qatomic_cxx11.h \ + /usr/include/qt/QtCore/qbasicatomic.h \ + /usr/include/qt/QtCore/qbytearray.h \ + /usr/include/qt/QtCore/qbytearraylist.h \ + /usr/include/qt/QtCore/qchar.h \ + /usr/include/qt/QtCore/qcompilerdetection.h \ + /usr/include/qt/QtCore/qconfig.h \ + /usr/include/qt/QtCore/qcontainerfwd.h \ + /usr/include/qt/QtCore/qcontainertools_impl.h \ + /usr/include/qt/QtCore/qdatastream.h \ + /usr/include/qt/QtCore/qflags.h \ + /usr/include/qt/QtCore/qgenericatomic.h \ + /usr/include/qt/QtCore/qglobal.h \ + /usr/include/qt/QtCore/qglobalstatic.h \ + /usr/include/qt/QtCore/qhash.h \ + /usr/include/qt/QtCore/qhashfunctions.h \ + /usr/include/qt/QtCore/qiodevice.h \ + /usr/include/qt/QtCore/qiterator.h \ + /usr/include/qt/QtCore/qline.h \ + /usr/include/qt/QtCore/qlist.h \ + /usr/include/qt/QtCore/qlogging.h \ + /usr/include/qt/QtCore/qmargins.h \ + /usr/include/qt/QtCore/qmetatype.h \ + /usr/include/qt/QtCore/qnamespace.h \ + /usr/include/qt/QtCore/qnumeric.h \ + /usr/include/qt/QtCore/qobject.h \ + /usr/include/qt/QtCore/qobject_impl.h \ + /usr/include/qt/QtCore/qobjectdefs.h \ + /usr/include/qt/QtCore/qobjectdefs_impl.h \ + /usr/include/qt/QtCore/qpair.h \ + /usr/include/qt/QtCore/qpoint.h \ + /usr/include/qt/QtCore/qprocessordetection.h \ + /usr/include/qt/QtCore/qrect.h \ + /usr/include/qt/QtCore/qrefcount.h \ + /usr/include/qt/QtCore/qregexp.h \ + /usr/include/qt/QtCore/qscopedpointer.h \ + /usr/include/qt/QtCore/qshareddata.h \ + /usr/include/qt/QtCore/qsharedpointer.h \ + /usr/include/qt/QtCore/qsharedpointer_impl.h \ + /usr/include/qt/QtCore/qsize.h \ + /usr/include/qt/QtCore/qstring.h \ + /usr/include/qt/QtCore/qstringalgorithms.h \ + /usr/include/qt/QtCore/qstringlist.h \ + /usr/include/qt/QtCore/qstringliteral.h \ + /usr/include/qt/QtCore/qstringmatcher.h \ + /usr/include/qt/QtCore/qstringview.h \ + /usr/include/qt/QtCore/qsysinfo.h \ + /usr/include/qt/QtCore/qsystemdetection.h \ + /usr/include/qt/QtCore/qtcore-config.h \ + /usr/include/qt/QtCore/qtypeinfo.h \ + /usr/include/qt/QtCore/qvarlengtharray.h \ + /usr/include/qt/QtCore/qvector.h \ + /usr/include/qt/QtCore/qversiontagging.h \ + /usr/include/qt/QtGui/qbrush.h \ + /usr/include/qt/QtGui/qcolor.h \ + /usr/include/qt/QtGui/qcursor.h \ + /usr/include/qt/QtGui/qfont.h \ + /usr/include/qt/QtGui/qfontinfo.h \ + /usr/include/qt/QtGui/qfontmetrics.h \ + /usr/include/qt/QtGui/qicon.h \ + /usr/include/qt/QtGui/qimage.h \ + /usr/include/qt/QtGui/qkeysequence.h \ + /usr/include/qt/QtGui/qmatrix.h \ + /usr/include/qt/QtGui/qpaintdevice.h \ + /usr/include/qt/QtGui/qpalette.h \ + /usr/include/qt/QtGui/qpixelformat.h \ + /usr/include/qt/QtGui/qpixmap.h \ + /usr/include/qt/QtGui/qpolygon.h \ + /usr/include/qt/QtGui/qregion.h \ + /usr/include/qt/QtGui/qrgb.h \ + /usr/include/qt/QtGui/qrgba64.h \ + /usr/include/qt/QtGui/qtgui-config.h \ + /usr/include/qt/QtGui/qtguiglobal.h \ + /usr/include/qt/QtGui/qtransform.h \ + /usr/include/qt/QtGui/qwindowdefs.h \ + /usr/include/qt/QtWidgets/QMainWindow \ + /usr/include/qt/QtWidgets/qmainwindow.h \ + /usr/include/qt/QtWidgets/qsizepolicy.h \ + /usr/include/qt/QtWidgets/qtabwidget.h \ + /usr/include/qt/QtWidgets/qtwidgets-config.h \ + /usr/include/qt/QtWidgets/qtwidgetsglobal.h \ + /usr/include/qt/QtWidgets/qwidget.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/sys/cdefs.h \ + /usr/include/sys/syscall.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/lib/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake \ + /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdint.h \ + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h \ + /usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in \ + /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp \ + /usr/share/cmake/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake/Modules/CMakeCompilerIdDetection.cmake \ + /usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake \ + /usr/share/cmake/Modules/CMakeDetermineCompiler.cmake \ + /usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake \ + /usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake \ + /usr/share/cmake/Modules/CMakeDetermineCompilerSupport.cmake \ + /usr/share/cmake/Modules/CMakeDetermineSystem.cmake \ + /usr/share/cmake/Modules/CMakeFindBinUtils.cmake \ + /usr/share/cmake/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake/Modules/CMakeNinjaFindMake.cmake \ + /usr/share/cmake/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake/Modules/CMakeParseImplicitIncludeInfo.cmake \ + /usr/share/cmake/Modules/CMakeParseImplicitLinkInfo.cmake \ + /usr/share/cmake/Modules/CMakeParseLibraryArchitecture.cmake \ + /usr/share/cmake/Modules/CMakeSystem.cmake.in \ + /usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake \ + /usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake \ + /usr/share/cmake/Modules/Compiler/ADSP-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/ARMCC-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/ARMClang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/AppleClang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Borland-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake/Modules/Compiler/Clang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake \ + /usr/share/cmake/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Cray-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/CrayClang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Embarcadero-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Fujitsu-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/GHS-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake/Modules/Compiler/GNU-FindBinUtils.cmake \ + /usr/share/cmake/Modules/Compiler/GNU.cmake \ + /usr/share/cmake/Modules/Compiler/HP-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/IAR-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake \ + /usr/share/cmake/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Intel-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/MSVC-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/NVHPC-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/NVIDIA-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/OrangeC-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/PGI-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/PathScale-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/SCO-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/TI-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/TIClang-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Tasking-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/Watcom-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/XL-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake \ + /usr/share/cmake/Modules/GNUInstallDirs.cmake \ + /usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake \ + /usr/share/cmake/Modules/Internal/FeatureTesting.cmake \ + /usr/share/cmake/Modules/Platform/Linux-Determine-CXX.cmake \ + /usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake/Modules/Platform/Linux.cmake \ + /usr/share/cmake/Modules/Platform/UnixPaths.cmake \ + /home/nktkln/Documents/1_Calculator/mainwindow.ui \ + /usr/bin/cmake diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include/ui_mainwindow.h b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include/ui_mainwindow.h new file mode 100755 index 0000000..344c882 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include/ui_mainwindow.h @@ -0,0 +1,257 @@ +/******************************************************************************** +** Form generated from reading UI file 'mainwindow.ui' +** +** Created by: Qt User Interface Compiler version 5.15.14 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_MAINWINDOW_H +#define UI_MAINWINDOW_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class Ui_MainWindow +{ +public: + QWidget *centralwidget; + QPushButton *button0; + QPushButton *buttonDot; + QPushButton *buttonEquals; + QPushButton *button4; + QPushButton *button6; + QPushButton *button5; + QPushButton *buttonSubtract; + QPushButton *button7; + QPushButton *button9; + QPushButton *button8; + QPushButton *buttonMultiply; + QPushButton *buttonClear; + QPushButton *buttonPow; + QPushButton *buttonChangeSign; + QPushButton *buttonDivide; + QLabel *display; + QPushButton *button2; + QPushButton *buttonAdd; + QPushButton *button3; + QPushButton *button1; + QMenuBar *menubar; + QMenu *menuCalculator; + QMenu *menuProgarmming; + + void setupUi(QMainWindow *MainWindow) + { + if (MainWindow->objectName().isEmpty()) + MainWindow->setObjectName(QString::fromUtf8("MainWindow")); + MainWindow->resize(350, 564); + QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + sizePolicy.setHeightForWidth(MainWindow->sizePolicy().hasHeightForWidth()); + MainWindow->setSizePolicy(sizePolicy); + centralwidget = new QWidget(MainWindow); + centralwidget->setObjectName(QString::fromUtf8("centralwidget")); + sizePolicy.setHeightForWidth(centralwidget->sizePolicy().hasHeightForWidth()); + centralwidget->setSizePolicy(sizePolicy); + button0 = new QPushButton(centralwidget); + button0->setObjectName(QString::fromUtf8("button0")); + button0->setGeometry(QRect(6, 456, 166, 80)); + QFont font; + font.setPointSize(18); + button0->setFont(font); + buttonDot = new QPushButton(centralwidget); + buttonDot->setObjectName(QString::fromUtf8("buttonDot")); + buttonDot->setGeometry(QRect(178, 456, 80, 80)); + buttonDot->setFont(font); + buttonEquals = new QPushButton(centralwidget); + buttonEquals->setObjectName(QString::fromUtf8("buttonEquals")); + buttonEquals->setGeometry(QRect(264, 456, 80, 80)); + buttonEquals->setFont(font); + button4 = new QPushButton(centralwidget); + button4->setObjectName(QString::fromUtf8("button4")); + button4->setGeometry(QRect(6, 284, 80, 80)); + button4->setFont(font); + button6 = new QPushButton(centralwidget); + button6->setObjectName(QString::fromUtf8("button6")); + button6->setGeometry(QRect(178, 284, 80, 80)); + button6->setFont(font); + button5 = new QPushButton(centralwidget); + button5->setObjectName(QString::fromUtf8("button5")); + button5->setGeometry(QRect(92, 284, 80, 80)); + button5->setFont(font); + buttonSubtract = new QPushButton(centralwidget); + buttonSubtract->setObjectName(QString::fromUtf8("buttonSubtract")); + buttonSubtract->setGeometry(QRect(264, 284, 80, 80)); + buttonSubtract->setFont(font); + button7 = new QPushButton(centralwidget); + button7->setObjectName(QString::fromUtf8("button7")); + button7->setGeometry(QRect(6, 198, 80, 80)); + button7->setFont(font); + button9 = new QPushButton(centralwidget); + button9->setObjectName(QString::fromUtf8("button9")); + button9->setGeometry(QRect(178, 198, 80, 80)); + button9->setFont(font); + button8 = new QPushButton(centralwidget); + button8->setObjectName(QString::fromUtf8("button8")); + button8->setGeometry(QRect(92, 198, 80, 80)); + button8->setFont(font); + buttonMultiply = new QPushButton(centralwidget); + buttonMultiply->setObjectName(QString::fromUtf8("buttonMultiply")); + buttonMultiply->setGeometry(QRect(264, 198, 80, 80)); + buttonMultiply->setFont(font); + buttonClear = new QPushButton(centralwidget); + buttonClear->setObjectName(QString::fromUtf8("buttonClear")); + buttonClear->setGeometry(QRect(6, 112, 80, 80)); + buttonClear->setFont(font); + buttonPow = new QPushButton(centralwidget); + buttonPow->setObjectName(QString::fromUtf8("buttonPow")); + buttonPow->setGeometry(QRect(178, 112, 80, 80)); + buttonPow->setFont(font); + buttonChangeSign = new QPushButton(centralwidget); + buttonChangeSign->setObjectName(QString::fromUtf8("buttonChangeSign")); + buttonChangeSign->setGeometry(QRect(92, 112, 80, 80)); + buttonChangeSign->setFont(font); + buttonDivide = new QPushButton(centralwidget); + buttonDivide->setObjectName(QString::fromUtf8("buttonDivide")); + buttonDivide->setGeometry(QRect(264, 112, 80, 80)); + buttonDivide->setFont(font); + display = new QLabel(centralwidget); + display->setObjectName(QString::fromUtf8("display")); + display->setGeometry(QRect(12, 6, 326, 100)); + display->setFont(font); + display->setLayoutDirection(Qt::LayoutDirection::LeftToRight); + display->setAutoFillBackground(false); + button2 = new QPushButton(centralwidget); + button2->setObjectName(QString::fromUtf8("button2")); + button2->setGeometry(QRect(92, 370, 80, 80)); + button2->setFont(font); + buttonAdd = new QPushButton(centralwidget); + buttonAdd->setObjectName(QString::fromUtf8("buttonAdd")); + buttonAdd->setGeometry(QRect(264, 370, 80, 80)); + buttonAdd->setFont(font); + button3 = new QPushButton(centralwidget); + button3->setObjectName(QString::fromUtf8("button3")); + button3->setGeometry(QRect(178, 370, 80, 80)); + button3->setFont(font); + button1 = new QPushButton(centralwidget); + button1->setObjectName(QString::fromUtf8("button1")); + button1->setGeometry(QRect(6, 370, 80, 80)); + button1->setFont(font); + MainWindow->setCentralWidget(centralwidget); + menubar = new QMenuBar(MainWindow); + menubar->setObjectName(QString::fromUtf8("menubar")); + menubar->setGeometry(QRect(0, 0, 350, 23)); + menuCalculator = new QMenu(menubar); + menuCalculator->setObjectName(QString::fromUtf8("menuCalculator")); + menuProgarmming = new QMenu(menubar); + menuProgarmming->setObjectName(QString::fromUtf8("menuProgarmming")); + MainWindow->setMenuBar(menubar); + + menubar->addAction(menuCalculator->menuAction()); + menubar->addAction(menuProgarmming->menuAction()); + + retranslateUi(MainWindow); + + QMetaObject::connectSlotsByName(MainWindow); + } // setupUi + + void retranslateUi(QMainWindow *MainWindow) + { + MainWindow->setWindowTitle(QCoreApplication::translate("MainWindow", "Calculator", nullptr)); + button0->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); +#if QT_CONFIG(shortcut) + button0->setShortcut(QCoreApplication::translate("MainWindow", "0", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonDot->setText(QCoreApplication::translate("MainWindow", ".", nullptr)); +#if QT_CONFIG(shortcut) + buttonDot->setShortcut(QCoreApplication::translate("MainWindow", ".", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonEquals->setText(QCoreApplication::translate("MainWindow", "=", nullptr)); +#if QT_CONFIG(shortcut) + buttonEquals->setShortcut(QCoreApplication::translate("MainWindow", "+, Return", nullptr)); +#endif // QT_CONFIG(shortcut) + button4->setText(QCoreApplication::translate("MainWindow", "4", nullptr)); +#if QT_CONFIG(shortcut) + button4->setShortcut(QCoreApplication::translate("MainWindow", "4", nullptr)); +#endif // QT_CONFIG(shortcut) + button6->setText(QCoreApplication::translate("MainWindow", "6", nullptr)); +#if QT_CONFIG(shortcut) + button6->setShortcut(QCoreApplication::translate("MainWindow", "6", nullptr)); +#endif // QT_CONFIG(shortcut) + button5->setText(QCoreApplication::translate("MainWindow", "5", nullptr)); +#if QT_CONFIG(shortcut) + button5->setShortcut(QCoreApplication::translate("MainWindow", "5", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonSubtract->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); +#if QT_CONFIG(shortcut) + buttonSubtract->setShortcut(QCoreApplication::translate("MainWindow", "-", nullptr)); +#endif // QT_CONFIG(shortcut) + button7->setText(QCoreApplication::translate("MainWindow", "7", nullptr)); +#if QT_CONFIG(shortcut) + button7->setShortcut(QCoreApplication::translate("MainWindow", "7", nullptr)); +#endif // QT_CONFIG(shortcut) + button9->setText(QCoreApplication::translate("MainWindow", "9", nullptr)); +#if QT_CONFIG(shortcut) + button9->setShortcut(QCoreApplication::translate("MainWindow", "9", nullptr)); +#endif // QT_CONFIG(shortcut) + button8->setText(QCoreApplication::translate("MainWindow", "8", nullptr)); +#if QT_CONFIG(shortcut) + button8->setShortcut(QCoreApplication::translate("MainWindow", "8", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonMultiply->setText(QCoreApplication::translate("MainWindow", "*", nullptr)); +#if QT_CONFIG(shortcut) + buttonMultiply->setShortcut(QCoreApplication::translate("MainWindow", "*", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonClear->setText(QCoreApplication::translate("MainWindow", "C", nullptr)); +#if QT_CONFIG(shortcut) + buttonClear->setShortcut(QCoreApplication::translate("MainWindow", "Backspace", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonPow->setText(QCoreApplication::translate("MainWindow", "^", nullptr)); +#if QT_CONFIG(shortcut) + buttonPow->setShortcut(QCoreApplication::translate("MainWindow", "^", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonChangeSign->setText(QCoreApplication::translate("MainWindow", "+/-", nullptr)); + buttonDivide->setText(QCoreApplication::translate("MainWindow", "/", nullptr)); +#if QT_CONFIG(shortcut) + buttonDivide->setShortcut(QCoreApplication::translate("MainWindow", "/", nullptr)); +#endif // QT_CONFIG(shortcut) + display->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + button2->setText(QCoreApplication::translate("MainWindow", "2", nullptr)); +#if QT_CONFIG(shortcut) + button2->setShortcut(QCoreApplication::translate("MainWindow", "2", nullptr)); +#endif // QT_CONFIG(shortcut) + buttonAdd->setText(QCoreApplication::translate("MainWindow", "+", nullptr)); +#if QT_CONFIG(shortcut) + buttonAdd->setShortcut(QCoreApplication::translate("MainWindow", "+", nullptr)); +#endif // QT_CONFIG(shortcut) + button3->setText(QCoreApplication::translate("MainWindow", "3", nullptr)); +#if QT_CONFIG(shortcut) + button3->setShortcut(QCoreApplication::translate("MainWindow", "3", nullptr)); +#endif // QT_CONFIG(shortcut) + button1->setText(QCoreApplication::translate("MainWindow", "1", nullptr)); +#if QT_CONFIG(shortcut) + button1->setShortcut(QCoreApplication::translate("MainWindow", "1", nullptr)); +#endif // QT_CONFIG(shortcut) + menuCalculator->setTitle(QCoreApplication::translate("MainWindow", "Calculator", nullptr)); + menuProgarmming->setTitle(QCoreApplication::translate("MainWindow", "Programming", nullptr)); + } // retranslateUi + +}; + +namespace Ui { + class MainWindow: public Ui_MainWindow {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_MAINWINDOW_H diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h new file mode 100755 index 0000000..69ec56f --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h @@ -0,0 +1,467 @@ +#define __DBL_MIN_EXP__ (-1021) +#define __cpp_nontype_template_parameter_auto 201606L +#define __UINT_LEAST16_MAX__ 0xffff +#define __FLT16_HAS_QUIET_NAN__ 1 +#define __ATOMIC_ACQUIRE 2 +#define __FLT128_MAX_10_EXP__ 4932 +#define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F +#define __GCC_IEC_559_COMPLEX 2 +#define __cpp_aggregate_nsdmi 201304L +#define __UINT_LEAST8_TYPE__ unsigned char +#define __SIZEOF_FLOAT80__ 16 +#define __BFLT16_DENORM_MIN__ 9.18354961579912115600575419704879436e-41BF16 +#define __INTMAX_C(c) c ## L +#define __CHAR_BIT__ 8 +#define __UINT8_MAX__ 0xff +#define __SCHAR_WIDTH__ 8 +#define __WINT_MAX__ 0xffffffffU +#define __FLT32_MIN_EXP__ (-125) +#define __cpp_static_assert 201411L +#define __BFLT16_MIN_10_EXP__ (-37) +#define QT_GUI_LIB 1 +#define __ORDER_LITTLE_ENDIAN__ 1234 +#define __WCHAR_MAX__ 0x7fffffff +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1 +#define __GCC_ATOMIC_CHAR_LOCK_FREE 2 +#define __GCC_IEC_559 2 +#define __FLT32X_DECIMAL_DIG__ 17 +#define __FLT_EVAL_METHOD__ 0 +#define __cpp_binary_literals 201304L +#define __FLT64_DECIMAL_DIG__ 17 +#define __cpp_noexcept_function_type 201510L +#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2 +#define __cpp_variadic_templates 200704L +#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL +#define __SIG_ATOMIC_TYPE__ int +#define __DBL_MIN_10_EXP__ (-307) +#define __FINITE_MATH_ONLY__ 0 +#define __cpp_variable_templates 201304L +#define __FLT32X_MAX_EXP__ 1024 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1 +#define __FLT32_HAS_DENORM__ 1 +#define __UINT_FAST8_MAX__ 0xff +#define __cpp_rvalue_reference 200610L +#define __cpp_nested_namespace_definitions 201411L +#define __DEC64_MAX_EXP__ 385 +#define __INT8_C(c) c +#define __LDBL_HAS_INFINITY__ 1 +#define __INT_LEAST8_WIDTH__ 8 +#define __cpp_variadic_using 201611L +#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL +#define __INT_LEAST8_MAX__ 0x7f +#define __cpp_attributes 200809L +#define __cpp_capture_star_this 201603L +#define __SHRT_MAX__ 0x7fff +#define __LDBL_MAX__ 1.18973149535723176502126385303097021e+4932L +#define __FLT64X_MAX_10_EXP__ 4932 +#define __cpp_if_constexpr 201606L +#define __BFLT16_MAX_10_EXP__ 38 +#define __BFLT16_MAX_EXP__ 128 +#define __LDBL_IS_IEC_60559__ 1 +#define __FLT64X_HAS_QUIET_NAN__ 1 +#define __UINT_LEAST8_MAX__ 0xff +#define __GCC_ATOMIC_BOOL_LOCK_FREE 2 +#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128 +#define __UINTMAX_TYPE__ long unsigned int +#define __cpp_nsdmi 200809L +#define __BFLT16_DECIMAL_DIG__ 4 +#define __linux 1 +#define __DEC32_EPSILON__ 1E-6DF +#define __FLT_EVAL_METHOD_TS_18661_3__ 0 +#define __UINT32_MAX__ 0xffffffffU +#define __GXX_EXPERIMENTAL_CXX0X__ 1 +#define __DBL_DENORM_MIN__ double(4.94065645841246544176568792868221372e-324L) +#define __FLT128_MIN_EXP__ (-16381) +#define __WINT_MIN__ 0U +#define __FLT128_MIN_10_EXP__ (-4931) +#define __FLT32X_IS_IEC_60559__ 1 +#define __INT_LEAST16_WIDTH__ 16 +#define __SCHAR_MAX__ 0x7f +#define __FLT128_MANT_DIG__ 113 +#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1) +#define __INT64_C(c) c ## L +#define __SSP_STRONG__ 3 +#define __GCC_ATOMIC_POINTER_LOCK_FREE 2 +#define __ATOMIC_SEQ_CST 5 +#define __unix 1 +#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL +#define __FLT32X_MANT_DIG__ 53 +#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2 +#define __cpp_aligned_new 201606L +#define __FLT32_MAX_10_EXP__ 38 +#define __FLT64X_EPSILON__ 1.08420217248550443400745280086994171e-19F64x +#define __STDC_HOSTED__ 1 +#define __DEC64_MIN_EXP__ (-382) +#define __cpp_decltype_auto 201304L +#define __DBL_DIG__ 15 +#define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F +#define __GXX_WEAK__ 1 +#define __SHRT_WIDTH__ 16 +#define __FLT32_IS_IEC_60559__ 1 +#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L +#define __DBL_IS_IEC_60559__ 1 +#define __DEC32_MAX__ 9.999999E96DF +#define __cpp_threadsafe_static_init 200806L +#define __cpp_enumerator_attributes 201411L +#define __FLT64X_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951F64x +#define __FLT32X_HAS_INFINITY__ 1 +#define __unix__ 1 +#define __INT_WIDTH__ 32 +#define __STDC_IEC_559__ 1 +#define __STDC_ISO_10646__ 201706L +#define __DECIMAL_DIG__ 21 +#define __STDC_IEC_559_COMPLEX__ 1 +#define __FLT64_EPSILON__ 2.22044604925031308084726333618164062e-16F64 +#define __gnu_linux__ 1 +#define __INT16_MAX__ 0x7fff +#define __FLT64_MIN_EXP__ (-1021) +#define __FLT64X_MIN_10_EXP__ (-4931) +#define __LDBL_HAS_QUIET_NAN__ 1 +#define __cpp_return_type_deduction 201304L +#define __FLT16_MIN_EXP__ (-13) +#define __FLT64_MANT_DIG__ 53 +#define __FLT64X_MANT_DIG__ 64 +#define __BFLT16_DIG__ 2 +#define __GNUC__ 14 +#define __GXX_RTTI 1 +#define __pie__ 2 +#define __MMX__ 1 +#define __FLT_HAS_DENORM__ 1 +#define __SIZEOF_LONG_DOUBLE__ 16 +#define __BIGGEST_ALIGNMENT__ 16 +#define __STDC_UTF_16__ 1 +#define __FLT64_MAX_10_EXP__ 308 +#define __BFLT16_IS_IEC_60559__ 0 +#define __FLT16_MAX_10_EXP__ 4 +#define __cpp_delegating_constructors 200604L +#define __DBL_MAX__ double(1.79769313486231570814527423731704357e+308L) +#define __cpp_raw_strings 200710L +#define __INT_FAST32_MAX__ 0x7fffffffffffffffL +#define __DBL_HAS_INFINITY__ 1 +#define __INT64_MAX__ 0x7fffffffffffffffL +#define __SIZEOF_FLOAT__ 4 +#define __HAVE_SPECULATION_SAFE_VALUE 1 +#define __cpp_fold_expressions 201603L +#define __DEC32_MIN_EXP__ (-94) +#define __INTPTR_WIDTH__ 64 +#define __UINT_LEAST32_MAX__ 0xffffffffU +#define __FLT32X_HAS_DENORM__ 1 +#define __INT_FAST16_TYPE__ long int +#define __MMX_WITH_SSE__ 1 +#define __LDBL_HAS_DENORM__ 1 +#define QT_WIDGETS_LIB 1 +#define __SEG_GS 1 +#define __BFLT16_EPSILON__ 7.81250000000000000000000000000000000e-3BF16 +#define __cplusplus 201703L +#define __cpp_ref_qualifiers 200710L +#define __DEC32_MIN__ 1E-95DF +#define __DEPRECATED 1 +#define __cpp_rvalue_references 200610L +#define __DBL_MAX_EXP__ 1024 +#define __WCHAR_WIDTH__ 32 +#define __FLT32_MAX__ 3.40282346638528859811704183484516925e+38F32 +#define __DEC128_EPSILON__ 1E-33DL +#define __FLT16_DECIMAL_DIG__ 5 +#define __SSE2_MATH__ 1 +#define __ATOMIC_HLE_RELEASE 131072 +#define __PTRDIFF_MAX__ 0x7fffffffffffffffL +#define __amd64 1 +#define __ATOMIC_HLE_ACQUIRE 65536 +#define __GNUG__ 14 +#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL +#define __SIZEOF_SIZE_T__ 8 +#define __BFLT16_HAS_INFINITY__ 1 +#define __FLT64X_MIN_EXP__ (-16381) +#define __SIZEOF_WINT_T__ 4 +#define __FLT32X_DIG__ 15 +#define __LONG_LONG_WIDTH__ 64 +#define __cpp_initializer_lists 200806L +#define __FLT32_MAX_EXP__ 128 +#define ABI_ID "ELF" +#define __cpp_hex_float 201603L +#define __GXX_ABI_VERSION 1019 +#define __FLT_MIN_EXP__ (-125) +#define __GCC_HAVE_DWARF2_CFI_ASM 1 +#define __x86_64 1 +#define __cpp_lambdas 200907L +#define __INT_FAST64_TYPE__ long int +#define __BFLT16_MAX__ 3.38953138925153547590470800371487867e+38BF16 +#define __FLT64_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F64 +#define __cpp_template_auto 201606L +#define __FLT16_DENORM_MIN__ 5.96046447753906250000000000000000000e-8F16 +#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128 +#define __FLT64X_NORM_MAX__ 1.18973149535723176502126385303097021e+4932F64x +#define __SIZEOF_POINTER__ 8 +#define __SIZE_TYPE__ long unsigned int +#define __LP64__ 1 +#define __DBL_HAS_QUIET_NAN__ 1 +#define __FLT32X_EPSILON__ 2.22044604925031308084726333618164062e-16F32x +#define __LDBL_MAX_EXP__ 16384 +#define __DECIMAL_BID_FORMAT__ 1 +#define __FLT64_MIN_10_EXP__ (-307) +#define __FLT16_MIN_10_EXP__ (-4) +#define __FLT64X_DECIMAL_DIG__ 21 +#define __DEC128_MIN__ 1E-6143DL +#define __REGISTER_PREFIX__ +#define __UINT16_MAX__ 0xffff +#define __FLT128_HAS_INFINITY__ 1 +#define __FLT32_MIN__ 1.17549435082228750796873653722224568e-38F32 +#define __UINT8_TYPE__ unsigned char +#define __FLT_DIG__ 6 +#define __NO_INLINE__ 1 +#define __DEC_EVAL_METHOD__ 2 +#define __FLT_MANT_DIG__ 24 +#define __LDBL_DECIMAL_DIG__ 21 +#define __VERSION__ "14.2.1 20240805" +#define __UINT64_C(c) c ## UL +#define __cpp_unicode_characters 201411L +#define _STDC_PREDEF_H 1 +#define __INT_LEAST32_MAX__ 0x7fffffff +#define __GCC_ATOMIC_INT_LOCK_FREE 2 +#define __FLT128_MAX_EXP__ 16384 +#define __FLT32_MANT_DIG__ 24 +#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define SIZEOF_DPTR (sizeof(void*)) +#define __FLT32X_MIN_EXP__ (-1021) +#define __STDC_IEC_60559_COMPLEX__ 201404L +#define __cpp_aggregate_bases 201603L +#define __BFLT16_MIN__ 1.17549435082228750796873653722224568e-38BF16 +#define __FLT128_HAS_DENORM__ 1 +#define __FLT32_DECIMAL_DIG__ 9 +#define __FLT128_DIG__ 33 +#define __INT32_C(c) c +#define __DEC64_EPSILON__ 1E-15DD +#define __ORDER_PDP_ENDIAN__ 3412 +#define __DEC128_MIN_EXP__ (-6142) +#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL +#define __INT_FAST32_TYPE__ long int +#define __UINT_LEAST16_TYPE__ short unsigned int +#define __DEC128_MAX_EXP__ 6145 +#define unix 1 +#define __DBL_HAS_DENORM__ 1 +#define __cpp_rtti 199711L +#define __UINT64_MAX__ 0xffffffffffffffffUL +#define __FLT_IS_IEC_60559__ 1 +#define __GNUC_WIDE_EXECUTION_CHARSET_NAME "UTF-32LE" +#define __FLT64X_DIG__ 18 +#define __INT8_TYPE__ signed char +#define __cpp_digit_separators 201309L +#define __ELF__ 1 +#define __GCC_ASM_FLAG_OUTPUTS__ 1 +#define __UINT32_TYPE__ unsigned int +#define __BFLT16_HAS_QUIET_NAN__ 1 +#define __FLT_RADIX__ 2 +#define __INT_LEAST16_TYPE__ short int +#define __LDBL_EPSILON__ 1.08420217248550443400745280086994171e-19L +#define __UINTMAX_C(c) c ## UL +#define __FLT16_DIG__ 3 +#define __k8 1 +#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x +#define __SIG_ATOMIC_MAX__ 0x7fffffff +#define __cpp_constexpr 201603L +#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2 +#define __USER_LABEL_PREFIX__ +#define __STDC_IEC_60559_BFP__ 201404L +#define __SIZEOF_PTRDIFF_T__ 8 +#define __FLT64X_HAS_INFINITY__ 1 +#define __SIZEOF_LONG__ 8 +#define __LDBL_DIG__ 18 +#define __FLT64_IS_IEC_60559__ 1 +#define __x86_64__ 1 +#define __FLT16_IS_IEC_60559__ 1 +#define __FLT16_MAX_EXP__ 16 +#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF +#define __INT_FAST16_MAX__ 0x7fffffffffffffffL +#define __GCC_CONSTRUCTIVE_SIZE 64 +#define __FLT64_DIG__ 15 +#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL +#define __UINT_LEAST64_TYPE__ long unsigned int +#define __FLT16_EPSILON__ 9.76562500000000000000000000000000000e-4F16 +#define __FLT_HAS_QUIET_NAN__ 1 +#define __FLT_MAX_10_EXP__ 38 +#define __FLT64X_HAS_DENORM__ 1 +#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL +#define __FLT_HAS_INFINITY__ 1 +#define __GNUC_EXECUTION_CHARSET_NAME "UTF-8" +#define __cpp_unicode_literals 200710L +#define __UINT_FAST16_TYPE__ long unsigned int +#define __DEC64_MAX__ 9.999999999999999E384DD +#define __INT_FAST32_WIDTH__ 64 +#define __CHAR16_TYPE__ short unsigned int +#define __PRAGMA_REDEFINE_EXTNAME 1 +#define __SIZE_WIDTH__ 64 +#define __SEG_FS 1 +#define __INT_LEAST16_MAX__ 0x7fff +#define __FLT16_NORM_MAX__ 6.55040000000000000000000000000000000e+4F16 +#define __DEC64_MANT_DIG__ 16 +#define __FLT32_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F32 +#define __SIG_ATOMIC_WIDTH__ 32 +#define __GCC_DESTRUCTIVE_SIZE 64 +#define __INT_LEAST64_TYPE__ long int +#define __INT16_TYPE__ short int +#define __INT_LEAST8_TYPE__ signed char +#define __FLT16_MAX__ 6.55040000000000000000000000000000000e+4F16 +#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128 +#define __cpp_structured_bindings 201606L +#define __SIZEOF_INT__ 4 +#define __DEC32_MAX_EXP__ 97 +#define __INT_FAST8_MAX__ 0x7f +#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128 +#define __INTPTR_MAX__ 0x7fffffffffffffffL +#define __cpp_sized_deallocation 201309L +#define __cpp_guaranteed_copy_elision 201606L +#define linux 1 +#define __FLT64_HAS_QUIET_NAN__ 1 +#define __FLT32_MIN_10_EXP__ (-37) +#define __EXCEPTIONS 1 +#define __UINT16_C(c) c +#define __PTRDIFF_WIDTH__ 64 +#define __LDBL_MANT_DIG__ 64 +#define __cpp_range_based_for 201603L +#define __INT_FAST16_WIDTH__ 64 +#define __FLT64_HAS_INFINITY__ 1 +#define __FLT64X_MAX__ 1.18973149535723176502126385303097021e+4932F64x +#define __FLT16_HAS_INFINITY__ 1 +#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16 +#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1) +#define __code_model_small__ 1 +#define __GCC_ATOMIC_LONG_LOCK_FREE 2 +#define __cpp_nontype_template_args 201411L +#define __DEC32_MANT_DIG__ 7 +#define __k8__ 1 +#define __INTPTR_TYPE__ long int +#define __UINT16_TYPE__ short unsigned int +#define __WCHAR_TYPE__ int +#define __pic__ 2 +#define __UINTPTR_MAX__ 0xffffffffffffffffUL +#define __INT_FAST64_WIDTH__ 64 +#define __cpp_decltype 200707L +#define __INT_FAST64_MAX__ 0x7fffffffffffffffL +#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1 +#define __FLT_NORM_MAX__ 3.40282346638528859811704183484516925e+38F +#define __FLT32_HAS_INFINITY__ 1 +#define __FLT64X_MAX_EXP__ 16384 +#define __UINT_FAST64_TYPE__ long unsigned int +#define __cpp_inline_variables 201606L +#define __BFLT16_MIN_EXP__ (-125) +#define __INT_MAX__ 0x7fffffff +#define __linux__ 1 +#define __INT64_TYPE__ long int +#define __FLT_MAX_EXP__ 128 +#define __ORDER_BIG_ENDIAN__ 4321 +#define __DBL_MANT_DIG__ 53 +#define __cpp_inheriting_constructors 201511L +#define QT_CORE_LIB 1 +#define __SIZEOF_FLOAT128__ 16 +#define __BFLT16_MANT_DIG__ 8 +#define __DEC64_MIN__ 1E-383DD +#define __WINT_TYPE__ unsigned int +#define __UINT_LEAST32_TYPE__ unsigned int +#define __SIZEOF_SHORT__ 2 +#define __FLT32_NORM_MAX__ 3.40282346638528859811704183484516925e+38F32 +#define __SSE__ 1 +#define __LDBL_MIN_EXP__ (-16381) +#define __FLT64_MAX__ 1.79769313486231570814527423731704357e+308F64 +#define __amd64__ 1 +#define __WINT_WIDTH__ 32 +#define __INT_LEAST64_WIDTH__ 64 +#define __FLT32X_MAX_10_EXP__ 308 +#define __cpp_namespace_attributes 201411L +#define __SIZEOF_INT128__ 16 +#define __FLT16_MIN__ 6.10351562500000000000000000000000000e-5F16 +#define __FLT64X_IS_IEC_60559__ 1 +#define __LDBL_MAX_10_EXP__ 4932 +#define __ATOMIC_RELAXED 0 +#define __DBL_EPSILON__ double(2.22044604925031308084726333618164062e-16L) +#define __INT_LEAST32_TYPE__ int +#define _LP64 1 +#define __UINT8_C(c) c +#define __FLT64_MAX_EXP__ 1024 +#define __SIZEOF_WCHAR_T__ 4 +#define __GNUC_PATCHLEVEL__ 1 +#define __FLT128_NORM_MAX__ 1.18973149535723176508575932662800702e+4932F128 +#define __FLT64_NORM_MAX__ 1.79769313486231570814527423731704357e+308F64 +#define __FLT128_HAS_QUIET_NAN__ 1 +#define __INTMAX_MAX__ 0x7fffffffffffffffL +#define __INT_FAST8_TYPE__ signed char +#define __FLT64X_MIN__ 3.36210314311209350626267781732175260e-4932F64x +#define __STDCPP_THREADS__ 1 +#define __BFLT16_HAS_DENORM__ 1 +#define __GNUC_STDC_INLINE__ 1 +#define __FLT64_HAS_DENORM__ 1 +#define __FLT32_EPSILON__ 1.19209289550781250000000000000000000e-7F32 +#define __FLT16_HAS_DENORM__ 1 +#define __DBL_DECIMAL_DIG__ 17 +#define __STDC_UTF_32__ 1 +#define __INT_FAST8_WIDTH__ 8 +#define __FXSR__ 1 +#define __FLT32X_MAX__ 1.79769313486231570814527423731704357e+308F32x +#define __DBL_NORM_MAX__ double(1.79769313486231570814527423731704357e+308L) +#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define __INTMAX_WIDTH__ 64 +#define __cpp_runtime_arrays 198712L +#define __FLT32_DIG__ 6 +#define __UINT64_TYPE__ long unsigned int +#define __UINT32_C(c) c ## U +#define __cpp_alias_templates 200704L +#define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F +#define __FLT128_IS_IEC_60559__ 1 +#define __INT8_MAX__ 0x7f +#define __LONG_WIDTH__ 64 +#define __DBL_MIN__ double(2.22507385850720138309023271733240406e-308L) +#define __PIC__ 2 +#define __INT32_MAX__ 0x7fffffff +#define __UINT_FAST32_TYPE__ long unsigned int +#define __FLT16_MANT_DIG__ 11 +#define __FLT32X_NORM_MAX__ 1.79769313486231570814527423731704357e+308F32x +#define __CHAR32_TYPE__ unsigned int +#define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F +#define __SSE2__ 1 +#define __cpp_deduction_guides 201703L +#define __BFLT16_NORM_MAX__ 3.38953138925153547590470800371487867e+38BF16 +#define __INT32_TYPE__ int +#define __SIZEOF_DOUBLE__ 8 +#define __cpp_exceptions 199711L +#define __FLT_MIN_10_EXP__ (-37) +#define __FLT64_MIN__ 2.22507385850720138309023271733240406e-308F64 +#define __INT_LEAST32_WIDTH__ 32 +#define __INTMAX_TYPE__ long int +#define __GLIBCXX_BITSIZE_INT_N_0 128 +#define __FLT32X_HAS_QUIET_NAN__ 1 +#define __ATOMIC_CONSUME 1 +#define __GNUC_MINOR__ 2 +#define __GLIBCXX_TYPE_INT_N_0 __int128 +#define __UINTMAX_MAX__ 0xffffffffffffffffUL +#define __PIE__ 2 +#define __FLT32X_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F32x +#define __cpp_template_template_args 201611L +#define __DBL_MAX_10_EXP__ 308 +#define __LDBL_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951L +#define __INT16_C(c) c +#define __STDC__ 1 +#define __PTRDIFF_TYPE__ long int +#define __LONG_MAX__ 0x7fffffffffffffffL +#define __FLT32X_MIN_10_EXP__ (-307) +#define __UINTPTR_TYPE__ long unsigned int +#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD +#define __DEC128_MANT_DIG__ 34 +#define __LDBL_MIN_10_EXP__ (-4931) +#define __cpp_generic_lambdas 201304L +#define __SSE_MATH__ 1 +#define __SIZEOF_LONG_LONG__ 8 +#define __cpp_user_defined_literals 200809L +#define __FLT128_DECIMAL_DIG__ 36 +#define __GCC_ATOMIC_LLONG_LOCK_FREE 2 +#define __FLT32_HAS_QUIET_NAN__ 1 +#define __FLT_DECIMAL_DIG__ 9 +#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL +#define __LDBL_NORM_MAX__ 1.18973149535723176502126385303097021e+4932L +#define __GCC_ATOMIC_SHORT_LOCK_FREE 2 +#define __SIZE_MAX__ 0xffffffffffffffffUL +#define __UINT_FAST8_TYPE__ unsigned char +#define _GNU_SOURCE 1 +#define __cpp_init_captures 201304L +#define __ATOMIC_ACQ_REL 4 +#define __ATOMIC_RELEASE 3 diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp new file mode 100755 index 0000000..de9bec6 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp @@ -0,0 +1,2 @@ +// This file is autogenerated. Changes will be overwritten. +#include "EWIEGA46WW/moc_mainwindow.cpp" diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/timestamp b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/timestamp new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt new file mode 100755 index 0000000..c7d6867 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt @@ -0,0 +1,469 @@ +# This is the CMakeCache file. +# For build in directory: /home/nktkln/Documents/1_Calculator/build/Desktop-Debug +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Value Computed by CMake +1_Calculator_BINARY_DIR:STATIC=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug + +//Value Computed by CMake +1_Calculator_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +1_Calculator_SOURCE_DIR:STATIC=/home/nktkln/Documents/1_Calculator + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//No help, variable specified on the command line. +CMAKE_BUILD_TYPE:STRING=Debug + +//Enable colored diagnostics throughout. +CMAKE_COLOR_DIAGNOSTICS:BOOL=1 + +//CXX compiler +CMAKE_CXX_COMPILER:STRING=/usr/bin/g++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING=-DQT_QML_DEBUG + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//No help, variable specified on the command line. +CMAKE_CXX_FLAGS_INIT:STRING=-DQT_QML_DEBUG + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +CMAKE_CXX_OUTPUT_EXTENSION:STRING=.o + +//No help, variable specified on the command line. +CMAKE_C_COMPILER:FILEPATH=/usr/bin/clang + +CMAKE_C_OUTPUT_EXTENSION:STRING= + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/pkgRedirects + +//No help, variable specified on the command line. +CMAKE_GENERATOR:STRING=Ninja + +//User executables (bin) +CMAKE_INSTALL_BINDIR:PATH=bin + +//Read-only architecture-independent data (DATAROOTDIR) +CMAKE_INSTALL_DATADIR:PATH= + +//Read-only architecture-independent data root (share) +CMAKE_INSTALL_DATAROOTDIR:PATH=share + +//Documentation root (DATAROOTDIR/doc/PROJECT_NAME) +CMAKE_INSTALL_DOCDIR:PATH= + +//C header files (include) +CMAKE_INSTALL_INCLUDEDIR:PATH=include + +//Info documentation (DATAROOTDIR/info) +CMAKE_INSTALL_INFODIR:PATH= + +//Object code libraries (lib) +CMAKE_INSTALL_LIBDIR:PATH=lib + +//Program executables (libexec) +CMAKE_INSTALL_LIBEXECDIR:PATH=libexec + +//Locale-dependent data (DATAROOTDIR/locale) +CMAKE_INSTALL_LOCALEDIR:PATH= + +//Modifiable single-machine data (var) +CMAKE_INSTALL_LOCALSTATEDIR:PATH=var + +//Man documentation (DATAROOTDIR/man) +CMAKE_INSTALL_MANDIR:PATH= + +//C header files for non-gcc (/usr/include) +CMAKE_INSTALL_OLDINCLUDEDIR:PATH=/usr/include + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Run-time variable data (LOCALSTATEDIR/run) +CMAKE_INSTALL_RUNSTATEDIR:PATH= + +//System admin executables (sbin) +CMAKE_INSTALL_SBINDIR:PATH=sbin + +//Modifiable architecture-independent data (com) +CMAKE_INSTALL_SHAREDSTATEDIR:PATH=com + +//Read-only single-machine data (etc) +CMAKE_INSTALL_SYSCONFDIR:PATH=etc + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Program used to build from build.ninja files. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/ninja + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//No help, variable specified on the command line. +CMAKE_PREFIX_PATH:PATH=/usr + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//No help, variable specified on the command line. +CMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=1_Calculator + +//Value Computed by CMake +CMAKE_PROJECT_VERSION:STATIC=0.1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MAJOR:STATIC=0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MINOR:STATIC=1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_PATCH:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_TWEAK:STATIC= + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Skip Qt Creator's package manager auto-setup +QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP:BOOL=OFF + +//The directory containing a CMake configuration file for QT. +QT_DIR:PATH=/usr/lib/cmake/Qt5 + +//No help, variable specified on the command line. +QT_QMAKE_EXECUTABLE:FILEPATH=/usr/bin/qmake + +//The directory containing a CMake configuration file for Qt5Core. +Qt5Core_DIR:PATH=/usr/lib/cmake/Qt5Core + +//The directory containing a CMake configuration file for Qt5Gui. +Qt5Gui_DIR:PATH=/usr/lib/cmake/Qt5Gui + +//The directory containing a CMake configuration file for Qt5Widgets. +Qt5Widgets_DIR:PATH=/usr/lib/cmake/Qt5Widgets + +//The directory containing a CMake configuration file for Qt5. +Qt5_DIR:PATH=/usr/lib/cmake/Qt5 + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=30 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Path to cache edit program executable. +CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/ccmake +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/nktkln/Documents/1_Calculator +//ADVANCED property for variable: CMAKE_INSTALL_BINDIR +CMAKE_INSTALL_BINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATADIR +CMAKE_INSTALL_DATADIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATAROOTDIR +CMAKE_INSTALL_DATAROOTDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DOCDIR +CMAKE_INSTALL_DOCDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INCLUDEDIR +CMAKE_INSTALL_INCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INFODIR +CMAKE_INSTALL_INFODIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBDIR +CMAKE_INSTALL_LIBDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBEXECDIR +CMAKE_INSTALL_LIBEXECDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALEDIR +CMAKE_INSTALL_LOCALEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALSTATEDIR +CMAKE_INSTALL_LOCALSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_MANDIR +CMAKE_INSTALL_MANDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_OLDINCLUDEDIR +CMAKE_INSTALL_OLDINCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_RUNSTATEDIR +CMAKE_INSTALL_RUNSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SBINDIR +CMAKE_INSTALL_SBINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SHAREDSTATEDIR +CMAKE_INSTALL_SHAREDSTATEDIR-ADVANCED:INTERNAL=1 +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0 +//ADVANCED property for variable: CMAKE_INSTALL_SYSCONFDIR +CMAKE_INSTALL_SYSCONFDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//linker supports push/pop state +_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE +//CMAKE_INSTALL_PREFIX during last run +_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX:INTERNAL=/usr/local + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt.prev b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt.prev new file mode 100755 index 0000000..c7d6867 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeCache.txt.prev @@ -0,0 +1,469 @@ +# This is the CMakeCache file. +# For build in directory: /home/nktkln/Documents/1_Calculator/build/Desktop-Debug +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Value Computed by CMake +1_Calculator_BINARY_DIR:STATIC=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug + +//Value Computed by CMake +1_Calculator_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +1_Calculator_SOURCE_DIR:STATIC=/home/nktkln/Documents/1_Calculator + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//No help, variable specified on the command line. +CMAKE_BUILD_TYPE:STRING=Debug + +//Enable colored diagnostics throughout. +CMAKE_COLOR_DIAGNOSTICS:BOOL=1 + +//CXX compiler +CMAKE_CXX_COMPILER:STRING=/usr/bin/g++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING=-DQT_QML_DEBUG + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//No help, variable specified on the command line. +CMAKE_CXX_FLAGS_INIT:STRING=-DQT_QML_DEBUG + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +CMAKE_CXX_OUTPUT_EXTENSION:STRING=.o + +//No help, variable specified on the command line. +CMAKE_C_COMPILER:FILEPATH=/usr/bin/clang + +CMAKE_C_OUTPUT_EXTENSION:STRING= + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/pkgRedirects + +//No help, variable specified on the command line. +CMAKE_GENERATOR:STRING=Ninja + +//User executables (bin) +CMAKE_INSTALL_BINDIR:PATH=bin + +//Read-only architecture-independent data (DATAROOTDIR) +CMAKE_INSTALL_DATADIR:PATH= + +//Read-only architecture-independent data root (share) +CMAKE_INSTALL_DATAROOTDIR:PATH=share + +//Documentation root (DATAROOTDIR/doc/PROJECT_NAME) +CMAKE_INSTALL_DOCDIR:PATH= + +//C header files (include) +CMAKE_INSTALL_INCLUDEDIR:PATH=include + +//Info documentation (DATAROOTDIR/info) +CMAKE_INSTALL_INFODIR:PATH= + +//Object code libraries (lib) +CMAKE_INSTALL_LIBDIR:PATH=lib + +//Program executables (libexec) +CMAKE_INSTALL_LIBEXECDIR:PATH=libexec + +//Locale-dependent data (DATAROOTDIR/locale) +CMAKE_INSTALL_LOCALEDIR:PATH= + +//Modifiable single-machine data (var) +CMAKE_INSTALL_LOCALSTATEDIR:PATH=var + +//Man documentation (DATAROOTDIR/man) +CMAKE_INSTALL_MANDIR:PATH= + +//C header files for non-gcc (/usr/include) +CMAKE_INSTALL_OLDINCLUDEDIR:PATH=/usr/include + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Run-time variable data (LOCALSTATEDIR/run) +CMAKE_INSTALL_RUNSTATEDIR:PATH= + +//System admin executables (sbin) +CMAKE_INSTALL_SBINDIR:PATH=sbin + +//Modifiable architecture-independent data (com) +CMAKE_INSTALL_SHAREDSTATEDIR:PATH=com + +//Read-only single-machine data (etc) +CMAKE_INSTALL_SYSCONFDIR:PATH=etc + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Program used to build from build.ninja files. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/ninja + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//No help, variable specified on the command line. +CMAKE_PREFIX_PATH:PATH=/usr + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//No help, variable specified on the command line. +CMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=1_Calculator + +//Value Computed by CMake +CMAKE_PROJECT_VERSION:STATIC=0.1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MAJOR:STATIC=0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MINOR:STATIC=1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_PATCH:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_TWEAK:STATIC= + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Skip Qt Creator's package manager auto-setup +QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP:BOOL=OFF + +//The directory containing a CMake configuration file for QT. +QT_DIR:PATH=/usr/lib/cmake/Qt5 + +//No help, variable specified on the command line. +QT_QMAKE_EXECUTABLE:FILEPATH=/usr/bin/qmake + +//The directory containing a CMake configuration file for Qt5Core. +Qt5Core_DIR:PATH=/usr/lib/cmake/Qt5Core + +//The directory containing a CMake configuration file for Qt5Gui. +Qt5Gui_DIR:PATH=/usr/lib/cmake/Qt5Gui + +//The directory containing a CMake configuration file for Qt5Widgets. +Qt5Widgets_DIR:PATH=/usr/lib/cmake/Qt5Widgets + +//The directory containing a CMake configuration file for Qt5. +Qt5_DIR:PATH=/usr/lib/cmake/Qt5 + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/nktkln/Documents/1_Calculator/build/Desktop-Debug +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=30 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Path to cache edit program executable. +CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/ccmake +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/nktkln/Documents/1_Calculator +//ADVANCED property for variable: CMAKE_INSTALL_BINDIR +CMAKE_INSTALL_BINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATADIR +CMAKE_INSTALL_DATADIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATAROOTDIR +CMAKE_INSTALL_DATAROOTDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DOCDIR +CMAKE_INSTALL_DOCDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INCLUDEDIR +CMAKE_INSTALL_INCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INFODIR +CMAKE_INSTALL_INFODIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBDIR +CMAKE_INSTALL_LIBDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBEXECDIR +CMAKE_INSTALL_LIBEXECDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALEDIR +CMAKE_INSTALL_LOCALEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALSTATEDIR +CMAKE_INSTALL_LOCALSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_MANDIR +CMAKE_INSTALL_MANDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_OLDINCLUDEDIR +CMAKE_INSTALL_OLDINCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_RUNSTATEDIR +CMAKE_INSTALL_RUNSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SBINDIR +CMAKE_INSTALL_SBINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SHAREDSTATEDIR +CMAKE_INSTALL_SHAREDSTATEDIR-ADVANCED:INTERNAL=1 +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0 +//ADVANCED property for variable: CMAKE_INSTALL_SYSCONFDIR +CMAKE_INSTALL_SYSCONFDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//linker supports push/pop state +_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE +//CMAKE_INSTALL_PREFIX during last run +_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX:INTERNAL=/usr/local + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o new file mode 100755 index 0000000..685622e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/main.cpp.o b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/main.cpp.o new file mode 100755 index 0000000..d0fbcc2 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/main.cpp.o differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/mainwindow.cpp.o b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/mainwindow.cpp.o new file mode 100755 index 0000000..a1a7067 Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir/mainwindow.cpp.o differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenInfo.json b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenInfo.json new file mode 100755 index 0000000..57e70c6 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenInfo.json @@ -0,0 +1,156 @@ +{ + "BUILD_DIR" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen", + "CMAKE_BINARY_DIR" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "CMAKE_CURRENT_BINARY_DIR" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug", + "CMAKE_CURRENT_SOURCE_DIR" : "/home/nktkln/Documents/1_Calculator", + "CMAKE_EXECUTABLE" : "/usr/bin/cmake", + "CMAKE_LIST_FILES" : + [ + "/home/nktkln/Documents/1_Calculator/CMakeLists.txt", + "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/.qtc/package-manager/auto-setup.cmake", + "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake", + "/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake", + "/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake", + "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake", + "/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake", + "/usr/share/cmake/Modules/CMakeGenericSystem.cmake", + "/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake", + "/usr/share/cmake/Modules/Platform/Linux.cmake", + "/usr/share/cmake/Modules/Platform/UnixPaths.cmake", + "/usr/share/cmake/Modules/CMakeCXXInformation.cmake", + "/usr/share/cmake/Modules/CMakeLanguageInformation.cmake", + "/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake", + "/usr/share/cmake/Modules/Compiler/GNU.cmake", + "/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake", + "/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake", + "/usr/share/cmake/Modules/Platform/Linux-GNU.cmake", + "/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake", + "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake", + "/usr/lib/cmake/Qt5/Qt5Config.cmake", + "/usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake", + "/usr/lib/cmake/Qt5/Qt5Config.cmake", + "/usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake", + "/usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake", + "/usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake", + "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake", + "/usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake", + "/usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake", + "/usr/share/cmake/Modules/CMakeParseArguments.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake", + "/usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake", + "/usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake", + "/usr/share/cmake/Modules/CMakeParseArguments.cmake", + "/usr/share/cmake/Modules/GNUInstallDirs.cmake" + ], + "CMAKE_SOURCE_DIR" : "/home/nktkln/Documents/1_Calculator", + "CROSS_CONFIG" : false, + "DEP_FILE" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/deps", + "DEP_FILE_RULE_NAME" : "1_Calculator_autogen/timestamp", + "HEADERS" : + [ + [ + "/home/nktkln/Documents/1_Calculator/mainwindow.h", + "MU", + "EWIEGA46WW/moc_mainwindow.cpp", + null + ] + ], + "HEADER_EXTENSIONS" : [ "h", "hh", "h++", "hm", "hpp", "hxx", "in", "txx" ], + "INCLUDE_DIR" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include", + "MOC_COMPILATION_FILE" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp", + "MOC_DEFINITIONS" : [ "QT_CORE_LIB", "QT_GUI_LIB", "QT_WIDGETS_LIB" ], + "MOC_DEPEND_FILTERS" : + [ + [ + "Q_PLUGIN_METADATA", + "[\n][ \t]*Q_PLUGIN_METADATA[ \t]*\\([^\\)]*FILE[ \t]*\"([^\"]+)\"" + ] + ], + "MOC_INCLUDES" : + [ + "/usr/include/qt", + "/usr/include/qt/QtWidgets", + "/usr/include/qt/QtGui", + "/usr/include/qt/QtCore", + "/usr/lib/qt/mkspecs/linux-g++", + "/usr/include/c++/14.2.1", + "/usr/include/c++/14.2.1/x86_64-pc-linux-gnu", + "/usr/include/c++/14.2.1/backward", + "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include", + "/usr/local/include", + "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed", + "/usr/include" + ], + "MOC_MACRO_NAMES" : [ "Q_OBJECT", "Q_GADGET", "Q_NAMESPACE", "Q_NAMESPACE_EXPORT" ], + "MOC_OPTIONS" : [], + "MOC_PATH_PREFIX" : false, + "MOC_PREDEFS_CMD" : + [ + "/usr/bin/g++", + "-std=gnu++17", + "-dM", + "-E", + "-c", + "/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp" + ], + "MOC_PREDEFS_FILE" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h", + "MOC_RELAXED_MODE" : false, + "MOC_SKIP" : [], + "MULTI_CONFIG" : false, + "PARALLEL" : 4, + "PARSE_CACHE_FILE" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/ParseCache.txt", + "QT_MOC_EXECUTABLE" : "/usr/bin/moc", + "QT_UIC_EXECUTABLE" : "/usr/bin/uic", + "QT_VERSION_MAJOR" : 5, + "QT_VERSION_MINOR" : 15, + "SETTINGS_FILE" : "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenUsed.txt", + "SOURCES" : + [ + [ "/home/nktkln/Documents/1_Calculator/main.cpp", "MU", null ], + [ "/home/nktkln/Documents/1_Calculator/mainwindow.cpp", "MU", null ] + ], + "UIC_OPTIONS" : [], + "UIC_SEARCH_PATHS" : [], + "UIC_SKIP" : [], + "UIC_UI_FILES" : [], + "USE_BETTER_GRAPH" : false, + "VERBOSITY" : 0 +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenUsed.txt b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenUsed.txt new file mode 100755 index 0000000..100a243 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenUsed.txt @@ -0,0 +1,2 @@ +moc:2fe698556f071dc2ede55c372421c63fed7d77212a75d6c4a97e43f8b910d2c3 +uic:452b95f48e3bbc9d2fd494ed484eeb598279fff30cbe2f18ee90045db5d090bf diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/ParseCache.txt b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/ParseCache.txt new file mode 100755 index 0000000..b85f7ba --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/ParseCache.txt @@ -0,0 +1,343 @@ +# Generated by CMake. Changes will be overwritten. +/home/nktkln/Documents/1_Calculator/mainwindow.h + mmc:Q_OBJECT + mdp:/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/moc_predefs.h + mdp:/home/nktkln/Documents/1_Calculator/mainwindow.h + mdp:/usr/include/asm-generic/errno-base.h + mdp:/usr/include/asm-generic/errno.h + mdp:/usr/include/asm/errno.h + mdp:/usr/include/asm/unistd.h + mdp:/usr/include/asm/unistd_64.h + mdp:/usr/include/assert.h + mdp:/usr/include/bits/atomic_wide_counter.h + mdp:/usr/include/bits/confname.h + mdp:/usr/include/bits/cpu-set.h + mdp:/usr/include/bits/endian.h + mdp:/usr/include/bits/endianness.h + mdp:/usr/include/bits/environments.h + mdp:/usr/include/bits/errno.h + mdp:/usr/include/bits/floatn-common.h + mdp:/usr/include/bits/floatn.h + mdp:/usr/include/bits/getopt_core.h + mdp:/usr/include/bits/getopt_posix.h + mdp:/usr/include/bits/libc-header-start.h + mdp:/usr/include/bits/locale.h + mdp:/usr/include/bits/long-double.h + mdp:/usr/include/bits/posix_opt.h + mdp:/usr/include/bits/pthread_stack_min-dynamic.h + mdp:/usr/include/bits/pthreadtypes-arch.h + mdp:/usr/include/bits/pthreadtypes.h + mdp:/usr/include/bits/sched.h + mdp:/usr/include/bits/setjmp.h + mdp:/usr/include/bits/struct_mutex.h + mdp:/usr/include/bits/struct_rwlock.h + mdp:/usr/include/bits/syscall.h + mdp:/usr/include/bits/thread-shared-types.h + mdp:/usr/include/bits/time.h + mdp:/usr/include/bits/time64.h + mdp:/usr/include/bits/timesize.h + mdp:/usr/include/bits/timex.h + mdp:/usr/include/bits/types.h + mdp:/usr/include/bits/types/FILE.h + mdp:/usr/include/bits/types/__FILE.h + mdp:/usr/include/bits/types/__locale_t.h + mdp:/usr/include/bits/types/__mbstate_t.h + mdp:/usr/include/bits/types/__sigset_t.h + mdp:/usr/include/bits/types/clock_t.h + mdp:/usr/include/bits/types/clockid_t.h + mdp:/usr/include/bits/types/error_t.h + mdp:/usr/include/bits/types/locale_t.h + mdp:/usr/include/bits/types/mbstate_t.h + mdp:/usr/include/bits/types/struct___jmp_buf_tag.h + mdp:/usr/include/bits/types/struct_itimerspec.h + mdp:/usr/include/bits/types/struct_sched_param.h + mdp:/usr/include/bits/types/struct_timespec.h + mdp:/usr/include/bits/types/struct_timeval.h + mdp:/usr/include/bits/types/struct_tm.h + mdp:/usr/include/bits/types/time_t.h + mdp:/usr/include/bits/types/timer_t.h + mdp:/usr/include/bits/types/wint_t.h + mdp:/usr/include/bits/typesizes.h + mdp:/usr/include/bits/unistd_ext.h + mdp:/usr/include/bits/wchar.h + mdp:/usr/include/bits/wctype-wchar.h + mdp:/usr/include/bits/wordsize.h + mdp:/usr/include/c++/14.2.1/algorithm + mdp:/usr/include/c++/14.2.1/array + mdp:/usr/include/c++/14.2.1/atomic + mdp:/usr/include/c++/14.2.1/backward/auto_ptr.h + mdp:/usr/include/c++/14.2.1/backward/binders.h + mdp:/usr/include/c++/14.2.1/bit + mdp:/usr/include/c++/14.2.1/bits/algorithmfwd.h + mdp:/usr/include/c++/14.2.1/bits/align.h + mdp:/usr/include/c++/14.2.1/bits/alloc_traits.h + mdp:/usr/include/c++/14.2.1/bits/allocated_ptr.h + mdp:/usr/include/c++/14.2.1/bits/allocator.h + mdp:/usr/include/c++/14.2.1/bits/atomic_base.h + mdp:/usr/include/c++/14.2.1/bits/atomic_lockfree_defines.h + mdp:/usr/include/c++/14.2.1/bits/atomic_wait.h + mdp:/usr/include/c++/14.2.1/bits/basic_ios.h + mdp:/usr/include/c++/14.2.1/bits/basic_ios.tcc + mdp:/usr/include/c++/14.2.1/bits/basic_string.h + mdp:/usr/include/c++/14.2.1/bits/basic_string.tcc + mdp:/usr/include/c++/14.2.1/bits/c++0x_warning.h + mdp:/usr/include/c++/14.2.1/bits/char_traits.h + mdp:/usr/include/c++/14.2.1/bits/charconv.h + mdp:/usr/include/c++/14.2.1/bits/concept_check.h + mdp:/usr/include/c++/14.2.1/bits/cpp_type_traits.h + mdp:/usr/include/c++/14.2.1/bits/cxxabi_forced.h + mdp:/usr/include/c++/14.2.1/bits/cxxabi_init_exception.h + mdp:/usr/include/c++/14.2.1/bits/erase_if.h + mdp:/usr/include/c++/14.2.1/bits/exception.h + mdp:/usr/include/c++/14.2.1/bits/exception_defines.h + mdp:/usr/include/c++/14.2.1/bits/exception_ptr.h + mdp:/usr/include/c++/14.2.1/bits/functexcept.h + mdp:/usr/include/c++/14.2.1/bits/functional_hash.h + mdp:/usr/include/c++/14.2.1/bits/hash_bytes.h + mdp:/usr/include/c++/14.2.1/bits/invoke.h + mdp:/usr/include/c++/14.2.1/bits/ios_base.h + mdp:/usr/include/c++/14.2.1/bits/iterator_concepts.h + mdp:/usr/include/c++/14.2.1/bits/list.tcc + mdp:/usr/include/c++/14.2.1/bits/locale_classes.h + mdp:/usr/include/c++/14.2.1/bits/locale_classes.tcc + mdp:/usr/include/c++/14.2.1/bits/locale_facets.h + mdp:/usr/include/c++/14.2.1/bits/locale_facets.tcc + mdp:/usr/include/c++/14.2.1/bits/localefwd.h + mdp:/usr/include/c++/14.2.1/bits/max_size_type.h + mdp:/usr/include/c++/14.2.1/bits/memory_resource.h + mdp:/usr/include/c++/14.2.1/bits/memoryfwd.h + mdp:/usr/include/c++/14.2.1/bits/mofunc_impl.h + mdp:/usr/include/c++/14.2.1/bits/move.h + mdp:/usr/include/c++/14.2.1/bits/move_only_function.h + mdp:/usr/include/c++/14.2.1/bits/nested_exception.h + mdp:/usr/include/c++/14.2.1/bits/new_allocator.h + mdp:/usr/include/c++/14.2.1/bits/node_handle.h + mdp:/usr/include/c++/14.2.1/bits/ostream.tcc + mdp:/usr/include/c++/14.2.1/bits/ostream_insert.h + mdp:/usr/include/c++/14.2.1/bits/out_ptr.h + mdp:/usr/include/c++/14.2.1/bits/postypes.h + mdp:/usr/include/c++/14.2.1/bits/predefined_ops.h + mdp:/usr/include/c++/14.2.1/bits/ptr_traits.h + mdp:/usr/include/c++/14.2.1/bits/range_access.h + mdp:/usr/include/c++/14.2.1/bits/ranges_algo.h + mdp:/usr/include/c++/14.2.1/bits/ranges_algobase.h + mdp:/usr/include/c++/14.2.1/bits/ranges_base.h + mdp:/usr/include/c++/14.2.1/bits/ranges_cmp.h + mdp:/usr/include/c++/14.2.1/bits/ranges_uninitialized.h + mdp:/usr/include/c++/14.2.1/bits/ranges_util.h + mdp:/usr/include/c++/14.2.1/bits/refwrap.h + mdp:/usr/include/c++/14.2.1/bits/requires_hosted.h + mdp:/usr/include/c++/14.2.1/bits/sat_arith.h + mdp:/usr/include/c++/14.2.1/bits/shared_ptr.h + mdp:/usr/include/c++/14.2.1/bits/shared_ptr_atomic.h + mdp:/usr/include/c++/14.2.1/bits/shared_ptr_base.h + mdp:/usr/include/c++/14.2.1/bits/std_abs.h + mdp:/usr/include/c++/14.2.1/bits/std_function.h + mdp:/usr/include/c++/14.2.1/bits/std_mutex.h + mdp:/usr/include/c++/14.2.1/bits/stl_algo.h + mdp:/usr/include/c++/14.2.1/bits/stl_algobase.h + mdp:/usr/include/c++/14.2.1/bits/stl_bvector.h + mdp:/usr/include/c++/14.2.1/bits/stl_construct.h + mdp:/usr/include/c++/14.2.1/bits/stl_function.h + mdp:/usr/include/c++/14.2.1/bits/stl_heap.h + mdp:/usr/include/c++/14.2.1/bits/stl_iterator.h + mdp:/usr/include/c++/14.2.1/bits/stl_iterator_base_funcs.h + mdp:/usr/include/c++/14.2.1/bits/stl_iterator_base_types.h + mdp:/usr/include/c++/14.2.1/bits/stl_list.h + mdp:/usr/include/c++/14.2.1/bits/stl_map.h + mdp:/usr/include/c++/14.2.1/bits/stl_multimap.h + mdp:/usr/include/c++/14.2.1/bits/stl_numeric.h + mdp:/usr/include/c++/14.2.1/bits/stl_pair.h + mdp:/usr/include/c++/14.2.1/bits/stl_raw_storage_iter.h + mdp:/usr/include/c++/14.2.1/bits/stl_relops.h + mdp:/usr/include/c++/14.2.1/bits/stl_tempbuf.h + mdp:/usr/include/c++/14.2.1/bits/stl_tree.h + mdp:/usr/include/c++/14.2.1/bits/stl_uninitialized.h + mdp:/usr/include/c++/14.2.1/bits/stl_vector.h + mdp:/usr/include/c++/14.2.1/bits/stream_iterator.h + mdp:/usr/include/c++/14.2.1/bits/streambuf.tcc + mdp:/usr/include/c++/14.2.1/bits/streambuf_iterator.h + mdp:/usr/include/c++/14.2.1/bits/string_view.tcc + mdp:/usr/include/c++/14.2.1/bits/stringfwd.h + mdp:/usr/include/c++/14.2.1/bits/uniform_int_dist.h + mdp:/usr/include/c++/14.2.1/bits/unique_ptr.h + mdp:/usr/include/c++/14.2.1/bits/uses_allocator.h + mdp:/usr/include/c++/14.2.1/bits/uses_allocator_args.h + mdp:/usr/include/c++/14.2.1/bits/utility.h + mdp:/usr/include/c++/14.2.1/bits/vector.tcc + mdp:/usr/include/c++/14.2.1/bits/version.h + mdp:/usr/include/c++/14.2.1/cctype + mdp:/usr/include/c++/14.2.1/cerrno + mdp:/usr/include/c++/14.2.1/charconv + mdp:/usr/include/c++/14.2.1/climits + mdp:/usr/include/c++/14.2.1/clocale + mdp:/usr/include/c++/14.2.1/compare + mdp:/usr/include/c++/14.2.1/concepts + mdp:/usr/include/c++/14.2.1/cstddef + mdp:/usr/include/c++/14.2.1/cstdint + mdp:/usr/include/c++/14.2.1/cstdlib + mdp:/usr/include/c++/14.2.1/cwchar + mdp:/usr/include/c++/14.2.1/cwctype + mdp:/usr/include/c++/14.2.1/debug/assertions.h + mdp:/usr/include/c++/14.2.1/debug/debug.h + mdp:/usr/include/c++/14.2.1/exception + mdp:/usr/include/c++/14.2.1/ext/aligned_buffer.h + mdp:/usr/include/c++/14.2.1/ext/alloc_traits.h + mdp:/usr/include/c++/14.2.1/ext/atomicity.h + mdp:/usr/include/c++/14.2.1/ext/concurrence.h + mdp:/usr/include/c++/14.2.1/ext/numeric_traits.h + mdp:/usr/include/c++/14.2.1/ext/string_conversions.h + mdp:/usr/include/c++/14.2.1/ext/type_traits.h + mdp:/usr/include/c++/14.2.1/format + mdp:/usr/include/c++/14.2.1/functional + mdp:/usr/include/c++/14.2.1/initializer_list + mdp:/usr/include/c++/14.2.1/ios + mdp:/usr/include/c++/14.2.1/iosfwd + mdp:/usr/include/c++/14.2.1/iterator + mdp:/usr/include/c++/14.2.1/limits + mdp:/usr/include/c++/14.2.1/list + mdp:/usr/include/c++/14.2.1/map + mdp:/usr/include/c++/14.2.1/memory + mdp:/usr/include/c++/14.2.1/new + mdp:/usr/include/c++/14.2.1/numbers + mdp:/usr/include/c++/14.2.1/numeric + mdp:/usr/include/c++/14.2.1/optional + mdp:/usr/include/c++/14.2.1/ostream + mdp:/usr/include/c++/14.2.1/pstl/execution_defs.h + mdp:/usr/include/c++/14.2.1/pstl/glue_numeric_defs.h + mdp:/usr/include/c++/14.2.1/stdexcept + mdp:/usr/include/c++/14.2.1/stdlib.h + mdp:/usr/include/c++/14.2.1/streambuf + mdp:/usr/include/c++/14.2.1/string + mdp:/usr/include/c++/14.2.1/string_view + mdp:/usr/include/c++/14.2.1/text_encoding + mdp:/usr/include/c++/14.2.1/tuple + mdp:/usr/include/c++/14.2.1/type_traits + mdp:/usr/include/c++/14.2.1/typeinfo + mdp:/usr/include/c++/14.2.1/unordered_map + mdp:/usr/include/c++/14.2.1/utility + mdp:/usr/include/c++/14.2.1/vector + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++locale.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/error_constants.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/gthr.h + mdp:/usr/include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h + mdp:/usr/include/ctype.h + mdp:/usr/include/errno.h + mdp:/usr/include/features-time64.h + mdp:/usr/include/features.h + mdp:/usr/include/gnu/stubs-64.h + mdp:/usr/include/gnu/stubs.h + mdp:/usr/include/linux/errno.h + mdp:/usr/include/locale.h + mdp:/usr/include/pthread.h + mdp:/usr/include/qt/QtCore/qalgorithms.h + mdp:/usr/include/qt/QtCore/qarraydata.h + mdp:/usr/include/qt/QtCore/qatomic.h + mdp:/usr/include/qt/QtCore/qatomic_cxx11.h + mdp:/usr/include/qt/QtCore/qbasicatomic.h + mdp:/usr/include/qt/QtCore/qbytearray.h + mdp:/usr/include/qt/QtCore/qbytearraylist.h + mdp:/usr/include/qt/QtCore/qchar.h + mdp:/usr/include/qt/QtCore/qcompilerdetection.h + mdp:/usr/include/qt/QtCore/qconfig.h + mdp:/usr/include/qt/QtCore/qcontainerfwd.h + mdp:/usr/include/qt/QtCore/qcontainertools_impl.h + mdp:/usr/include/qt/QtCore/qdatastream.h + mdp:/usr/include/qt/QtCore/qflags.h + mdp:/usr/include/qt/QtCore/qgenericatomic.h + mdp:/usr/include/qt/QtCore/qglobal.h + mdp:/usr/include/qt/QtCore/qglobalstatic.h + mdp:/usr/include/qt/QtCore/qhash.h + mdp:/usr/include/qt/QtCore/qhashfunctions.h + mdp:/usr/include/qt/QtCore/qiodevice.h + mdp:/usr/include/qt/QtCore/qiterator.h + mdp:/usr/include/qt/QtCore/qline.h + mdp:/usr/include/qt/QtCore/qlist.h + mdp:/usr/include/qt/QtCore/qlogging.h + mdp:/usr/include/qt/QtCore/qmargins.h + mdp:/usr/include/qt/QtCore/qmetatype.h + mdp:/usr/include/qt/QtCore/qnamespace.h + mdp:/usr/include/qt/QtCore/qnumeric.h + mdp:/usr/include/qt/QtCore/qobject.h + mdp:/usr/include/qt/QtCore/qobject_impl.h + mdp:/usr/include/qt/QtCore/qobjectdefs.h + mdp:/usr/include/qt/QtCore/qobjectdefs_impl.h + mdp:/usr/include/qt/QtCore/qpair.h + mdp:/usr/include/qt/QtCore/qpoint.h + mdp:/usr/include/qt/QtCore/qprocessordetection.h + mdp:/usr/include/qt/QtCore/qrect.h + mdp:/usr/include/qt/QtCore/qrefcount.h + mdp:/usr/include/qt/QtCore/qregexp.h + mdp:/usr/include/qt/QtCore/qscopedpointer.h + mdp:/usr/include/qt/QtCore/qshareddata.h + mdp:/usr/include/qt/QtCore/qsharedpointer.h + mdp:/usr/include/qt/QtCore/qsharedpointer_impl.h + mdp:/usr/include/qt/QtCore/qsize.h + mdp:/usr/include/qt/QtCore/qstring.h + mdp:/usr/include/qt/QtCore/qstringalgorithms.h + mdp:/usr/include/qt/QtCore/qstringlist.h + mdp:/usr/include/qt/QtCore/qstringliteral.h + mdp:/usr/include/qt/QtCore/qstringmatcher.h + mdp:/usr/include/qt/QtCore/qstringview.h + mdp:/usr/include/qt/QtCore/qsysinfo.h + mdp:/usr/include/qt/QtCore/qsystemdetection.h + mdp:/usr/include/qt/QtCore/qtcore-config.h + mdp:/usr/include/qt/QtCore/qtypeinfo.h + mdp:/usr/include/qt/QtCore/qvarlengtharray.h + mdp:/usr/include/qt/QtCore/qvector.h + mdp:/usr/include/qt/QtCore/qversiontagging.h + mdp:/usr/include/qt/QtGui/qbrush.h + mdp:/usr/include/qt/QtGui/qcolor.h + mdp:/usr/include/qt/QtGui/qcursor.h + mdp:/usr/include/qt/QtGui/qfont.h + mdp:/usr/include/qt/QtGui/qfontinfo.h + mdp:/usr/include/qt/QtGui/qfontmetrics.h + mdp:/usr/include/qt/QtGui/qicon.h + mdp:/usr/include/qt/QtGui/qimage.h + mdp:/usr/include/qt/QtGui/qkeysequence.h + mdp:/usr/include/qt/QtGui/qmatrix.h + mdp:/usr/include/qt/QtGui/qpaintdevice.h + mdp:/usr/include/qt/QtGui/qpalette.h + mdp:/usr/include/qt/QtGui/qpixelformat.h + mdp:/usr/include/qt/QtGui/qpixmap.h + mdp:/usr/include/qt/QtGui/qpolygon.h + mdp:/usr/include/qt/QtGui/qregion.h + mdp:/usr/include/qt/QtGui/qrgb.h + mdp:/usr/include/qt/QtGui/qrgba64.h + mdp:/usr/include/qt/QtGui/qtgui-config.h + mdp:/usr/include/qt/QtGui/qtguiglobal.h + mdp:/usr/include/qt/QtGui/qtransform.h + mdp:/usr/include/qt/QtGui/qwindowdefs.h + mdp:/usr/include/qt/QtWidgets/QMainWindow + mdp:/usr/include/qt/QtWidgets/qmainwindow.h + mdp:/usr/include/qt/QtWidgets/qsizepolicy.h + mdp:/usr/include/qt/QtWidgets/qtabwidget.h + mdp:/usr/include/qt/QtWidgets/qtwidgets-config.h + mdp:/usr/include/qt/QtWidgets/qtwidgetsglobal.h + mdp:/usr/include/qt/QtWidgets/qwidget.h + mdp:/usr/include/sched.h + mdp:/usr/include/stdc-predef.h + mdp:/usr/include/string.h + mdp:/usr/include/strings.h + mdp:/usr/include/sys/cdefs.h + mdp:/usr/include/sys/syscall.h + mdp:/usr/include/syscall.h + mdp:/usr/include/time.h + mdp:/usr/include/unistd.h + mdp:/usr/include/wchar.h + mdp:/usr/include/wctype.h + mdp:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/limits.h + mdp:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdarg.h + mdp:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stddef.h + mdp:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/stdint.h + mdp:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include/syslimits.h +/home/nktkln/Documents/1_Calculator/main.cpp +/home/nktkln/Documents/1_Calculator/mainwindow.cpp + uic:./ui_mainwindow.h diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake new file mode 100755 index 0000000..8b3004f --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake @@ -0,0 +1,105 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/g++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "14.2.1") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CXX_STANDARD_LATEST "26") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23;cxx_std_26") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") +set(CMAKE_CXX26_COMPILE_FEATURES "cxx_std_26") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld") +set(CMAKE_CXX_COMPILER_LINKER_ID "GNU") +set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.43.0) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU) +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang IN ITEMS C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED FALSE) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/14.2.1;/usr/include/c++/14.2.1/x86_64-pc-linux-gnu;/usr/include/c++/14.2.1/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed;/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1;/usr/lib;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") +### Imported target for C++23 standard library +set(CMAKE_CXX23_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Toolchain does not support discovering `import std` support") + + +### Imported target for C++26 standard library +set(CMAKE_CXX26_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Toolchain does not support discovering `import std` support") + + + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeDetermineCompilerABI_CXX.bin b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000..d17868f Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeDetermineCompilerABI_CXX.bin differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake new file mode 100755 index 0000000..bb9c350 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.10.7-arch1-1") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.10.7-arch1-1") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.10.7-arch1-1") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.10.7-arch1-1") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100755 index 0000000..da6c824 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,919 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define COMPILER_ID "CrayClang" +# define COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define COMPILER_ID "OrangeC" +# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define COMPILER_ID "TIClang" + # define COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "Arm" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/a.out b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/a.out new file mode 100755 index 0000000..8e01c3e Binary files /dev/null and b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/a.out differ diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeConfigureLog.yaml b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeConfigureLog.yaml new file mode 100755 index 0000000..4a1045d --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,259 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineSystem.cmake:205 (message)" + - "CMakeLists.txt:3 (project)" + message: | + The system is: Linux - 6.10.7-arch1-1 - x86_64 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:3 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/g++ + Build flags: -DQT_QML_DEBUG + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is GNU, found in: + /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/3.30.3/CompilerIdCXX/a.out + + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:74 (try_compile)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeScratch/TryCompile-h2DUU1" + binary: "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeScratch/TryCompile-h2DUU1" + cmakeVariables: + CMAKE_CXX_FLAGS: "-DQT_QML_DEBUG" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_CXX_SCAN_FOR_MODULES: "OFF" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CXX_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeScratch/TryCompile-h2DUU1' + + Run Build Command(s): /usr/bin/ninja -v cmTC_52280 + [1/2] /usr/bin/g++ -DQT_QML_DEBUG -fdiagnostics-color=always -v -o CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp + Using built-in specs. + COLLECT_GCC=/usr/bin/g++ + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc/src/gcc/configure --enable-languages=ada,c,c++,d,fortran,go,lto,m2,objc,obj-c++,rust --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20240805 (GCC) + COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -D_GNU_SOURCE -D QT_QML_DEBUG /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_52280.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fdiagnostics-color=always -o /tmp/cc6vasmJ.s + GNU C++17 (GCC) version 14.2.1 20240805 (x86_64-pc-linux-gnu) + compiled by GNU C version 14.2.1 20240805, GMP version 6.3.0, MPFR version 4.2.1, MPC version 1.3.1, isl version isl-0.26-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1 + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/backward + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include + /usr/local/include + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed + /usr/include + End of search list. + Compiler executable checksum: 438deb6040cbc4b51ad3ab8b369917b9 + COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/' + as -v --64 -o CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o /tmp/cc6vasmJ.s + GNU assembler version 2.43.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.43.0 + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.' + [2/2] : && /usr/bin/g++ -DQT_QML_DEBUG -v -Wl,-v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_52280 && : + Using built-in specs. + COLLECT_GCC=/usr/bin/g++ + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper + Target: x86_64-pc-linux-gnu + Configured with: /build/gcc/src/gcc/configure --enable-languages=ada,c,c++,d,fortran,go,lto,m2,objc,obj-c++,rust --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.1 20240805 (GCC) + COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-D' 'QT_QML_DEBUG' '-v' '-o' 'cmTC_52280' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_52280.' + /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrbCATp.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_52280 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + collect2 version 14.2.1 20240805 + /usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrbCATp.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_52280 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o + GNU ld (GNU Binutils) 2.43.0 + COLLECT_GCC_OPTIONS='-D' 'QT_QML_DEBUG' '-v' '-o' 'cmTC_52280' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_52280.' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:182 (message)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Parsed CXX implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/backward] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + add: [/usr/local/include] + add: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + add: [/usr/include] + end of search list found + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1] ==> [/usr/include/c++/14.2.1] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu] ==> [/usr/include/c++/14.2.1/x86_64-pc-linux-gnu] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/backward] ==> [/usr/include/c++/14.2.1/backward] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/include/c++/14.2.1;/usr/include/c++/14.2.1/x86_64-pc-linux-gnu;/usr/include/c++/14.2.1/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:218 (message)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Parsed CXX implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)] + ignore line: [Change Dir: '/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/CMakeScratch/TryCompile-h2DUU1'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/ninja -v cmTC_52280] + ignore line: [[1/2] /usr/bin/g++ -DQT_QML_DEBUG -fdiagnostics-color=always -v -o CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc/src/gcc/configure --enable-languages=ada c c++ d fortran go lto m2 objc obj-c++ rust --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20240805 (GCC) ] + ignore line: [COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/cc1plus -quiet -v -D_GNU_SOURCE -D QT_QML_DEBUG /usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_52280.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fdiagnostics-color=always -o /tmp/cc6vasmJ.s] + ignore line: [GNU C++17 (GCC) version 14.2.1 20240805 (x86_64-pc-linux-gnu)] + ignore line: [ compiled by GNU C version 14.2.1 20240805 GMP version 6.3.0 MPFR version 4.2.1 MPC version 1.3.1 isl version isl-0.26-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../x86_64-pc-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/backward] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/include-fixed] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [Compiler executable checksum: 438deb6040cbc4b51ad3ab8b369917b9] + ignore line: [COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o /tmp/cc6vasmJ.s] + ignore line: [GNU assembler version 2.43.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.43.0] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-fdiagnostics-color=always' '-D' 'QT_QML_DEBUG' '-v' '-o' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.'] + ignore line: [[2/2] : && /usr/bin/g++ -DQT_QML_DEBUG -v -Wl -v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_52280 && :] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/g++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] + ignore line: [Target: x86_64-pc-linux-gnu] + ignore line: [Configured with: /build/gcc/src/gcc/configure --enable-languages=ada c c++ d fortran go lto m2 objc obj-c++ rust --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.1 20240805 (GCC) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-D' 'QT_QML_DEBUG' '-v' '-o' 'cmTC_52280' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_52280.'] + link line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrbCATp.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_52280 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccrbCATp.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-o] ==> ignore + arg [cmTC_52280] ==> ignore + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o] + arg [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + ignore line: [collect2 version 14.2.1 20240805] + ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrbCATp.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_52280 /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../.. -v CMakeFiles/cmTC_52280.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] + linker tool for 'CXX': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/Scrt1.o] ==> [/usr/lib/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crti.o] ==> [/usr/lib/crti.o] + collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib/crtn.o] ==> [/usr/lib/crtn.o] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/Scrt1.o;/usr/lib/crti.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtbeginS.o;/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1/crtendS.o;/usr/lib/crtn.o] + implicit dirs: [/usr/lib/gcc/x86_64-pc-linux-gnu/14.2.1;/usr/lib;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)" + - "/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake:255 (cmake_determine_linker_id)" + - "/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Running the CXX compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils) 2.43.0 +... diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/TargetDirectories.txt b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/TargetDirectories.txt new file mode 100755 index 0000000..917b418 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,9 @@ +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/edit_cache.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/rebuild_cache.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/list_install_components.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/install.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/install/local.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/install/strip.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen_timestamp_deps.dir +/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/clean_additional.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/clean_additional.cmake new file mode 100755 index 0000000..856f9e0 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/clean_additional.cmake @@ -0,0 +1,10 @@ +# Additional clean files +cmake_minimum_required(VERSION 3.16) + +if("${CONFIG}" STREQUAL "" OR "${CONFIG}" STREQUAL "Debug") + file(REMOVE_RECURSE + "1_Calculator_autogen" + "CMakeFiles/1_Calculator_autogen.dir/AutogenUsed.txt" + "CMakeFiles/1_Calculator_autogen.dir/ParseCache.txt" + ) +endif() diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/cmake.check_cache b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/cmake.check_cache new file mode 100755 index 0000000..3dccd73 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/rules.ninja b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/rules.ninja new file mode 100755 index 0000000..ff58b4f --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/CMakeFiles/rules.ninja @@ -0,0 +1,72 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 3.30 + +# This file contains all the rules used to get the outputs files +# built from the input files. +# It is included in the main 'build.ninja'. + +# ============================================================================= +# Project: 1_Calculator +# Configurations: Debug +# ============================================================================= +# ============================================================================= + +############################################# +# Rule for compiling CXX files. + +rule CXX_COMPILER__1_Calculator_unscanned_Debug + depfile = $DEP_FILE + deps = gcc + command = ${LAUNCHER}${CODE_CHECK}/usr/bin/g++ $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in + description = Building CXX object $out + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_LINKER__1_Calculator_Debug + command = $PRE_LINK && /usr/bin/g++ $FLAGS $LINK_FLAGS $in -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD + description = Linking CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for running custom commands. + +rule CUSTOM_COMMAND + command = $COMMAND + description = $DESC + + +############################################# +# Rule for re-running cmake. + +rule RERUN_CMAKE + command = /usr/bin/cmake --regenerate-during-build -S/home/nktkln/Documents/1_Calculator -B/home/nktkln/Documents/1_Calculator/build/Desktop-Debug + description = Re-running CMake... + generator = 1 + + +############################################# +# Rule for cleaning additional files. + +rule CLEAN_ADDITIONAL + command = /usr/bin/cmake -DCONFIG=$CONFIG -P CMakeFiles/clean_additional.cmake + description = Cleaning additional files... + + +############################################# +# Rule for cleaning all built files. + +rule CLEAN + command = /usr/bin/ninja $FILE_ARG -t clean $TARGETS + description = Cleaning all built files... + + +############################################# +# Rule for printing all primary targets available. + +rule HELP + command = /usr/bin/ninja -t targets + description = All primary targets available: + diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/Testing/Temporary/LastTest.log b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/Testing/Temporary/LastTest.log new file mode 100755 index 0000000..8b97a58 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/Testing/Temporary/LastTest.log @@ -0,0 +1,3 @@ +Start testing: Sep 14 16:09 MSK +---------------------------------------------------------- +End testing: Sep 14 16:09 MSK diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/build.ninja b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/build.ninja new file mode 100755 index 0000000..356cc99 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/build.ninja @@ -0,0 +1,240 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 3.30 + +# This file contains all the build statements describing the +# compilation DAG. + +# ============================================================================= +# Write statements declared in CMakeLists.txt: +# +# Which is the root file. +# ============================================================================= + +# ============================================================================= +# Project: 1_Calculator +# Configurations: Debug +# ============================================================================= + +############################################# +# Minimal version of Ninja required by this file + +ninja_required_version = 1.5 + + +############################################# +# Set configuration variable for custom commands. + +CONFIGURATION = Debug +# ============================================================================= +# Include auxiliary files. + + +############################################# +# Include rules file. + +include CMakeFiles/rules.ninja + +# ============================================================================= + +############################################# +# Logical path to working directory; prefix for absolute paths. + +cmake_ninja_workdir = /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/ +# ============================================================================= +# Object build statements for EXECUTABLE target 1_Calculator + + +############################################# +# Order-only phony target for 1_Calculator + +build cmake_object_order_depends_target_1_Calculator: phony || 1_Calculator_autogen 1_Calculator_autogen/mocs_compilation.cpp 1_Calculator_autogen/timestamp 1_Calculator_autogen_timestamp_deps + +build CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o: CXX_COMPILER__1_Calculator_unscanned_Debug /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/mocs_compilation.cpp || cmake_object_order_depends_target_1_Calculator + DEFINES = -DQT_CORE_LIB -DQT_GUI_LIB -DQT_WIDGETS_LIB + DEP_FILE = CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o.d + FLAGS = -DQT_QML_DEBUG -g -std=gnu++17 -fdiagnostics-color=always -fPIC + INCLUDES = -I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include -isystem /usr/include/qt -isystem /usr/include/qt/QtWidgets -isystem /usr/include/qt/QtGui -isystem /usr/include/qt/QtCore -isystem /usr/lib/qt/mkspecs/linux-g++ + OBJECT_DIR = CMakeFiles/1_Calculator.dir + OBJECT_FILE_DIR = CMakeFiles/1_Calculator.dir/1_Calculator_autogen + +build CMakeFiles/1_Calculator.dir/main.cpp.o: CXX_COMPILER__1_Calculator_unscanned_Debug /home/nktkln/Documents/1_Calculator/main.cpp || cmake_object_order_depends_target_1_Calculator + DEFINES = -DQT_CORE_LIB -DQT_GUI_LIB -DQT_WIDGETS_LIB + DEP_FILE = CMakeFiles/1_Calculator.dir/main.cpp.o.d + FLAGS = -DQT_QML_DEBUG -g -std=gnu++17 -fdiagnostics-color=always -fPIC + INCLUDES = -I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include -isystem /usr/include/qt -isystem /usr/include/qt/QtWidgets -isystem /usr/include/qt/QtGui -isystem /usr/include/qt/QtCore -isystem /usr/lib/qt/mkspecs/linux-g++ + OBJECT_DIR = CMakeFiles/1_Calculator.dir + OBJECT_FILE_DIR = CMakeFiles/1_Calculator.dir + +build CMakeFiles/1_Calculator.dir/mainwindow.cpp.o: CXX_COMPILER__1_Calculator_unscanned_Debug /home/nktkln/Documents/1_Calculator/mainwindow.cpp || cmake_object_order_depends_target_1_Calculator + DEFINES = -DQT_CORE_LIB -DQT_GUI_LIB -DQT_WIDGETS_LIB + DEP_FILE = CMakeFiles/1_Calculator.dir/mainwindow.cpp.o.d + FLAGS = -DQT_QML_DEBUG -g -std=gnu++17 -fdiagnostics-color=always -fPIC + INCLUDES = -I/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/include -isystem /usr/include/qt -isystem /usr/include/qt/QtWidgets -isystem /usr/include/qt/QtGui -isystem /usr/include/qt/QtCore -isystem /usr/lib/qt/mkspecs/linux-g++ + OBJECT_DIR = CMakeFiles/1_Calculator.dir + OBJECT_FILE_DIR = CMakeFiles/1_Calculator.dir + + +# ============================================================================= +# Link build statements for EXECUTABLE target 1_Calculator + + +############################################# +# Link the executable 1_Calculator + +build 1_Calculator: CXX_EXECUTABLE_LINKER__1_Calculator_Debug CMakeFiles/1_Calculator.dir/1_Calculator_autogen/mocs_compilation.cpp.o CMakeFiles/1_Calculator.dir/main.cpp.o CMakeFiles/1_Calculator.dir/mainwindow.cpp.o | /usr/lib/libQt5Widgets.so.5.15.14 /usr/lib/libQt5Gui.so.5.15.14 /usr/lib/libQt5Core.so.5.15.14 || 1_Calculator_autogen 1_Calculator_autogen_timestamp_deps + FLAGS = -DQT_QML_DEBUG -g + LINK_LIBRARIES = /usr/lib/libQt5Widgets.so.5.15.14 /usr/lib/libQt5Gui.so.5.15.14 /usr/lib/libQt5Core.so.5.15.14 + OBJECT_DIR = CMakeFiles/1_Calculator.dir + POST_BUILD = : + PRE_LINK = : + TARGET_FILE = 1_Calculator + TARGET_PDB = 1_Calculator.dbg + + +############################################# +# Utility command for edit_cache + +build CMakeFiles/edit_cache.util: CUSTOM_COMMAND + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/ccmake -S/home/nktkln/Documents/1_Calculator -B/home/nktkln/Documents/1_Calculator/build/Desktop-Debug + DESC = Running CMake cache editor... + pool = console + restat = 1 + +build edit_cache: phony CMakeFiles/edit_cache.util + + +############################################# +# Utility command for rebuild_cache + +build CMakeFiles/rebuild_cache.util: CUSTOM_COMMAND + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/cmake --regenerate-during-build -S/home/nktkln/Documents/1_Calculator -B/home/nktkln/Documents/1_Calculator/build/Desktop-Debug + DESC = Running CMake to regenerate build system... + pool = console + restat = 1 + +build rebuild_cache: phony CMakeFiles/rebuild_cache.util + + +############################################# +# Utility command for list_install_components + +build list_install_components: phony + + +############################################# +# Utility command for install + +build CMakeFiles/install.util: CUSTOM_COMMAND all + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/cmake -P cmake_install.cmake + DESC = Install the project... + pool = console + restat = 1 + +build install: phony CMakeFiles/install.util + + +############################################# +# Utility command for install/local + +build CMakeFiles/install/local.util: CUSTOM_COMMAND all + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake + DESC = Installing only the local directory... + pool = console + restat = 1 + +build install/local: phony CMakeFiles/install/local.util + + +############################################# +# Utility command for install/strip + +build CMakeFiles/install/strip.util: CUSTOM_COMMAND all + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake + DESC = Installing the project stripped... + pool = console + restat = 1 + +build install/strip: phony CMakeFiles/install/strip.util + + +############################################# +# Utility command for 1_Calculator_autogen_timestamp_deps + +build 1_Calculator_autogen_timestamp_deps: phony + + +############################################# +# Utility command for 1_Calculator_autogen + +build 1_Calculator_autogen: phony CMakeFiles/1_Calculator_autogen 1_Calculator_autogen/include/ui_mainwindow.h 1_Calculator_autogen/include/ui_programmingwindow.h 1_Calculator_autogen/timestamp 1_Calculator_autogen/mocs_compilation.cpp 1_Calculator_autogen_timestamp_deps + + +############################################# +# Custom command for 1_Calculator_autogen/timestamp + +build 1_Calculator_autogen/timestamp 1_Calculator_autogen/mocs_compilation.cpp | ${cmake_ninja_workdir}1_Calculator_autogen/timestamp ${cmake_ninja_workdir}1_Calculator_autogen/mocs_compilation.cpp: CUSTOM_COMMAND /usr/bin/moc /usr/bin/uic || 1_Calculator_autogen_timestamp_deps + COMMAND = cd /home/nktkln/Documents/1_Calculator/build/Desktop-Debug && /usr/bin/cmake -E cmake_autogen /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/1_Calculator_autogen.dir/AutogenInfo.json Debug && /usr/bin/cmake -E touch /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/timestamp && /usr/bin/cmake -E cmake_transform_depfile Ninja gccdepfile /home/nktkln/Documents/1_Calculator /home/nktkln/Documents/1_Calculator /home/nktkln/Documents/1_Calculator/build/Desktop-Debug /home/nktkln/Documents/1_Calculator/build/Desktop-Debug /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator_autogen/deps /home/nktkln/Documents/1_Calculator/build/Desktop-Debug/CMakeFiles/d/177e7d34e6d3807b0a60c8a02d506a03c9e67420a1524fdd6e02a67b744d59b1.d + DESC = Automatic MOC and UIC for target 1_Calculator + depfile = CMakeFiles/d/177e7d34e6d3807b0a60c8a02d506a03c9e67420a1524fdd6e02a67b744d59b1.d + deps = gcc + restat = 1 + + +############################################# +# Phony custom command for CMakeFiles/1_Calculator_autogen + +build CMakeFiles/1_Calculator_autogen 1_Calculator_autogen/include/ui_mainwindow.h 1_Calculator_autogen/include/ui_programmingwindow.h | ${cmake_ninja_workdir}CMakeFiles/1_Calculator_autogen ${cmake_ninja_workdir}1_Calculator_autogen/include/ui_mainwindow.h ${cmake_ninja_workdir}1_Calculator_autogen/include/ui_programmingwindow.h: phony 1_Calculator_autogen/timestamp || 1_Calculator_autogen_timestamp_deps + +# ============================================================================= +# Target aliases. + +# ============================================================================= +# Folder targets. + +# ============================================================================= + +############################################# +# Folder: /home/nktkln/Documents/1_Calculator/build/Desktop-Debug + +build all: phony 1_Calculator + +# ============================================================================= +# Built-in targets + + +############################################# +# Re-run CMake if any of its inputs changed. + +build build.ninja: RERUN_CMAKE | .qtc/package-manager/auto-setup.cmake /home/nktkln/Documents/1_Calculator/CMakeLists.txt /usr/lib/cmake/Qt5/Qt5Config.cmake /usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake /usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake /usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake /usr/share/cmake/Modules/CMakeCXXInformation.cmake /usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake/Modules/CMakeGenericSystem.cmake /usr/share/cmake/Modules/CMakeInitializeConfigs.cmake /usr/share/cmake/Modules/CMakeLanguageInformation.cmake /usr/share/cmake/Modules/CMakeParseArguments.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake/Modules/Compiler/GNU.cmake /usr/share/cmake/Modules/GNUInstallDirs.cmake /usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake/Modules/Platform/Linux.cmake /usr/share/cmake/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.30.3/CMakeCXXCompiler.cmake CMakeFiles/3.30.3/CMakeSystem.cmake + pool = console + + +############################################# +# A missing CMake input file is not an error. + +build .qtc/package-manager/auto-setup.cmake /home/nktkln/Documents/1_Calculator/CMakeLists.txt /usr/lib/cmake/Qt5/Qt5Config.cmake /usr/lib/cmake/Qt5/Qt5ConfigVersion.cmake /usr/lib/cmake/Qt5/Qt5ModuleLocation.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfig.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtras.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake /usr/lib/cmake/Qt5Core/Qt5CoreConfigVersion.cmake /usr/lib/cmake/Qt5Core/Qt5CoreMacros.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfig.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake /usr/lib/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QGtk3ThemePlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QPdfPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgIconPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QSvgPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QTsLibPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandEglPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeEglPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QWaylandXCompositeGlxPlatformIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake /usr/lib/cmake/Qt5Gui/Qt5Gui_QXdgDesktopPortalThemePlugin.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake /usr/lib/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake /usr/share/cmake/Modules/CMakeCXXInformation.cmake /usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake/Modules/CMakeGenericSystem.cmake /usr/share/cmake/Modules/CMakeInitializeConfigs.cmake /usr/share/cmake/Modules/CMakeLanguageInformation.cmake /usr/share/cmake/Modules/CMakeParseArguments.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake/Modules/Compiler/GNU.cmake /usr/share/cmake/Modules/GNUInstallDirs.cmake /usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake/Modules/Platform/Linux-GNU.cmake /usr/share/cmake/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake/Modules/Platform/Linux.cmake /usr/share/cmake/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.30.3/CMakeCXXCompiler.cmake CMakeFiles/3.30.3/CMakeSystem.cmake: phony + + +############################################# +# Clean additional files. + +build CMakeFiles/clean.additional: CLEAN_ADDITIONAL + CONFIG = Debug + + +############################################# +# Clean all the built files. + +build clean: CLEAN CMakeFiles/clean.additional + + +############################################# +# Print all primary targets available. + +build help: HELP + + +############################################# +# Make the all target the default. + +default all diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/cmake_install.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/cmake_install.cmake new file mode 100755 index 0000000..6c7b1ac --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/cmake_install.cmake @@ -0,0 +1,78 @@ +# Install script for directory: /home/nktkln/Documents/1_Calculator + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "Debug") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Install shared libraries without execute permission? +if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) + set(CMAKE_INSTALL_SO_NO_EXE "0") +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set path to fallback-tool for dependency-resolution. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/usr/bin/objdump") +endif() + +if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT) + if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator" AND + NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator") + file(RPATH_CHECK + FILE "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator" + RPATH "") + endif() + file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" TYPE EXECUTABLE FILES "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/1_Calculator") + if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator" AND + NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator") + if(CMAKE_INSTALL_DO_STRIP) + execute_process(COMMAND "/usr/bin/strip" "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/1_Calculator") + endif() + endif() +endif() + +if(CMAKE_INSTALL_COMPONENT) + if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") + else() + string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt") + unset(CMAKE_INST_COMP_HASH) + endif() +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +if(NOT CMAKE_INSTALL_LOCAL_ONLY) + string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") + file(WRITE "/home/nktkln/Documents/1_Calculator/build/Desktop-Debug/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() diff --git a/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/qtcsettings.cmake b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/qtcsettings.cmake new file mode 100755 index 0000000..1649748 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/build/Desktop-Debug/qtcsettings.cmake @@ -0,0 +1,2 @@ +# This file is managed by Qt Creator, do not edit! + diff --git a/Third term/Industrial programming technologies/1_Calculator/calculator.ui b/Third term/Industrial programming technologies/1_Calculator/calculator.ui new file mode 100755 index 0000000..77627f9 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/calculator.ui @@ -0,0 +1,398 @@ + + + MainWindow + + + + 0 + 0 + 350 + 586 + + + + MainWindow + + + + + + 6 + 456 + 166 + 80 + + + + + 18 + + + + 0 + + + + + + 178 + 456 + 80 + 80 + + + + + 18 + + + + . + + + + + + 264 + 456 + 80 + 80 + + + + + 18 + + + + = + + + + + + 6 + 284 + 80 + 80 + + + + + 18 + + + + 4 + + + + + + 178 + 284 + 80 + 80 + + + + + 18 + + + + 6 + + + + + + 92 + 284 + 80 + 80 + + + + + 18 + + + + 5 + + + + + + 264 + 284 + 80 + 80 + + + + + 18 + + + + - + + + + + + 6 + 198 + 80 + 80 + + + + + 18 + + + + 7 + + + + + + 178 + 198 + 80 + 80 + + + + + 18 + + + + 9 + + + + + + 92 + 198 + 80 + 80 + + + + + 18 + + + + 8 + + + + + + 264 + 198 + 80 + 80 + + + + + 18 + + + + * + + + + + + 6 + 112 + 80 + 80 + + + + + 18 + + + + C + + + + + + 178 + 112 + 80 + 80 + + + + + 18 + + + + % + + + + + + 92 + 112 + 80 + 80 + + + + + 18 + + + + +/- + + + + + + 264 + 112 + 80 + 80 + + + + + 18 + + + + / + + + + + + 12 + 6 + 326 + 100 + + + + + 18 + + + + Qt::LayoutDirection::LeftToRight + + + false + + + d + + + + + + 92 + 370 + 80 + 80 + + + + + 18 + + + + 2 + + + + + + 264 + 370 + 80 + 80 + + + + + 18 + + + + + + + + + + + 178 + 370 + 80 + 80 + + + + + 18 + + + + 3 + + + + + + 6 + 370 + 80 + 80 + + + + + 18 + + + + 1 + + + + + + + + 0 + 0 + 350 + 23 + + + + + + + diff --git a/Third term/Industrial programming technologies/1_Calculator/main.cpp b/Third term/Industrial programming technologies/1_Calculator/main.cpp new file mode 100755 index 0000000..fd3e533 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/main.cpp @@ -0,0 +1,11 @@ +#include "mainwindow.h" + +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + MainWindow w; + w.show(); + return a.exec(); +} diff --git a/Third term/Industrial programming technologies/1_Calculator/mainwindow.cpp b/Third term/Industrial programming technologies/1_Calculator/mainwindow.cpp new file mode 100755 index 0000000..959586b --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/mainwindow.cpp @@ -0,0 +1,170 @@ +#include +#include "mainwindow.h" +#include "./ui_mainwindow.h" + +MainWindow::MainWindow(QWidget *parent) + : QMainWindow(parent) + , ui(new Ui::MainWindow) + , currentValue(0) + , storedValue(0) + , doubleDepth(0) +{ + ui->setupUi(this); + + connect(ui->button0, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button1, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button2, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button3, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button4, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button5, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button6, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button7, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button8, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->button9, &QPushButton::clicked, this, &MainWindow::digitClicked); + connect(ui->buttonDot, &QPushButton::clicked, this, &MainWindow::dotClicked); + + connect(ui->buttonAdd, &QPushButton::clicked, this, &MainWindow::addClicked); + connect(ui->buttonSubtract, &QPushButton::clicked, this, &MainWindow::subtractClicked); + connect(ui->buttonMultiply, &QPushButton::clicked, this, &MainWindow::multiplyClicked); + connect(ui->buttonDivide, &QPushButton::clicked, this, &MainWindow::divideClicked); + connect(ui->buttonEquals, &QPushButton::clicked, this, &MainWindow::equalsClicked); + connect(ui->buttonClear, &QPushButton::clicked, this, &MainWindow::clearClicked); + connect(ui->buttonChangeSign, &QPushButton::clicked, this, &MainWindow::changeSignClicked); + connect(ui->buttonPow, &QPushButton::clicked, this, &MainWindow::powClicked); +} + +MainWindow::~MainWindow() +{ + delete ui; +} + +void MainWindow::printDisplay() +{ + if (pendingOperator == "") { + ui->display->setText(QString::number(currentValue)); + } else { + QString out; + + if (storedValue < 0) { + out += "(" + QString::number(storedValue) + ")"; + } else { + out += QString::number(storedValue); + } + + out += pendingOperator; + + if (currentValue < 0) { + out += "(" + QString::number(currentValue) + ")"; + } else { + out += QString::number(currentValue); + } + + ui->display->setText(out); + } +} + +void MainWindow::digitClicked() +{ + QPushButton *clickedButton = qobject_cast(sender()); + int digitValue = clickedButton->text().toInt(); + if (currentValue < 0) digitValue *= -1; + if (doubleDepth != 0) { + currentValue += digitValue * std::pow(0.1, doubleDepth); + doubleDepth++; + } else { + currentValue = currentValue * 10 + digitValue; + } + printDisplay(); +} + +void MainWindow::dotClicked() { + doubleDepth = 1; + ui->display->setText(QString::number(currentValue)); +} + +void MainWindow::addClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "+"; + printDisplay(); +} + +void MainWindow::subtractClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "-"; + printDisplay(); +} + +void MainWindow::multiplyClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "*"; + printDisplay(); +} + +void MainWindow::divideClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "/"; + printDisplay(); +} + +void MainWindow::powClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "^"; + printDisplay(); +} + +void MainWindow::equalsClicked() +{ + if (pendingOperator == "+") { + currentValue = storedValue + currentValue; + } else if (pendingOperator == "-") { + currentValue = storedValue - currentValue; + } else if (pendingOperator == "*") { + currentValue = storedValue * currentValue; + } else if (pendingOperator == "/") { + if (currentValue != 0) { + currentValue = storedValue / currentValue; + } else { + ui->display->setText("Error"); + return; + } + } else if (pendingOperator == "^") { + if (currentValue != 0) { + currentValue = std::pow(storedValue, currentValue); + } else { + ui->display->setText("Error"); + return; + } + } + + pendingOperator = ""; + printDisplay(); +} + +void MainWindow::clearClicked() +{ + currentValue = 0; + storedValue = 0; + pendingOperator = ""; + printDisplay(); +} + +void MainWindow::changeSignClicked() +{ + currentValue *= -1; + printDisplay(); +} diff --git a/Third term/Industrial programming technologies/1_Calculator/mainwindow.h b/Third term/Industrial programming technologies/1_Calculator/mainwindow.h new file mode 100755 index 0000000..b9ee483 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/mainwindow.h @@ -0,0 +1,41 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include + +QT_BEGIN_NAMESPACE +namespace Ui { +class MainWindow; +} +QT_END_NAMESPACE + +class MainWindow : public QMainWindow +{ + Q_OBJECT + +public: + MainWindow(QWidget *parent = nullptr); + ~MainWindow(); + +private slots: + void digitClicked(); + void dotClicked(); + void addClicked(); + void subtractClicked(); + void multiplyClicked(); + void divideClicked(); + void equalsClicked(); + void clearClicked(); + void changeSignClicked(); + void powClicked(); + void printDisplay(); + +private: + Ui::MainWindow *ui; + double currentValue; + double storedValue; + int doubleDepth; + QString pendingOperator; +}; + +#endif // MAINWINDOW_H diff --git a/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui b/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui new file mode 100755 index 0000000..94decb3 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui @@ -0,0 +1,496 @@ + + + MainWindow + + + + 0 + 0 + 350 + 564 + + + + + 0 + 0 + + + + Calculator + + + + + 0 + 0 + + + + + + 6 + 456 + 166 + 80 + + + + + 18 + + + + 0 + + + 0 + + + + + + 178 + 456 + 80 + 80 + + + + + 18 + + + + . + + + . + + + + + + 264 + 456 + 80 + 80 + + + + + 18 + + + + = + + + Ctrl+S + + + + + + 6 + 284 + 80 + 80 + + + + + 18 + + + + 4 + + + 4 + + + + + + 178 + 284 + 80 + 80 + + + + + 18 + + + + 6 + + + 6 + + + + + + 92 + 284 + 80 + 80 + + + + + 18 + + + + 5 + + + 5 + + + + + + 264 + 284 + 80 + 80 + + + + + 18 + + + + - + + + - + + + + + + 6 + 198 + 80 + 80 + + + + + 18 + + + + 7 + + + 7 + + + + + + 178 + 198 + 80 + 80 + + + + + 18 + + + + 9 + + + 9 + + + + + + 92 + 198 + 80 + 80 + + + + + 18 + + + + 8 + + + 8 + + + + + + 264 + 198 + 80 + 80 + + + + + 18 + + + + * + + + * + + + + + + 6 + 112 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 178 + 112 + 80 + 80 + + + + + 18 + + + + ^ + + + ^ + + + + + + 92 + 112 + 80 + 80 + + + + + 18 + + + + +/- + + + + + + 264 + 112 + 80 + 80 + + + + + 18 + + + + / + + + / + + + + + + 12 + 6 + 326 + 100 + + + + + 18 + + + + Qt::LayoutDirection::LeftToRight + + + false + + + 0 + + + + + + 92 + 370 + 80 + 80 + + + + + 18 + + + + 2 + + + 2 + + + + + + 264 + 370 + 80 + 80 + + + + + 18 + + + + + + + + + + + + + + + 178 + 370 + 80 + 80 + + + + + 18 + + + + 3 + + + 3 + + + + + + 6 + 370 + 80 + 80 + + + + + 18 + + + + 1 + + + 1 + + + + + + 280 + 160 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + + 0 + 0 + 350 + 23 + + + + + Calculator + + + + + Programming + + + + + + + + + diff --git a/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui.autosave b/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui.autosave new file mode 100755 index 0000000..0f4b123 --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/mainwindow.ui.autosave @@ -0,0 +1,475 @@ + + + MainWindow + + + + 0 + 0 + 350 + 564 + + + + + 0 + 0 + + + + Calculator + + + + + 0 + 0 + + + + + + 6 + 456 + 166 + 80 + + + + + 18 + + + + 0 + + + 0 + + + + + + 178 + 456 + 80 + 80 + + + + + 18 + + + + . + + + . + + + + + + 264 + 456 + 80 + 80 + + + + + 18 + + + + = + + + Ctrl+S + + + + + + 6 + 284 + 80 + 80 + + + + + 18 + + + + 4 + + + 4 + + + + + + 178 + 284 + 80 + 80 + + + + + 18 + + + + 6 + + + 6 + + + + + + 92 + 284 + 80 + 80 + + + + + 18 + + + + 5 + + + 5 + + + + + + 264 + 284 + 80 + 80 + + + + + 18 + + + + - + + + - + + + + + + 6 + 198 + 80 + 80 + + + + + 18 + + + + 7 + + + 7 + + + + + + 178 + 198 + 80 + 80 + + + + + 18 + + + + 9 + + + 9 + + + + + + 92 + 198 + 80 + 80 + + + + + 18 + + + + 8 + + + 8 + + + + + + 264 + 198 + 80 + 80 + + + + + 18 + + + + * + + + * + + + + + + 6 + 112 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 178 + 112 + 80 + 80 + + + + + 18 + + + + ^ + + + ^ + + + + + + 92 + 112 + 80 + 80 + + + + + 18 + + + + +/- + + + + + + 264 + 112 + 80 + 80 + + + + + 18 + + + + / + + + / + + + + + + 12 + 6 + 326 + 100 + + + + + 18 + + + + Qt::LayoutDirection::LeftToRight + + + false + + + 0 + + + + + + 92 + 370 + 80 + 80 + + + + + 18 + + + + 2 + + + 2 + + + + + + 264 + 370 + 80 + 80 + + + + + 18 + + + + + + + + + + + + + + + 178 + 370 + 80 + 80 + + + + + 18 + + + + 3 + + + 3 + + + + + + 6 + 370 + 80 + 80 + + + + + 18 + + + + 1 + + + 1 + + + + + + + 0 + 0 + 350 + 23 + + + + + Calculator + + + + + Programming + + + + + + + + + diff --git a/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui b/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui new file mode 100755 index 0000000..03bce8d --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui @@ -0,0 +1,231 @@ + + + MainWindow + + + + 0 + 0 + 350 + 564 + + + + MainWindow + + + + + + 270 + 110 + 42 + 27 + + + + 2 + + + 36 + + + 10 + + + + + + 100 + 110 + 113 + 26 + + + + + + + 100 + 150 + 113 + 26 + + + + + + + 120 + 250 + 58 + 18 + + + + TextLabel + + + + + + 270 + 150 + 42 + 27 + + + + 2 + + + 36 + + + 10 + + + + + + 260 + 80 + 58 + 18 + + + + TextLabel + + + + + + 260 + 240 + 42 + 27 + + + + 2 + + + 36 + + + 10 + + + + + + 10 + 290 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 110 + 290 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 200 + 290 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 290 + 290 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + + 0 + 0 + 350 + 23 + + + + + Calculator + + + + + Programming + + + + + + + + + + diff --git a/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui.autosave b/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui.autosave new file mode 100755 index 0000000..c6b516d --- /dev/null +++ b/Third term/Industrial programming technologies/1_Calculator/programmingwindow.ui.autosave @@ -0,0 +1,228 @@ + + + MainWindow + + + + 0 + 0 + 350 + 564 + + + + MainWindow + + + + + + 261 + 110 + 51 + 21 + + + + 2 + + + 36 + + + 10 + + + + + + 100 + 110 + 113 + 26 + + + + + + + 12 + 150 + 231 + 71 + + + + + + + 260 + 150 + 71 + 71 + + + + + 18 + + + + 2 + + + 36 + + + 10 + + + + + + 260 + 80 + 58 + 18 + + + + TextLabel + + + + + + 0 + 360 + 80 + 80 + + + + + 18 + + + + + + + + Backspace + + + + + + 90 + 360 + 80 + 80 + + + + + 18 + + + + - + + + Backspace + + + + + + 180 + 360 + 80 + 80 + + + + + 18 + + + + / + + + Backspace + + + + + + 270 + 360 + 80 + 80 + + + + + 18 + + + + = + + + Backspace + + + + + + 12 + 250 + 326 + 100 + + + + + 18 + + + + Qt::LayoutDirection::LeftToRight + + + false + + + 0 + + + + + + + 0 + 0 + 350 + 23 + + + + + Calculator + + + + + Programming + + + + + + + + + + diff --git a/Third term/Industrial programming technologies/Calculator/CMakeLists.txt b/Third term/Industrial programming technologies/Calculator/CMakeLists.txt new file mode 100755 index 0000000..7734c0e --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/CMakeLists.txt @@ -0,0 +1,70 @@ +cmake_minimum_required(VERSION 3.16) + +project(Calculator VERSION 0.1 LANGUAGES CXX) + +set(CMAKE_AUTOUIC ON) +set(CMAKE_AUTOMOC ON) +set(CMAKE_AUTORCC ON) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets) +find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets) + +set(PROJECT_SOURCES + main.cpp + calculator.cpp + calculator.h + calculator.ui +) + +if(${QT_VERSION_MAJOR} GREATER_EQUAL 6) + qt_add_executable(Calculator + MANUAL_FINALIZATION + ${PROJECT_SOURCES} + ) +# Define target properties for Android with Qt 6 as: +# set_property(TARGET Calculator APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR +# ${CMAKE_CURRENT_SOURCE_DIR}/android) +# For more information, see https://doc.qt.io/qt-6/qt-add-executable.html#target-creation +else() + if(ANDROID) + add_library(Calculator SHARED + ${PROJECT_SOURCES} + ) +# Define properties for Android with Qt 5 after find_package() calls as: +# set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android") + else() + add_executable(Calculator + ${PROJECT_SOURCES} + ) + endif() +endif() + +target_link_libraries(Calculator PRIVATE Qt${QT_VERSION_MAJOR}::Widgets) + +# Qt for iOS sets MACOSX_BUNDLE_GUI_IDENTIFIER automatically since Qt 6.1. +# If you are developing for iOS or macOS you should consider setting an +# explicit, fixed bundle identifier manually though. +if(${QT_VERSION} VERSION_LESS 6.1.0) + set(BUNDLE_ID_OPTION MACOSX_BUNDLE_GUI_IDENTIFIER com.example.Calculator) +endif() +set_target_properties(Calculator PROPERTIES + ${BUNDLE_ID_OPTION} + MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION} + MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + MACOSX_BUNDLE TRUE + WIN32_EXECUTABLE TRUE +) + +include(GNUInstallDirs) +install(TARGETS Calculator + BUNDLE DESTINATION . + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} +) + +if(QT_VERSION_MAJOR EQUAL 6) + qt_finalize_executable(Calculator) +endif() diff --git a/Third term/Industrial programming technologies/Calculator/CMakeLists.txt.user b/Third term/Industrial programming technologies/Calculator/CMakeLists.txt.user new file mode 100755 index 0000000..4fd5451 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/CMakeLists.txt.user @@ -0,0 +1,419 @@ + + + + + + EnvironmentId + {7e7f6dcd-a295-45ed-b19b-9b7fbc97cb2b} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + 0 + false + true + false + 2 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + false + + + 0 + true + + true + true + Builtin.DefaultTidyAndClazy + 5 + true + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Qt for macOS + Qt for macOS + qt.qt6.672.clang_64_kit + 0 + 0 + 0 + + Debug + 2 + false + + -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_BUILD_TYPE:STRING=Debug +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +%{CMAKE_OSX_ARCHITECTURES:DefaultFlag} + /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug + + + + + all + + false + + true + Build + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + Build + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Debug + CMakeProjectManager.CMakeBuildConfiguration + + + Release + 2 + false + + -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_BUILD_TYPE:STRING=Release +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +%{CMAKE_OSX_ARCHITECTURES:DefaultFlag} + /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Release + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release + CMakeProjectManager.CMakeBuildConfiguration + + + RelWithDebInfo + 2 + false + + -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +%{CMAKE_OSX_ARCHITECTURES:DefaultFlag} + /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-RelWithDebInfo + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release with Debug Information + CMakeProjectManager.CMakeBuildConfiguration + + + RelWithDebInfo + 2 + false + + -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +%{CMAKE_OSX_ARCHITECTURES:DefaultFlag} + 0 + /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Profile + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Profile + CMakeProjectManager.CMakeBuildConfiguration + + + MinSizeRel + 2 + false + + -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_BUILD_TYPE:STRING=MinSizeRel +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake +%{CMAKE_OSX_ARCHITECTURES:DefaultFlag} + /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-MinSizeRel + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Minimum Size Release + CMakeProjectManager.CMakeBuildConfiguration + + 5 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + 0 + true + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + ProjectExplorer.CustomExecutableRunConfiguration + + false + true + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/cache-v2 b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/cache-v2 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/cmakeFiles-v1 b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/cmakeFiles-v1 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/codemodel-v2 b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.cmake/api/v1/query/codemodel-v2 new file mode 100755 index 0000000..e69de29 diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/LICENSE.conan b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/LICENSE.conan new file mode 100755 index 0000000..541f5a3 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/LICENSE.conan @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/auto-setup.cmake b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/auto-setup.cmake new file mode 100755 index 0000000..628b69c --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/auto-setup.cmake @@ -0,0 +1,269 @@ +# +# Internal Qt Creator variable reference +# +foreach(qtcreator_var + QT_QMAKE_EXECUTABLE CMAKE_PREFIX_PATH CMAKE_C_COMPILER CMAKE_CXX_COMPILER + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO) + set(__just_reference_${qtcreator_var} ${${qtcreator_var}}) +endforeach() + +if (EXISTS "${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake") + include("${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake") +endif() + +if (QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP) + return() +endif() +option(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP "Skip Qt Creator's package manager auto-setup" OFF) + +# Store the C/C++ object output extension +if (CMAKE_VERSION GREATER_EQUAL "3.19") + cmake_language(DEFER CALL set CMAKE_C_OUTPUT_EXTENSION "${CMAKE_C_OUTPUT_EXTENSION}" CACHE STRING "" FORCE) + cmake_language(DEFER CALL set CMAKE_CXX_OUTPUT_EXTENSION "${CMAKE_CXX_OUTPUT_EXTENSION}" CACHE STRING "" FORCE) +endif() + +macro(qtc_auto_setup_compiler_standard toolchainFile) + foreach(lang_var C CXX CUDA OBJC OBJCXX) + foreach(prop_var STANDARD STANDARD_REQUIRED EXTENSIONS) + if (CMAKE_${lang_var}_${prop_var}) + file(APPEND "${toolchainFile}" + "set(CMAKE_${lang_var}_${prop_var} ${CMAKE_${lang_var}_${prop_var}})\n") + endif() + endforeach() + endforeach() + + # Forward important CMake variables to the package manager in the toolchain file + foreach(fwd_var CMAKE_MSVC_RUNTIME_LIBRARY CMAKE_SYSROOT CMAKE_OSX_SYSROOT CMAKE_OSX_ARCHITECTURES) + if (${fwd_var}) + file(APPEND "${toolchainFile}" + "set(${fwd_var} ${${fwd_var}})\n") + endif() + endforeach() +endmacro() + +# +# conan +# +macro(qtc_auto_setup_conan) + foreach(file conanfile.txt conanfile.py) + if (EXISTS "${CMAKE_SOURCE_DIR}/${file}") + set(conanfile_txt "${CMAKE_SOURCE_DIR}/${file}") + break() + endif() + endforeach() + + if (conanfile_txt AND NOT QT_CREATOR_SKIP_CONAN_SETUP) + option(QT_CREATOR_SKIP_CONAN_SETUP "Skip Qt Creator's conan package manager auto-setup" OFF) + set(QT_CREATOR_CONAN_BUILD_POLICY "missing" CACHE STRING "Qt Creator's conan package manager auto-setup build policy. This is used for the BUILD property of cmake_conan_run") + + find_program(conan_program conan) + if (NOT conan_program) + message(WARNING "Qt Creator: conan executable not found. " + "Package manager auto-setup will be skipped. " + "To disable this warning set QT_CREATOR_SKIP_CONAN_SETUP to ON.") + return() + endif() + execute_process(COMMAND ${conan_program} --version + RESULT_VARIABLE result_code + OUTPUT_VARIABLE conan_version_output + ERROR_VARIABLE conan_version_output) + if (NOT result_code EQUAL 0) + message(FATAL_ERROR "conan --version failed='${result_code}: ${conan_version_output}") + endif() + + string(REGEX REPLACE ".*Conan version ([0-9].[0-9]).*" "\\1" conan_version "${conan_version_output}") + + set(conanfile_timestamp_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.timestamp") + file(TIMESTAMP "${conanfile_txt}" conanfile_timestamp) + + set(do_conan_installation ON) + if (EXISTS "${conanfile_timestamp_file}") + file(READ "${conanfile_timestamp_file}" old_conanfile_timestamp) + if ("${conanfile_timestamp}" STREQUAL "${old_conanfile_timestamp}") + set(do_conan_installation OFF) + endif() + endif() + + set(conanfile_build_policy_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.buildpolicy") + if (EXISTS "${conanfile_build_policy_file}") + file(READ "${conanfile_build_policy_file}" build_policy) + if (NOT "${build_policy}" STREQUAL "${QT_CREATOR_CONAN_BUILD_POLICY}") + set(do_conan_installation ON) + endif() + endif() + + if (do_conan_installation) + message(STATUS "Qt Creator: conan package manager auto-setup. " + "Skip this step by setting QT_CREATOR_SKIP_CONAN_SETUP to ON.") + + file(COPY "${conanfile_txt}" DESTINATION "${CMAKE_BINARY_DIR}/conan-dependencies/") + + file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" " + set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\") + set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\") + ") + qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake") + + if (CMAKE_TOOLCHAIN_FILE) + file(APPEND "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" + "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n") + endif() + + file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/CMakeLists.txt" " + cmake_minimum_required(VERSION 3.15) + + unset(CMAKE_PROJECT_INCLUDE_BEFORE CACHE) + project(conan-setup) + + if (${conan_version} VERSION_GREATER_EQUAL 2.0) + set(CONAN_COMMAND \"${conan_program}\") + include(\"${CMAKE_CURRENT_LIST_DIR}/conan_provider.cmake\") + conan_profile_detect_default() + detect_host_profile(\"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\") + + set(build_types \${CMAKE_BUILD_TYPE}) + if (CMAKE_CONFIGURATION_TYPES) + set(build_types \${CMAKE_CONFIGURATION_TYPES}) + endif() + + foreach(type \${build_types}) + conan_install( + -pr \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\" + --build=${QT_CREATOR_CONAN_BUILD_POLICY} + -s build_type=\${type} + -g CMakeDeps) + endforeach() + + get_property(CONAN_INSTALL_SUCCESS GLOBAL PROPERTY CONAN_INSTALL_SUCCESS) + if (CONAN_INSTALL_SUCCESS) + get_property(CONAN_GENERATORS_FOLDER GLOBAL PROPERTY CONAN_GENERATORS_FOLDER) + file(TO_CMAKE_PATH \"\${CONAN_GENERATORS_FOLDER}\" CONAN_GENERATORS_FOLDER) + file(WRITE \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake\" \" + list(PREPEND CMAKE_PREFIX_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(PREPEND CMAKE_MODULE_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(PREPEND CMAKE_FIND_ROOT_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\") + list(REMOVE_DUPLICATES CMAKE_PREFIX_PATH) + list(REMOVE_DUPLICATES CMAKE_MODULE_PATH) + list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH) + set(CMAKE_PREFIX_PATH \\\"\\\${CMAKE_PREFIX_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + set(CMAKE_MODULE_PATH \\\"\\\${CMAKE_MODULE_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + set(CMAKE_FIND_ROOT_PATH \\\"\\\${CMAKE_FIND_ROOT_PATH}\\\" CACHE STRING \\\"\\\" FORCE) + \") + endif() + else() + include(\"${CMAKE_CURRENT_LIST_DIR}/conan.cmake\") + conan_cmake_run( + CONANFILE \"${conanfile_txt}\" + INSTALL_FOLDER \"${CMAKE_BINARY_DIR}/conan-dependencies\" + GENERATORS cmake_paths cmake_find_package json + BUILD ${QT_CREATOR_CONAN_BUILD_POLICY} + ENV CONAN_CMAKE_TOOLCHAIN_FILE=\"${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake\" + ) + endif() + ") + + if (NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES) + set(CMAKE_CONFIGURATION_TYPES "Debug;Release") + endif() + + execute_process(COMMAND ${CMAKE_COMMAND} + -S "${CMAKE_BINARY_DIR}/conan-dependencies/" + -B "${CMAKE_BINARY_DIR}/conan-dependencies/build" + -C "${CMAKE_BINARY_DIR}/qtcsettings.cmake" + -D "CMAKE_TOOLCHAIN_FILE=${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" + -G ${CMAKE_GENERATOR} + -D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -D "CMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}" + RESULT_VARIABLE result + ) + if (result EQUAL 0) + file(WRITE "${conanfile_timestamp_file}" "${conanfile_timestamp}") + file(WRITE "${conanfile_build_policy_file}" ${QT_CREATOR_CONAN_BUILD_POLICY}) + else() + message(WARNING "Qt Creator's conan package manager auto-setup failed. Consider setting " + "QT_CREATOR_SKIP_CONAN_SETUP to ON and reconfigure to skip this step.") + return() + endif() + endif() + + include("${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake") + endif() + unset(conanfile_txt) +endmacro() +qtc_auto_setup_conan() + +# +# vcpkg +# +macro(qtc_auto_setup_vcpkg) + if (EXISTS "${CMAKE_SOURCE_DIR}/vcpkg.json" AND NOT QT_CREATOR_SKIP_VCPKG_SETUP) + option(QT_CREATOR_SKIP_VCPKG_SETUP "Skip Qt Creator's vcpkg package manager auto-setup" OFF) + + find_program(vcpkg_program vcpkg $ENV{VCPKG_ROOT} ${CMAKE_SOURCE_DIR}/vcpkg) + if (NOT vcpkg_program) + message(WARNING "Qt Creator: vcpkg executable not found. " + "Package manager auto-setup will be skipped. " + "To disable this warning set QT_CREATOR_SKIP_VCPKG_SETUP to ON.") + return() + endif() + execute_process(COMMAND ${vcpkg_program} version + RESULT_VARIABLE result_code + OUTPUT_VARIABLE vcpkg_version_output + ERROR_VARIABLE vcpkg_version_output) + if (NOT result_code EQUAL 0) + message(FATAL_ERROR "vcpkg version failed='${result_code}: ${vcpkg_version_output}") + endif() + + # Resolve any symlinks + get_filename_component(vpkg_program_real_path ${vcpkg_program} REALPATH) + get_filename_component(vpkg_root ${vpkg_program_real_path} DIRECTORY) + + if (NOT EXISTS "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + message(STATUS "Qt Creator: vcpkg package manager auto-setup. " + "Skip this step by setting QT_CREATOR_SKIP_VCPKG_SETUP to ON.") + + file(WRITE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" " + set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\") + set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\") + ") + qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + + if (CMAKE_TOOLCHAIN_FILE AND NOT + CMAKE_TOOLCHAIN_FILE STREQUAL "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake") + file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" + "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n") + endif() + + if (VCPKG_TARGET_TRIPLET) + set(vcpkg_triplet ${VCPKG_TARGET_TRIPLET}) + else() + if (WIN32) + set(vcpkg_triplet x64-mingw-static) + if (CMAKE_CXX_COMPILER MATCHES ".*/(.*)/cl.exe") + set(vcpkg_triplet ${CMAKE_MATCH_1}-windows) + endif() + elseif(APPLE) + set(vcpkg_triplet x64-osx) + else() + set(vcpkg_triplet x64-linux) + endif() + endif() + + file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" " + set(VCPKG_TARGET_TRIPLET ${vcpkg_triplet}) + include(\"${vpkg_root}/scripts/buildsystems/vcpkg.cmake\") + ") + endif() + + set(CMAKE_TOOLCHAIN_FILE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" CACHE PATH "" FORCE) + + # Save CMAKE_PREFIX_PATH and CMAKE_MODULE_PATH as cache variables + if (CMAKE_VERSION GREATER_EQUAL "3.19") + cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_PREFIX_PATH) + cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_MODULE_PATH) + cmake_language(DEFER CALL set CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}" CACHE STRING "" FORCE) + cmake_language(DEFER CALL set CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" CACHE STRING "" FORCE) + endif() + endif() +endmacro() +qtc_auto_setup_vcpkg() diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan.cmake b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan.cmake new file mode 100755 index 0000000..4f5f67e --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan.cmake @@ -0,0 +1,1026 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 JFrog + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + + +# This file comes from: https://github.com/conan-io/cmake-conan. Please refer +# to this repository for issues and documentation. + +# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called. +# It will take CMake current settings (os, compiler, compiler version, architecture) +# and translate them to conan settings for installing and retrieving dependencies. + +# It is intended to facilitate developers building projects that have conan dependencies, +# but it is only necessary on the end-user side. It is not necessary to create conan +# packages, in fact it shouldn't be use for that. Check the project documentation. + +# version: 0.18.1 + +include(CMakeParseArguments) + +function(_get_msvc_ide_version result) + set(${result} "" PARENT_SCOPE) + if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500) + set(${result} 8 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600) + set(${result} 9 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700) + set(${result} 10 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800) + set(${result} 11 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900) + set(${result} 12 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910) + set(${result} 14 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920) + set(${result} 15 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930) + set(${result} 16 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940) + set(${result} 17 PARENT_SCOPE) + else() + message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]") + endif() +endfunction() + +macro(_conan_detect_build_type) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE}) + elseif(CMAKE_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE}) + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER) + if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG") + set(_CONAN_SETTING_BUILD_TYPE "Debug") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE") + set(_CONAN_SETTING_BUILD_TYPE "Release") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO") + set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL") + set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel") + endif() +endmacro() + +macro(_conan_check_system_name) + #handle -s os setting + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + #use default conan os setting if CMAKE_SYSTEM_NAME is not defined + set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set(CONAN_SYSTEM_NAME Macos) + endif() + if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX") + set(CONAN_SYSTEM_NAME Neutrino) + endif() + set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino) + list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index) + if (${_index} GREATER -1) + #check if the cmake system is a conan supported one + set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME}) + else() + message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}") + endif() + endif() +endmacro() + +macro(_conan_check_language) + get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES) + if (";${_languages};" MATCHES ";CXX;") + set(LANGUAGE CXX) + set(USING_CXX 1) + elseif (";${_languages};" MATCHES ";C;") + set(LANGUAGE C) + set(USING_CXX 0) + else () + message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.") + endif() +endmacro() + +macro(_conan_detect_compiler) + + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_ARCH) + set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH}) + endif() + + if(USING_CXX) + set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD}) + endif() + + if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU) + # using GCC + # TODO: Handle other params + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + if(${MAJOR} GREATER 4) + set(COMPILER_VERSION ${MAJOR}) + endif() + set(_CONAN_SETTING_COMPILER gcc) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + set(_CONAN_SETTING_COMPILER intel) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang) + # using AppleClang + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER apple-clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang + AND NOT "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" + AND NOT "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC") + + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if(APPLE) + cmake_policy(GET CMP0025 APPLE_CLANG_POLICY) + if(NOT APPLE_CLANG_POLICY STREQUAL NEW) + message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it") + set(_CONAN_SETTING_COMPILER apple-clang) + endif() + endif() + if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}) + endif() + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC + OR (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang + AND "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" + AND "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC")) + + set(_VISUAL "Visual Studio") + _get_msvc_ide_version(_VISUAL_VERSION) + if("${_VISUAL_VERSION}" STREQUAL "") + message(FATAL_ERROR "Conan: Visual Studio not recognized") + else() + set(_CONAN_SETTING_COMPILER ${_VISUAL}) + set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION}) + endif() + + if(NOT _CONAN_SETTING_ARCH) + if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64") + set(_CONAN_SETTING_ARCH x86_64) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM") + message(STATUS "Conan: Using default ARM architecture from MSVC") + set(_CONAN_SETTING_ARCH armv6) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86") + set(_CONAN_SETTING_ARCH x86) + else () + message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]") + endif() + endif() + + conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV}) + message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}") + set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime}) + + if (CMAKE_GENERATOR_TOOLSET) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja")) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + endif() + else() + message(FATAL_ERROR "Conan: compiler setup not recognized") + endif() + +endmacro() + +function(conan_cmake_settings result) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER}) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID}) + #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION}) + #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS}) + #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE}) + #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE}) + #message(STATUS "GENERATOR " ${CMAKE_GENERATOR}) + #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64}) + + message(STATUS "Conan: Automatic detection of conan settings from cmake") + + conan_parse_arguments(${ARGV}) + + _conan_detect_build_type(${ARGV}) + + _conan_check_system_name() + + _conan_check_language() + + _conan_detect_compiler(${ARGV}) + + # If profile is defined it is used + if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE}) + elseif(ARGUMENTS_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE}) + endif() + + foreach(ARG ${_APPLIED_PROFILES}) + set(_SETTINGS ${_SETTINGS} -pr=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_PROFILE_BUILD}) + conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET) + set(_SETTINGS ${_SETTINGS} -pr:b=${ARG}) + endforeach() + + if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL") + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset) + endif() + + # remove any manually specified settings from the autodetected settings + foreach(ARG ${ARGUMENTS_SETTINGS}) + string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}") + message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.") + list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}") + endforeach() + + # Automatic from CMake + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + + foreach(ARG ${ARGUMENTS_SETTINGS}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}) + endforeach() + + message(STATUS "Conan: Settings= ${_SETTINGS}") + + set(${result} ${_SETTINGS} PARENT_SCOPE) +endfunction() + + +function(conan_cmake_detect_unix_libcxx result) + # Take into account any -stdlib in compile options + get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) + string(GENEX_STRIP "${compile_options}" compile_options) + + # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions + get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) + string(GENEX_STRIP "${defines}" defines) + + foreach(define ${defines}) + if(define MATCHES "_GLIBCXX_USE_CXX11_ABI") + if(define MATCHES "^-D") + set(compile_options ${compile_options} "${define}") + else() + set(compile_options ${compile_options} "-D${define}") + endif() + endif() + endforeach() + + # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable + set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER}) + if(CMAKE_CXX_COMPILER_ARG1) + # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz" + # without this, ccache, winegcc, or other wrappers might lose all their arguments + separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1}) + list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1}) + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET) + # without --target= we may be calling the wrong underlying GCC + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT) + # without --sysroot= we may find the wrong #include + if(CMAKE_SYSROOT_COMPILE) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}") + elseif(CMAKE_SYSROOT) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}") + endif() + endif() + + separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + + if(CMAKE_OSX_SYSROOT) + set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}") + endif() + + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo "#include " + COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM - + OUTPUT_VARIABLE string_defines + ) + + if(string_defines MATCHES "#define __GLIBCXX__") + # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake + if(DEFINED _GLIBCXX_USE_CXX11_ABI) + if(_GLIBCXX_USE_CXX11_ABI) + set(${result} libstdc++11 PARENT_SCOPE) + return() + else() + set(${result} libstdc++ PARENT_SCOPE) + return() + endif() + endif() + + if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n") + set(${result} libstdc++11 PARENT_SCOPE) + else() + # Either the compiler is missing the define because it is old, and so + # it can't use the new abi, or the compiler was configured to use the + # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS) + set(${result} libstdc++ PARENT_SCOPE) + endif() + else() + set(${result} libc++ PARENT_SCOPE) + endif() +endfunction() + +function(conan_cmake_detect_vs_runtime result) + + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_BUILD_TYPE) + set(build_type "${ARGUMENTS_BUILD_TYPE}") + elseif(CMAKE_BUILD_TYPE) + set(build_type "${CMAKE_BUILD_TYPE}") + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + if(build_type) + string(TOUPPER "${build_type}" build_type) + endif() + set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS) + foreach(variable ${variables}) + if(NOT "${${variable}}" STREQUAL "") + string(REPLACE " " ";" flags "${${variable}}") + foreach (flag ${flags}) + if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd") + string(SUBSTRING "${flag}" 1 -1 runtime) + set(${result} "${runtime}" PARENT_SCOPE) + return() + endif() + endforeach() + endif() + endforeach() + if("${build_type}" STREQUAL "DEBUG") + set(${result} "MDd" PARENT_SCOPE) + else() + set(${result} "MD" PARENT_SCOPE) + endif() +endfunction() + +function(_collect_settings result) + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset + compiler.cppstd) + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + set(${result} ${detected_setings} PARENT_SCOPE) +endfunction() + +function(conan_cmake_autodetect detected_settings) + _conan_detect_build_type(${ARGV}) + _conan_check_system_name() + _conan_check_language() + _conan_detect_compiler(${ARGV}) + _collect_settings(collected_settings) + set(${detected_settings} ${collected_settings} PARENT_SCOPE) +endfunction() + +macro(conan_parse_arguments) + set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD) + set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER OUTPUT_FOLDER CONAN_COMMAND) + set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE + PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO + INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES) + cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) +endmacro() + +function(old_conan_cmake_install) + # Calls "conan install" + # Argument BUILD is equivalant to --build={missing, PkgName,...} or + # --build when argument is 'BUILD all' (which builds all packages from source) + # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source + # cmake does not identify conan as command, even if it is +x and it is in the path + conan_parse_arguments(${ARGV}) + + if(CONAN_CMAKE_MULTI) + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi) + else() + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake) + endif() + + set(CONAN_BUILD_POLICY "") + foreach(ARG ${ARGUMENTS_BUILD}) + if(${ARG} STREQUAL "all") + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build) + break() + else() + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG}) + endif() + endforeach() + if(ARGUMENTS_CONAN_COMMAND) + set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + set(CONAN_OPTIONS "") + if(ARGUMENTS_CONANFILE) + if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE}) + set(CONANFILE ${ARGUMENTS_CONANFILE}) + else() + set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE}) + endif() + else() + set(CONANFILE ".") + endif() + foreach(ARG ${ARGUMENTS_OPTIONS}) + set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG}) + endforeach() + if(ARGUMENTS_UPDATE) + set(CONAN_INSTALL_UPDATE --update) + endif() + if(ARGUMENTS_NO_IMPORTS) + set(CONAN_INSTALL_NO_IMPORTS --no-imports) + endif() + set(CONAN_INSTALL_FOLDER "") + if(ARGUMENTS_INSTALL_FOLDER) + set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER}) + endif() + set(CONAN_OUTPUT_FOLDER "") + if(ARGUMENTS_OUTPUT_FOLDER) + set(CONAN_OUTPUT_FOLDER -of=${ARGUMENTS_OUTPUT_FOLDER}) + endif() + foreach(ARG ${ARGUMENTS_GENERATORS}) + set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_ENV}) + set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG}) + endforeach() + set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS}) + + string (REPLACE ";" " " _conan_args "${conan_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}") + + if(ARGUMENTS_OUTPUT_QUIET) + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_output + ERROR_VARIABLE conan_output + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + else() + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + +endfunction() + +function(conan_cmake_install) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET) + set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER OUTPUT_FOLDER) + set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) + cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN}) + foreach(arg ${installOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID") + set(flag "--lockfile-node-id") + elseif("${arg}" STREQUAL "INSTALL_FOLDER") + set(flag "--install-folder") + elseif("${arg}" STREQUAL "OUTPUT_FOLDER") + set(flag "--output-folder") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "GENERATOR") + set(flag "--generator") + elseif("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED NO_IMPORTS) + set(NO_IMPORTS --no-imports) + endif() + set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} ${OUTPUT_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) + + string(REPLACE ";" " " _install_args "${install_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${install_args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan install failed='${return_code}'") + else() + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + endif() + +endfunction() + +function(conan_cmake_lock_create) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(lockCreateOptions UPDATE BASE OUTPUT_QUIET ERROR_QUIET) + set(lockCreateOneValueArgs PATH REFERENCE REMOTE LOCKFILE LOCKFILE_OUT) + set(lockCreateMultiValueArgs BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) + cmake_parse_arguments(ARGS "${lockCreateOptions}" "${lockCreateOneValueArgs}" "${lockCreateMultiValueArgs}" ${ARGN}) + foreach(arg ${lockCreateOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${lockCreateOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${lockCreateMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED BASE) + set(BASE --base) + endif() + set(lock_create_Args lock create ${PATH} ${REFERENCE} ${UPDATE} ${BASE} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) + + string(REPLACE ";" " " _lock_create_Args "${lock_create_Args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_lock_create_Args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${lock_create_Args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan lock create failed='${return_code}'") + else() + message(FATAL_ERROR "Conan lock create failed='${return_code}'") + endif() + endif() +endfunction() + +function(conan_cmake_setup_conanfile) + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_CONANFILE) + get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME) + # configure_file will make sure cmake re-runs when conanfile is updated + configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY) + file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk) + else() + conan_cmake_generate_conanfile(ON ${ARGV}) + endif() +endfunction() + +function(conan_cmake_configure) + conan_cmake_generate_conanfile(OFF ${ARGV}) +endfunction() + +# Generate, writing in disk a conanfile.txt with the requires, options, and imports +# specified as arguments +# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR) +function(conan_cmake_generate_conanfile DEFAULT_GENERATOR) + + conan_parse_arguments(${ARGV}) + + set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt") + file(WRITE ${_FN} "") + + if(DEFINED ARGUMENTS_REQUIRES) + file(APPEND ${_FN} "[requires]\n") + foreach(REQUIRE ${ARGUMENTS_REQUIRES}) + file(APPEND ${_FN} ${REQUIRE} "\n") + endforeach() + endif() + + if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS) + file(APPEND ${_FN} "[generators]\n") + if (DEFAULT_GENERATOR) + file(APPEND ${_FN} "cmake\n") + endif() + if (DEFINED ARGUMENTS_GENERATORS) + foreach(GENERATOR ${ARGUMENTS_GENERATORS}) + file(APPEND ${_FN} ${GENERATOR} "\n") + endforeach() + endif() + endif() + + if(DEFINED ARGUMENTS_BUILD_REQUIRES) + file(APPEND ${_FN} "[build_requires]\n") + foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES}) + file(APPEND ${_FN} ${BUILD_REQUIRE} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_IMPORTS) + file(APPEND ${_FN} "[imports]\n") + foreach(IMPORTS ${ARGUMENTS_IMPORTS}) + file(APPEND ${_FN} ${IMPORTS} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_OPTIONS) + file(APPEND ${_FN} "[options]\n") + foreach(OPTION ${ARGUMENTS_OPTIONS}) + file(APPEND ${_FN} ${OPTION} "\n") + endforeach() + endif() + +endfunction() + + +macro(conan_load_buildinfo) + if(CONAN_CMAKE_MULTI) + set(_CONANBUILDINFO conanbuildinfo_multi.cmake) + else() + set(_CONANBUILDINFO conanbuildinfo.cmake) + endif() + if(ARGUMENTS_INSTALL_FOLDER) + set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER}) + else() + set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR}) + endif() + # Checks for the existence of conanbuildinfo.cmake, and loads it + # important that it is macro, so variables defined at parent scope + if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}") + message(STATUS "Conan: Loading ${_CONANBUILDINFO}") + include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}) + else() + message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}") + endif() +endmacro() + + +macro(conan_cmake_run) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES) + message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators") + elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE) + message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.") + endif() + + if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED + AND NOT ARGUMENTS_BUILD_TYPE) + set(CONAN_CMAKE_MULTI ON) + if (NOT ARGUMENTS_CONFIGURATION_TYPES) + set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug") + endif() + message(STATUS "Conan: Using cmake-multi generator") + else() + set(CONAN_CMAKE_MULTI OFF) + endif() + + if(NOT CONAN_EXPORTED) + conan_cmake_setup_conanfile(${ARGV}) + if(CONAN_CMAKE_MULTI) + foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES}) + set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE}) + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endforeach() + set(CMAKE_BUILD_TYPE) + else() + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endif() + endif() + + if (NOT ARGUMENTS_NO_LOAD) + conan_load_buildinfo() + endif() + + if(ARGUMENTS_BASIC_SETUP) + foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD) + if(ARGUMENTS_${_option}) + if(${_option} STREQUAL "CMAKE_TARGETS") + list(APPEND _setup_options "TARGETS") + else() + list(APPEND _setup_options ${_option}) + endif() + endif() + endforeach() + conan_basic_setup(${_setup_options}) + endif() +endmacro() + +macro(conan_check) + # Checks conan availability in PATH + # Arguments REQUIRED, DETECT_QUIET and VERSION are optional + # Example usage: + # conan_check(VERSION 1.0.0 REQUIRED) + set(options REQUIRED DETECT_QUIET) + set(oneValueArgs VERSION) + cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN}) + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: checking conan executable") + endif() + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found! Please install conan.") + endif() + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: Found program ${CONAN_CMD}") + endif() + execute_process(COMMAND ${CONAN_CMD} --version + RESULT_VARIABLE return_code + OUTPUT_VARIABLE CONAN_VERSION_OUTPUT + ERROR_VARIABLE CONAN_VERSION_OUTPUT) + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan --version failed='${return_code}'") + endif() + + if(NOT CONAN_DETECT_QUIET) + string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT) + message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}") + endif() + + if(DEFINED CONAN_VERSION) + string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO + "${CONAN_VERSION_OUTPUT}") + if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION}) + message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \ + required: ${CONAN_VERSION}. Consider updating via 'pip \ + install conan==${CONAN_VERSION}'.") + endif() + endif() +endmacro() + +function(conan_add_remote) + # Adds a remote + # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional + # Example usage: + # conan_add_remote(NAME bincrafters INDEX 1 + # URL https://api.bintray.com/conan/bincrafters/public-conan + # VERIFY_SSL True) + set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN}) + + if(DEFINED CONAN_INDEX) + set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}") + endif() + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED DETECT_QUIET) + endif() + set(CONAN_VERIFY_SSL_ARG "True") + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL}) + endif() + message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})") + execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan remote failed='${return_code}'") + endif() +endfunction() + +macro(conan_config_install) + # install a full configuration from a local or remote zip file + # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional + # Example usage: + # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git + # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false) + set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL) + set(multiValueArgs ARGS) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}") + endif() + + if(DEFINED CONAN_TYPE) + set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}") + endif() + + if(DEFINED CONAN_ARGS) + set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"") + endif() + + if(DEFINED CONAN_SOURCE) + set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}") + endif() + + if(DEFINED CONAN_TARGET) + set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}") + endif() + + set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG} + ${CONAN_TYPE_ARG} + ${CONAN_ARGS_ARGS} + ${CONAN_SOURCE_ARGS} + ${CONAN_TARGET_ARGS}) + + message(STATUS "Conan: Installing config from ${CONAN_ITEM}") + execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan config failed='${return_code}'") + endif() +endmacro() diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan_provider.cmake b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan_provider.cmake new file mode 100755 index 0000000..e5fa9ce --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/conan_provider.cmake @@ -0,0 +1,655 @@ +# https://github.com/conan-io/cmake-conan/blob/develop2/conan_provider.cmake +# commit: f6464d1e13ef7a47c569f5061f9607ea63339d39 +# +# The MIT License (MIT) +# +# Copyright (c) 2019 JFrog +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +set(CONAN_MINIMUM_VERSION 2.0.5) + + +function(detect_os OS OS_API_LEVEL OS_SDK OS_SUBSYSTEM OS_VERSION) + # it could be cross compilation + message(STATUS "CMake-Conan: cmake_system_name=${CMAKE_SYSTEM_NAME}") + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(${OS} Macos PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX") + set(${OS} Neutrino PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN") + set(${OS} Windows PARENT_SCOPE) + set(${OS_SUBSYSTEM} cygwin PARENT_SCOPE) + elseif(CMAKE_SYSTEM_NAME MATCHES "^MSYS") + set(${OS} Windows PARENT_SCOPE) + set(${OS_SUBSYSTEM} msys2 PARENT_SCOPE) + else() + set(${OS} ${CMAKE_SYSTEM_NAME} PARENT_SCOPE) + endif() + if(CMAKE_SYSTEM_NAME STREQUAL "Android") + if(DEFINED ANDROID_PLATFORM) + string(REGEX MATCH "[0-9]+" _OS_API_LEVEL ${ANDROID_PLATFORM}) + elseif(DEFINED CMAKE_SYSTEM_VERSION) + set(_OS_API_LEVEL ${CMAKE_SYSTEM_VERSION}) + endif() + message(STATUS "CMake-Conan: android api level=${_OS_API_LEVEL}") + set(${OS_API_LEVEL} ${_OS_API_LEVEL} PARENT_SCOPE) + endif() + if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS") + # CMAKE_OSX_SYSROOT contains the full path to the SDK for MakeFile/Ninja + # generators, but just has the original input string for Xcode. + if(NOT IS_DIRECTORY ${CMAKE_OSX_SYSROOT}) + set(_OS_SDK ${CMAKE_OSX_SYSROOT}) + else() + if(CMAKE_OSX_SYSROOT MATCHES Simulator) + set(apple_platform_suffix simulator) + else() + set(apple_platform_suffix os) + endif() + if(CMAKE_OSX_SYSROOT MATCHES AppleTV) + set(_OS_SDK "appletv${apple_platform_suffix}") + elseif(CMAKE_OSX_SYSROOT MATCHES iPhone) + set(_OS_SDK "iphone${apple_platform_suffix}") + elseif(CMAKE_OSX_SYSROOT MATCHES Watch) + set(_OS_SDK "watch${apple_platform_suffix}") + endif() + endif() + if(DEFINED _OS_SDK) + message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}") + set(${OS_SDK} ${_OS_SDK} PARENT_SCOPE) + endif() + if(DEFINED CMAKE_OSX_DEPLOYMENT_TARGET) + message(STATUS "CMake-Conan: cmake_osx_deployment_target=${CMAKE_OSX_DEPLOYMENT_TARGET}") + set(${OS_VERSION} ${CMAKE_OSX_DEPLOYMENT_TARGET} PARENT_SCOPE) + endif() + endif() + endif() +endfunction() + + +function(detect_arch ARCH) + # CMAKE_OSX_ARCHITECTURES can contain multiple architectures, but Conan only supports one. + # Therefore this code only finds one. If the recipes support multiple architectures, the + # build will work. Otherwise, there will be a linker error for the missing architecture(s). + if(DEFINED CMAKE_OSX_ARCHITECTURES) + string(REPLACE " " ";" apple_arch_list "${CMAKE_OSX_ARCHITECTURES}") + list(LENGTH apple_arch_list apple_arch_count) + if(apple_arch_count GREATER 1) + message(WARNING "CMake-Conan: Multiple architectures detected, this will only work if Conan recipe(s) produce fat binaries.") + endif() + endif() + if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS" AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "") + set(host_arch ${CMAKE_OSX_ARCHITECTURES}) + elseif(MSVC) + set(host_arch ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}) + else() + set(host_arch ${CMAKE_SYSTEM_PROCESSOR}) + endif() + if(host_arch MATCHES "aarch64|arm64|ARM64") + set(_ARCH armv8) + elseif(host_arch MATCHES "armv7|armv7-a|armv7l|ARMV7") + set(_ARCH armv7) + elseif(host_arch MATCHES armv7s) + set(_ARCH armv7s) + elseif(host_arch MATCHES "i686|i386|X86") + set(_ARCH x86) + elseif(host_arch MATCHES "AMD64|amd64|x86_64|x64") + set(_ARCH x86_64) + endif() + message(STATUS "CMake-Conan: cmake_system_processor=${_ARCH}") + set(${ARCH} ${_ARCH} PARENT_SCOPE) +endfunction() + + +function(detect_cxx_standard CXX_STANDARD) + set(${CXX_STANDARD} ${CMAKE_CXX_STANDARD} PARENT_SCOPE) + if(CMAKE_CXX_EXTENSIONS) + set(${CXX_STANDARD} "gnu${CMAKE_CXX_STANDARD}" PARENT_SCOPE) + endif() +endfunction() + + +macro(detect_gnu_libstdcxx) + # _CONAN_IS_GNU_LIBSTDCXX true if GNU libstdc++ + check_cxx_source_compiles(" + #include + #if !defined(__GLIBCXX__) && !defined(__GLIBCPP__) + static_assert(false); + #endif + int main(){}" _CONAN_IS_GNU_LIBSTDCXX) + + # _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI true if C++11 ABI + check_cxx_source_compiles(" + #include + static_assert(sizeof(std::string) != sizeof(void*), \"using libstdc++\"); + int main () {}" _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) + + set(_CONAN_GNU_LIBSTDCXX_SUFFIX "") + if(_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) + set(_CONAN_GNU_LIBSTDCXX_SUFFIX "11") + endif() + unset (_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI) +endmacro() + + +macro(detect_libcxx) + # _CONAN_IS_LIBCXX true if LLVM libc++ + check_cxx_source_compiles(" + #include + #if !defined(_LIBCPP_VERSION) + static_assert(false); + #endif + int main(){}" _CONAN_IS_LIBCXX) +endmacro() + + +function(detect_lib_cxx LIB_CXX) + if(CMAKE_SYSTEM_NAME STREQUAL "Android") + message(STATUS "CMake-Conan: android_stl=${CMAKE_ANDROID_STL_TYPE}") + set(${LIB_CXX} ${CMAKE_ANDROID_STL_TYPE} PARENT_SCOPE) + return() + endif() + + include(CheckCXXSourceCompiles) + + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + detect_gnu_libstdcxx() + set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang") + set(${LIB_CXX} "libc++" PARENT_SCOPE) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows") + # Check for libc++ + detect_libcxx() + if(_CONAN_IS_LIBCXX) + set(${LIB_CXX} "libc++" PARENT_SCOPE) + return() + endif() + + # Check for libstdc++ + detect_gnu_libstdcxx() + if(_CONAN_IS_GNU_LIBSTDCXX) + set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE) + return() + endif() + + # TODO: it would be an error if we reach this point + elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + # Do nothing - compiler.runtime and compiler.runtime_type + # should be handled separately: https://github.com/conan-io/cmake-conan/pull/516 + return() + else() + # TODO: unable to determine, ask user to provide a full profile file instead + endif() +endfunction() + + +function(detect_compiler COMPILER COMPILER_VERSION COMPILER_RUNTIME COMPILER_RUNTIME_TYPE) + if(DEFINED CMAKE_CXX_COMPILER_ID) + set(_COMPILER ${CMAKE_CXX_COMPILER_ID}) + set(_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION}) + else() + if(NOT DEFINED CMAKE_C_COMPILER_ID) + message(FATAL_ERROR "C or C++ compiler not defined") + endif() + set(_COMPILER ${CMAKE_C_COMPILER_ID}) + set(_COMPILER_VERSION ${CMAKE_C_COMPILER_VERSION}) + endif() + + message(STATUS "CMake-Conan: CMake compiler=${_COMPILER}") + message(STATUS "CMake-Conan: CMake compiler version=${_COMPILER_VERSION}") + + if(_COMPILER MATCHES MSVC) + set(_COMPILER "msvc") + string(SUBSTRING ${MSVC_VERSION} 0 3 _COMPILER_VERSION) + # Configure compiler.runtime and compiler.runtime_type settings for MSVC + if(CMAKE_MSVC_RUNTIME_LIBRARY) + set(_msvc_runtime_library ${CMAKE_MSVC_RUNTIME_LIBRARY}) + else() + set(_msvc_runtime_library MultiThreaded$<$:Debug>DLL) # default value documented by CMake + endif() + + set(_KNOWN_MSVC_RUNTIME_VALUES "") + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded MultiThreadedDLL) + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreadedDebug MultiThreadedDebugDLL) + list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded$<$:Debug> MultiThreaded$<$:Debug>DLL) + + # only accept the 6 possible values, otherwise we don't don't know to map this + if(NOT _msvc_runtime_library IN_LIST _KNOWN_MSVC_RUNTIME_VALUES) + message(FATAL_ERROR "CMake-Conan: unable to map MSVC runtime: ${_msvc_runtime_library} to Conan settings") + endif() + + # Runtime is "dynamic" in all cases if it ends in DLL + if(_msvc_runtime_library MATCHES ".*DLL$") + set(_COMPILER_RUNTIME "dynamic") + else() + set(_COMPILER_RUNTIME "static") + endif() + message(STATUS "CMake-Conan: CMake compiler.runtime=${_COMPILER_RUNTIME}") + + # Only define compiler.runtime_type when explicitly requested + # If a generator expression is used, let Conan handle it conditional on build_type + if(NOT _msvc_runtime_library MATCHES ":Debug>") + if(_msvc_runtime_library MATCHES "Debug") + set(_COMPILER_RUNTIME_TYPE "Debug") + else() + set(_COMPILER_RUNTIME_TYPE "Release") + endif() + message(STATUS "CMake-Conan: CMake compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}") + endif() + + unset(_KNOWN_MSVC_RUNTIME_VALUES) + + elseif(_COMPILER MATCHES AppleClang) + set(_COMPILER "apple-clang") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + elseif(_COMPILER MATCHES Clang) + set(_COMPILER "clang") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + elseif(_COMPILER MATCHES GNU) + set(_COMPILER "gcc") + string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION}) + list(GET VERSION_LIST 0 _COMPILER_VERSION) + endif() + + message(STATUS "CMake-Conan: [settings] compiler=${_COMPILER}") + message(STATUS "CMake-Conan: [settings] compiler.version=${_COMPILER_VERSION}") + if (_COMPILER_RUNTIME) + message(STATUS "CMake-Conan: [settings] compiler.runtime=${_COMPILER_RUNTIME}") + endif() + if (_COMPILER_RUNTIME_TYPE) + message(STATUS "CMake-Conan: [settings] compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}") + endif() + + set(${COMPILER} ${_COMPILER} PARENT_SCOPE) + set(${COMPILER_VERSION} ${_COMPILER_VERSION} PARENT_SCOPE) + set(${COMPILER_RUNTIME} ${_COMPILER_RUNTIME} PARENT_SCOPE) + set(${COMPILER_RUNTIME_TYPE} ${_COMPILER_RUNTIME_TYPE} PARENT_SCOPE) +endfunction() + + +function(detect_build_type BUILD_TYPE) + get_property(_MULTICONFIG_GENERATOR GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(NOT _MULTICONFIG_GENERATOR) + # Only set when we know we are in a single-configuration generator + # Note: we may want to fail early if `CMAKE_BUILD_TYPE` is not defined + set(${BUILD_TYPE} ${CMAKE_BUILD_TYPE} PARENT_SCOPE) + endif() +endfunction() + +macro(set_conan_compiler_if_appleclang lang command output_variable) + if(CMAKE_${lang}_COMPILER_ID STREQUAL "AppleClang") + execute_process(COMMAND xcrun --find ${command} + OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE) + cmake_path(GET _xcrun_out PARENT_PATH _xcrun_toolchain_path) + cmake_path(GET CMAKE_${lang}_COMPILER PARENT_PATH _compiler_parent_path) + if ("${_xcrun_toolchain_path}" STREQUAL "${_compiler_parent_path}") + set(${output_variable} "") + endif() + unset(_xcrun_out) + unset(_xcrun_toolchain_path) + unset(_compiler_parent_path) + endif() +endmacro() + + +macro(append_compiler_executables_configuration) + set(_conan_c_compiler "") + set(_conan_cpp_compiler "") + if(CMAKE_C_COMPILER) + set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\",") + set_conan_compiler_if_appleclang(C cc _conan_c_compiler) + else() + message(WARNING "CMake-Conan: The C compiler is not defined. " + "Please define CMAKE_C_COMPILER or enable the C language.") + endif() + if(CMAKE_CXX_COMPILER) + set(_conan_cpp_compiler "\"cpp\":\"${CMAKE_CXX_COMPILER}\"") + set_conan_compiler_if_appleclang(CXX c++ _conan_cpp_compiler) + else() + message(WARNING "CMake-Conan: The C++ compiler is not defined. " + "Please define CMAKE_CXX_COMPILER or enable the C++ language.") + endif() + + if(NOT "x${_conan_c_compiler}${_conan_cpp_compiler}" STREQUAL "x") + string(APPEND PROFILE "tools.build:compiler_executables={${_conan_c_compiler}${_conan_cpp_compiler}}\n") + endif() + unset(_conan_c_compiler) + unset(_conan_cpp_compiler) +endmacro() + + +function(detect_host_profile output_file) + detect_os(MYOS MYOS_API_LEVEL MYOS_SDK MYOS_SUBSYSTEM MYOS_VERSION) + detect_arch(MYARCH) + detect_compiler(MYCOMPILER MYCOMPILER_VERSION MYCOMPILER_RUNTIME MYCOMPILER_RUNTIME_TYPE) + detect_cxx_standard(MYCXX_STANDARD) + detect_lib_cxx(MYLIB_CXX) + detect_build_type(MYBUILD_TYPE) + + set(PROFILE "") + string(APPEND PROFILE "[settings]\n") + if(MYARCH) + string(APPEND PROFILE arch=${MYARCH} "\n") + endif() + if(MYOS) + string(APPEND PROFILE os=${MYOS} "\n") + endif() + if(MYOS_API_LEVEL) + string(APPEND PROFILE os.api_level=${MYOS_API_LEVEL} "\n") + endif() + if(MYOS_VERSION) + string(APPEND PROFILE os.version=${MYOS_VERSION} "\n") + endif() + if(MYOS_SDK) + string(APPEND PROFILE os.sdk=${MYOS_SDK} "\n") + endif() + if(MYOS_SUBSYSTEM) + string(APPEND PROFILE os.subsystem=${MYOS_SUBSYSTEM} "\n") + endif() + if(MYCOMPILER) + string(APPEND PROFILE compiler=${MYCOMPILER} "\n") + endif() + if(MYCOMPILER_VERSION) + string(APPEND PROFILE compiler.version=${MYCOMPILER_VERSION} "\n") + endif() + if(MYCOMPILER_RUNTIME) + string(APPEND PROFILE compiler.runtime=${MYCOMPILER_RUNTIME} "\n") + endif() + if(MYCOMPILER_RUNTIME_TYPE) + string(APPEND PROFILE compiler.runtime_type=${MYCOMPILER_RUNTIME_TYPE} "\n") + endif() + if(MYCXX_STANDARD) + string(APPEND PROFILE compiler.cppstd=${MYCXX_STANDARD} "\n") + endif() + if(MYLIB_CXX) + string(APPEND PROFILE compiler.libcxx=${MYLIB_CXX} "\n") + endif() + if(MYBUILD_TYPE) + string(APPEND PROFILE "build_type=${MYBUILD_TYPE}\n") + endif() + + if(NOT DEFINED output_file) + set(_FN "${CMAKE_BINARY_DIR}/profile") + else() + set(_FN ${output_file}) + endif() + + string(APPEND PROFILE "[conf]\n") + string(APPEND PROFILE "tools.cmake.cmaketoolchain:generator=${CMAKE_GENERATOR}\n") + + # propagate compilers via profile + append_compiler_executables_configuration() + + if(MYOS STREQUAL "Android") + string(APPEND PROFILE "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n") + endif() + + message(STATUS "CMake-Conan: Creating profile ${_FN}") + file(WRITE ${_FN} ${PROFILE}) + message(STATUS "CMake-Conan: Profile: \n${PROFILE}") +endfunction() + + +function(conan_profile_detect_default) + message(STATUS "CMake-Conan: Checking if a default profile exists") + execute_process(COMMAND ${CONAN_COMMAND} profile path default + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + ECHO_OUTPUT_VARIABLE + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + if(NOT ${return_code} EQUAL "0") + message(STATUS "CMake-Conan: The default profile doesn't exist, detecting it.") + execute_process(COMMAND ${CONAN_COMMAND} profile detect + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + ECHO_OUTPUT_VARIABLE + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() +endfunction() + + +function(conan_install) + cmake_parse_arguments(ARGS CONAN_ARGS ${ARGN}) + set(CONAN_OUTPUT_FOLDER ${CMAKE_BINARY_DIR}/conan) + # Invoke "conan install" with the provided arguments + set(CONAN_ARGS ${CONAN_ARGS} -of=${CONAN_OUTPUT_FOLDER}) + message(STATUS "CMake-Conan: conan install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN}") + + + # In case there was not a valid cmake executable in the PATH, we inject the + # same we used to invoke the provider to the PATH + if(DEFINED PATH_TO_CMAKE_BIN) + set(_OLD_PATH $ENV{PATH}) + set(ENV{PATH} "$ENV{PATH}:${PATH_TO_CMAKE_BIN}") + endif() + + execute_process(COMMAND ${CONAN_COMMAND} install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN} --format=json + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_stdout + ERROR_VARIABLE conan_stderr + ECHO_ERROR_VARIABLE # show the text output regardless + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(DEFINED PATH_TO_CMAKE_BIN) + set(ENV{PATH} "${_OLD_PATH}") + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + else() + # the files are generated in a folder that depends on the layout used, if + # one is specified, but we don't know a priori where this is. + # TODO: this can be made more robust if Conan can provide this in the json output + string(JSON CONAN_GENERATORS_FOLDER GET ${conan_stdout} graph nodes 0 generators_folder) + cmake_path(CONVERT ${CONAN_GENERATORS_FOLDER} TO_CMAKE_PATH_LIST CONAN_GENERATORS_FOLDER) + # message("conan stdout: ${conan_stdout}") + message(STATUS "CMake-Conan: CONAN_GENERATORS_FOLDER=${CONAN_GENERATORS_FOLDER}") + set_property(GLOBAL PROPERTY CONAN_GENERATORS_FOLDER "${CONAN_GENERATORS_FOLDER}") + # reconfigure on conanfile changes + string(JSON CONANFILE GET ${conan_stdout} graph nodes 0 label) + message(STATUS "CMake-Conan: CONANFILE=${CMAKE_SOURCE_DIR}/${CONANFILE}") + set_property(DIRECTORY ${CMAKE_SOURCE_DIR} APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/${CONANFILE}") + # success + set_property(GLOBAL PROPERTY CONAN_INSTALL_SUCCESS TRUE) + endif() +endfunction() + + +function(conan_get_version conan_command conan_current_version) + execute_process( + COMMAND ${conan_command} --version + OUTPUT_VARIABLE conan_output + RESULT_VARIABLE conan_result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(conan_result) + message(FATAL_ERROR "CMake-Conan: Error when trying to run Conan") + endif() + + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" conan_version ${conan_output}) + set(${conan_current_version} ${conan_version} PARENT_SCOPE) +endfunction() + + +function(conan_version_check) + set(options ) + set(oneValueArgs MINIMUM CURRENT) + set(multiValueArgs ) + cmake_parse_arguments(CONAN_VERSION_CHECK + "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT CONAN_VERSION_CHECK_MINIMUM) + message(FATAL_ERROR "CMake-Conan: Required parameter MINIMUM not set!") + endif() + if(NOT CONAN_VERSION_CHECK_CURRENT) + message(FATAL_ERROR "CMake-Conan: Required parameter CURRENT not set!") + endif() + + if(CONAN_VERSION_CHECK_CURRENT VERSION_LESS CONAN_VERSION_CHECK_MINIMUM) + message(FATAL_ERROR "CMake-Conan: Conan version must be ${CONAN_VERSION_CHECK_MINIMUM} or later") + endif() +endfunction() + + +macro(construct_profile_argument argument_variable profile_list) + set(${argument_variable} "") + if("${profile_list}" STREQUAL "CONAN_HOST_PROFILE") + set(_arg_flag "--profile:host=") + elseif("${profile_list}" STREQUAL "CONAN_BUILD_PROFILE") + set(_arg_flag "--profile:build=") + endif() + + set(_profile_list "${${profile_list}}") + list(TRANSFORM _profile_list REPLACE "auto-cmake" "${CMAKE_BINARY_DIR}/conan_host_profile") + list(TRANSFORM _profile_list PREPEND ${_arg_flag}) + set(${argument_variable} ${_profile_list}) + + unset(_arg_flag) + unset(_profile_list) +endmacro() + + +macro(conan_provide_dependency method package_name) + set_property(GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED TRUE) + get_property(_conan_install_success GLOBAL PROPERTY CONAN_INSTALL_SUCCESS) + if(NOT _conan_install_success) + find_program(CONAN_COMMAND "conan" REQUIRED) + conan_get_version(${CONAN_COMMAND} CONAN_CURRENT_VERSION) + conan_version_check(MINIMUM ${CONAN_MINIMUM_VERSION} CURRENT ${CONAN_CURRENT_VERSION}) + message(STATUS "CMake-Conan: first find_package() found. Installing dependencies with Conan") + if("default" IN_LIST CONAN_HOST_PROFILE OR "default" IN_LIST CONAN_BUILD_PROFILE) + conan_profile_detect_default() + endif() + if("auto-cmake" IN_LIST CONAN_HOST_PROFILE) + detect_host_profile(${CMAKE_BINARY_DIR}/conan_host_profile) + endif() + construct_profile_argument(_host_profile_flags CONAN_HOST_PROFILE) + construct_profile_argument(_build_profile_flags CONAN_BUILD_PROFILE) + if(EXISTS "${CMAKE_SOURCE_DIR}/conanfile.py") + file(READ "${CMAKE_SOURCE_DIR}/conanfile.py" outfile) + if(NOT "${outfile}" MATCHES ".*CMakeDeps.*") + message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile") + endif() + set(generator "") + elseif (EXISTS "${CMAKE_SOURCE_DIR}/conanfile.txt") + file(READ "${CMAKE_SOURCE_DIR}/conanfile.txt" outfile) + if(NOT "${outfile}" MATCHES ".*CMakeDeps.*") + message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile. " + "Please define the generator as it will be mandatory in the future") + endif() + set(generator "-g;CMakeDeps") + endif() + get_property(_multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(NOT _multiconfig_generator) + message(STATUS "CMake-Conan: Installing single configuration ${CMAKE_BUILD_TYPE}") + conan_install(${_host_profile_flags} ${_build_profile_flags} ${CONAN_INSTALL_ARGS} ${generator}) + else() + message(STATUS "CMake-Conan: Installing both Debug and Release") + conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Release ${CONAN_INSTALL_ARGS} ${generator}) + conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Debug ${CONAN_INSTALL_ARGS} ${generator}) + endif() + unset(_host_profile_flags) + unset(_build_profile_flags) + unset(_multiconfig_generator) + unset(_conan_install_success) + else() + message(STATUS "CMake-Conan: find_package(${ARGV1}) found, 'conan install' already ran") + unset(_conan_install_success) + endif() + + get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER) + + # Ensure that we consider Conan-provided packages ahead of any other, + # irrespective of other settings that modify the search order or search paths + # This follows the guidelines from the find_package documentation + # (https://cmake.org/cmake/help/latest/command/find_package.html): + # find_package ( PATHS paths... NO_DEFAULT_PATH) + # find_package () + + # Filter out `REQUIRED` from the argument list, as the first call may fail + set(_find_args_${package_name} "${ARGN}") + list(REMOVE_ITEM _find_args_${package_name} "REQUIRED") + if(NOT "MODULE" IN_LIST _find_args_${package_name}) + find_package(${package_name} ${_find_args_${package_name}} BYPASS_PROVIDER PATHS "${_conan_generators_folder}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) + unset(_find_args_${package_name}) + endif() + + # Invoke find_package a second time - if the first call succeeded, + # this will simply reuse the result. If not, fall back to CMake default search + # behaviour, also allowing modules to be searched. + if(NOT ${package_name}_FOUND) + list(FIND CMAKE_MODULE_PATH "${_conan_generators_folder}" _index) + if(_index EQUAL -1) + list(PREPEND CMAKE_MODULE_PATH "${_conan_generators_folder}") + endif() + unset(_index) + find_package(${package_name} ${ARGN} BYPASS_PROVIDER) + list(REMOVE_ITEM CMAKE_MODULE_PATH "${_conan_generators_folder}") + endif() +endmacro() + +#[=[ not needed by Qt Creator, and if not commented it would break the auto-setup feature + +cmake_language( + SET_DEPENDENCY_PROVIDER conan_provide_dependency + SUPPORTED_METHODS FIND_PACKAGE +) + + +macro(conan_provide_dependency_check) + set(_CONAN_PROVIDE_DEPENDENCY_INVOKED FALSE) + get_property(_CONAN_PROVIDE_DEPENDENCY_INVOKED GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED) + if(NOT _CONAN_PROVIDE_DEPENDENCY_INVOKED) + message(WARNING "Conan is correctly configured as dependency provider, " + "but Conan has not been invoked. Please add at least one " + "call to `find_package()`.") + if(DEFINED CONAN_COMMAND) + # supress warning in case `CONAN_COMMAND` was specified but unused. + set(_CONAN_COMMAND ${CONAN_COMMAND}) + unset(_CONAN_COMMAND) + endif() + endif() + unset(_CONAN_PROVIDE_DEPENDENCY_INVOKED) +endmacro() + + +# Add a deferred call at the end of processing the top-level directory +# to check if the dependency provider was invoked at all. +cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL conan_provide_dependency_check) + +]=] + +# Configurable variables for Conan profiles +set(CONAN_HOST_PROFILE "default;auto-cmake" CACHE STRING "Conan host profile") +set(CONAN_BUILD_PROFILE "default" CACHE STRING "Conan build profile") +set(CONAN_INSTALL_ARGS "--build=missing" CACHE STRING "Command line arguments for conan install") + +find_program(_cmake_program NAMES cmake NO_PACKAGE_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH) +if(NOT _cmake_program) + get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY) + set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is") +endif() + diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeCache.txt b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeCache.txt new file mode 100755 index 0000000..38c16ca --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeCache.txt @@ -0,0 +1,118 @@ +# This is the CMakeCache file. +# For build in directory: /Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug +# It was generated by CMake: /opt/homebrew/Cellar/cmake/3.28.3/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//No help, variable specified on the command line. +CMAKE_BUILD_TYPE:STRING=Debug + +//No help, variable specified on the command line. +CMAKE_CXX_COMPILER:FILEPATH= + +//No help, variable specified on the command line. +CMAKE_C_COMPILER:FILEPATH= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/pkgRedirects + +//No help, variable specified on the command line. +CMAKE_GENERATOR:STRING=Ninja + +//Program used to build from build.ninja files. +CMAKE_MAKE_PROGRAM:FILEPATH=CMAKE_MAKE_PROGRAM-NOTFOUND + +//No help, variable specified on the command line. +CMAKE_PREFIX_PATH:PATH=/Users/nktkln/Qt/6.7.2/macos + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//No help, variable specified on the command line. +CMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/auto-setup.cmake + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=Calculator + +//Value Computed by CMake +CMAKE_PROJECT_VERSION:STATIC=0.1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MAJOR:STATIC=0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MINOR:STATIC=1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_PATCH:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_TWEAK:STATIC= + +//Value Computed by CMake +Calculator_BINARY_DIR:STATIC=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug + +//Value Computed by CMake +Calculator_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +Calculator_SOURCE_DIR:STATIC=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator + +//Skip Qt Creator's package manager auto-setup +QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP:BOOL=OFF + +//No help, variable specified on the command line. +QT_QMAKE_EXECUTABLE:FILEPATH=/Users/nktkln/Qt/6.7.2/macos/bin/qmake + + +######################## +# INTERNAL cache entries +######################## + +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=28 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/opt/homebrew/Cellar/cmake/3.28.3/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/opt/homebrew/Cellar/cmake/3.28.3/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/opt/homebrew/Cellar/cmake/3.28.3/bin/ctest +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/opt/homebrew/Cellar/cmake/3.28.3/share/cmake +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname + diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/3.28.3/CMakeSystem.cmake b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/3.28.3/CMakeSystem.cmake new file mode 100755 index 0000000..3a7cefd --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/3.28.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Darwin-23.6.0") +set(CMAKE_HOST_SYSTEM_NAME "Darwin") +set(CMAKE_HOST_SYSTEM_VERSION "23.6.0") +set(CMAKE_HOST_SYSTEM_PROCESSOR "arm64") + + + +set(CMAKE_SYSTEM "Darwin-23.6.0") +set(CMAKE_SYSTEM_NAME "Darwin") +set(CMAKE_SYSTEM_VERSION "23.6.0") +set(CMAKE_SYSTEM_PROCESSOR "arm64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/CMakeConfigureLog.yaml b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/CMakeConfigureLog.yaml new file mode 100755 index 0000000..fdf4c76 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,11 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/opt/homebrew/Cellar/cmake/3.28.3/share/cmake/Modules/CMakeDetermineSystem.cmake:233 (message)" + - "CMakeLists.txt:3 (project)" + message: | + The system is: Darwin - 23.6.0 - arm64 +... diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/cmake.check_cache b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/cmake.check_cache new file mode 100755 index 0000000..3dccd73 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/qtcsettings.cmake b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/qtcsettings.cmake new file mode 100755 index 0000000..0625861 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/qtcsettings.cmake @@ -0,0 +1,9 @@ +# This file is managed by Qt Creator, do not edit! + +set("CMAKE_CXX_COMPILER" "" CACHE "FILEPATH" "" FORCE) +set("CMAKE_C_COMPILER" "" CACHE "FILEPATH" "" FORCE) +set("CMAKE_GENERATOR" "Ninja" CACHE "STRING" "" FORCE) +set("CMAKE_BUILD_TYPE" "Debug" CACHE "STRING" "" FORCE) +set("QT_QMAKE_EXECUTABLE" "/Users/nktkln/Qt/6.7.2/macos/bin/qmake" CACHE "FILEPATH" "" FORCE) +set("CMAKE_PREFIX_PATH" "/Users/nktkln/Qt/6.7.2/macos" CACHE "PATH" "" FORCE) +set("CMAKE_PROJECT_INCLUDE_BEFORE" "/Users/nktkln/Documents/University/Code projects/Third term/Industrial programming technologies/Calculator/build/Qt_for_macOS-Debug/.qtc/package-manager/auto-setup.cmake" CACHE "FILEPATH" "" FORCE) \ No newline at end of file diff --git a/Third term/Industrial programming technologies/Calculator/calculator.cpp b/Third term/Industrial programming technologies/Calculator/calculator.cpp new file mode 100755 index 0000000..d71c4fc --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/calculator.cpp @@ -0,0 +1,169 @@ +#include "calculator.h" +#include "./ui_calculator.h" + +Calculator::Calculator(QWidget *parent) + : QMainWindow(parent) + , ui(new Ui::Calculator) + , currentValue(0) + , storedValue(0) + , doubleDepth(0) +{ + ui->setupUi(this); + + connect(ui->button0, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button1, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button2, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button3, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button4, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button5, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button6, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button7, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button8, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->button9, &QPushButton::clicked, this, &Calculator::digitClicked); + connect(ui->buttonDot, &QPushButton::clicked, this, &Calculator::dotClicked); + + connect(ui->buttonAdd, &QPushButton::clicked, this, &Calculator::addClicked); + connect(ui->buttonSubtract, &QPushButton::clicked, this, &Calculator::subtractClicked); + connect(ui->buttonMultiply, &QPushButton::clicked, this, &Calculator::multiplyClicked); + connect(ui->buttonDivide, &QPushButton::clicked, this, &Calculator::divideClicked); + connect(ui->buttonEquals, &QPushButton::clicked, this, &Calculator::equalsClicked); + connect(ui->buttonClear, &QPushButton::clicked, this, &Calculator::clearClicked); + connect(ui->buttonChangeSign, &QPushButton::clicked, this, &Calculator::changeSignClicked); + connect(ui->buttonPow, &QPushButton::clicked, this, &Calculator::powClicked); +} + +Calculator::~Calculator() +{ + delete ui; +} + +void Calculator::printDisplay() +{ + if (pendingOperator == "") { + ui->display->setText(QString::number(currentValue)); + } else { + QString out; + + if (storedValue < 0) { + out += "(" + QString::number(storedValue) + ")"; + } else { + out += QString::number(storedValue); + } + + out += pendingOperator; + + if (currentValue < 0) { + out += "(" + QString::number(currentValue) + ")"; + } else { + out += QString::number(currentValue); + } + + ui->display->setText(out); + } +} + +void Calculator::digitClicked() +{ + QPushButton *clickedButton = qobject_cast(sender()); + int digitValue = clickedButton->text().toInt(); + if (currentValue < 0) digitValue *= -1; + if (doubleDepth != 0) { + currentValue += digitValue * std::pow(0.1, doubleDepth); + doubleDepth++; + } else { + currentValue = currentValue * 10 + digitValue; + } + printDisplay(); +} + +void Calculator::dotClicked() { + doubleDepth = 1; + ui->display->setText(QString::number(currentValue)); +} + +void Calculator::addClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "+"; + printDisplay(); +} + +void Calculator::subtractClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "-"; + printDisplay(); +} + +void Calculator::multiplyClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "*"; + printDisplay(); +} + +void Calculator::divideClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "/"; + printDisplay(); +} + +void Calculator::powClicked() +{ + storedValue = currentValue; + currentValue = 0; + doubleDepth = 0; + pendingOperator = "^"; + printDisplay(); +} + +void Calculator::equalsClicked() +{ + if (pendingOperator == "+") { + currentValue = storedValue + currentValue; + } else if (pendingOperator == "-") { + currentValue = storedValue - currentValue; + } else if (pendingOperator == "*") { + currentValue = storedValue * currentValue; + } else if (pendingOperator == "/") { + if (currentValue != 0) { + currentValue = storedValue / currentValue; + } else { + ui->display->setText("Error"); + return; + } + } else if (pendingOperator == "^") { + if (currentValue != 0) { + currentValue = std::pow(storedValue, currentValue); + } else { + ui->display->setText("Error"); + return; + } + } + + pendingOperator = ""; + printDisplay(); +} + +void Calculator::clearClicked() +{ + currentValue = 0; + storedValue = 0; + pendingOperator = ""; + printDisplay(); +} + +void Calculator::changeSignClicked() +{ + currentValue *= -1; + printDisplay(); +} diff --git a/Third term/Industrial programming technologies/Calculator/calculator.h b/Third term/Industrial programming technologies/Calculator/calculator.h new file mode 100755 index 0000000..f38b273 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/calculator.h @@ -0,0 +1,40 @@ +#ifndef CALCULATOR_H +#define CALCULATOR_H + +#include + +QT_BEGIN_NAMESPACE +namespace Ui { +class Calculator; +} +QT_END_NAMESPACE + +class Calculator : public QMainWindow +{ + Q_OBJECT + +public: + Calculator(QWidget *parent = nullptr); + ~Calculator(); + +private slots: + void digitClicked(); + void dotClicked(); + void addClicked(); + void subtractClicked(); + void multiplyClicked(); + void divideClicked(); + void equalsClicked(); + void clearClicked(); + void changeSignClicked(); + void powClicked(); + void printDisplay(); + +private: + Ui::MainWindow *ui; + double currentValue; + double storedValue; + int doubleDepth; + QString pendingOperator; +}; +#endif // CALCULATOR_H diff --git a/Third term/Industrial programming technologies/Calculator/calculator.ui b/Third term/Industrial programming technologies/Calculator/calculator.ui new file mode 100755 index 0000000..3a0eba8 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/calculator.ui @@ -0,0 +1,475 @@ + + + Calculator + + + + 0 + 0 + 350 + 564 + + + + + 0 + 0 + + + + Calculator + + + + + 0 + 0 + + + + + + 6 + 456 + 166 + 80 + + + + + 18 + + + + 0 + + + 0 + + + + + + 178 + 456 + 80 + 80 + + + + + 18 + + + + . + + + . + + + + + + 264 + 456 + 80 + 80 + + + + + 18 + + + + = + + + Ctrl+S + + + + + + 6 + 284 + 80 + 80 + + + + + 18 + + + + 4 + + + 4 + + + + + + 178 + 284 + 80 + 80 + + + + + 18 + + + + 6 + + + 6 + + + + + + 92 + 284 + 80 + 80 + + + + + 18 + + + + 5 + + + 5 + + + + + + 264 + 284 + 80 + 80 + + + + + 18 + + + + - + + + - + + + + + + 6 + 198 + 80 + 80 + + + + + 18 + + + + 7 + + + 7 + + + + + + 178 + 198 + 80 + 80 + + + + + 18 + + + + 9 + + + 9 + + + + + + 92 + 198 + 80 + 80 + + + + + 18 + + + + 8 + + + 8 + + + + + + 264 + 198 + 80 + 80 + + + + + 18 + + + + * + + + * + + + + + + 6 + 112 + 80 + 80 + + + + + 18 + + + + C + + + Backspace + + + + + + 178 + 112 + 80 + 80 + + + + + 18 + + + + ^ + + + ^ + + + + + + 92 + 112 + 80 + 80 + + + + + 18 + + + + +/- + + + + + + 264 + 112 + 80 + 80 + + + + + 18 + + + + / + + + / + + + + + + 12 + 6 + 326 + 100 + + + + + 18 + + + + Qt::LayoutDirection::LeftToRight + + + false + + + 0 + + + + + + 92 + 370 + 80 + 80 + + + + + 18 + + + + 2 + + + 2 + + + + + + 264 + 370 + 80 + 80 + + + + + 18 + + + + + + + + + + + + + + + 178 + 370 + 80 + 80 + + + + + 18 + + + + 3 + + + 3 + + + + + + 6 + 370 + 80 + 80 + + + + + 18 + + + + 1 + + + 1 + + + + + + + 0 + 0 + 350 + 24 + + + + + Calculator + + + + + Programming + + + + + + + + + diff --git a/Third term/Industrial programming technologies/Calculator/main.cpp b/Third term/Industrial programming technologies/Calculator/main.cpp new file mode 100755 index 0000000..eb67047 --- /dev/null +++ b/Third term/Industrial programming technologies/Calculator/main.cpp @@ -0,0 +1,11 @@ +#include "calculator.h" + +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + Calculator w; + w.show(); + return a.exec(); +} diff --git a/Third term/Industrial programming technologies/README.md b/Third term/Industrial programming technologies/README.md new file mode 100755 index 0000000..47df3b9 --- /dev/null +++ b/Third term/Industrial programming technologies/README.md @@ -0,0 +1,7 @@ +# Artificial intelligence systems and big data + +number | grade +:----: | :---: +1 | ✅ + +[Back](/NKTKLN/mirea-projects) diff --git a/Third term/Programming of corporate systems/1/main.cs b/Third term/Programming of corporate systems/1/main.cs new file mode 100755 index 0000000..b121a47 --- /dev/null +++ b/Third term/Programming of corporate systems/1/main.cs @@ -0,0 +1,157 @@ +/* +Описание программного продукта + +1) Функционал + +Калькулятор предоставляет пользователям возможность выполнять базовые арифметические операции, +а также использовать функции для работы с памятью и дополнительными вычислениями. +Возможности калькулятора включают: + +Арифметические операции: + - Сложение (+) + - Вычитание (-) + - Умножение (*) + - Деление (/) + - Процент от числа (%) + - Возведение в степень (^) + - Квадратный корень (sqrt) + - Обратное значение (1/) + - Возведение в квадрат (^2) + +Функции работы с памятью: + - m+ — добавление текущего результата в память + - m- — вычитание текущего результата из памяти + - ms — сохранение текущего результата в память + - mc — очистка памяти + - mr — вывод сохранённого значения из памяти + - c — сброс текущего результата + +2) Ограничения + +Числовые ограничения: + - При выполнении операции квадратного корня (sqrt), число должно быть неотрицательным. + - При вычислении обратного значения (1/), делитель не должен быть равен нулю. + - При вычислении опраций деления, остатка от деления и обратного значения (/, %, 1/), + делитель не должен быть равен нулю. + +Операции: + - Калькулятор поддерживает только указанные операции и функции. + - Не предусмотрены расширенные математические функции (тригонометрические, логарифмические и др.). + +Ввод данных: + - Вводимые данные должны быть числовыми, неверный формат приводит к ошибкам. + - Программа не обрабатывает некорректные или неподдерживаемые команды. + +3) Возможные ошибки + +Формат ввода: + - Неверный формат числа: Появляется при вводе данных, которые не могут быть преобразованы в число. + +Математические ошибки: + - Отрицательное число: Появляется при попытке вычислить квадратный корень от отрицательного числа. + - Деление на 0: Происходит при попытке деления на ноль или вычислении остатка от деления на ноль. + +Неподдерживаемая операция: + - Появляется, если пользователь вводит операцию, которая не поддерживается калькулятором. +*/ + +using System; + +class Calculator +{ + static double memory = 0; + static double lastResult = 0; + + static void Main() + { + Console.WriteLine("Калькулятор\n\nКоманды: +, -, *, /, %, ^, sqrt, 1/, ^2\nФункции: m+, m-, ms, mc, mr, c, ce\nДля выхода используйте 'exit'\n"); + + while (true) + { + Console.Write(":> "); + string userInput = Console.ReadLine().Trim().ToLower(); + + if (userInput == "exit") break; + + if (ProcessFunction(userInput)) continue; + + try + { + double result = Calculate(userInput); + lastResult = result; + Console.WriteLine($"Результат: {result}"); + } + catch (Exception exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + } + } + } + + static bool ProcessFunction(string command) + { + switch (command) + { + case "m+": + memory += lastResult; + Console.WriteLine($"M+: {memory}"); + return true; + case "m-": + memory -= lastResult; + Console.WriteLine($"M-: {memory}"); + return true; + case "ms": + memory = lastResult; + Console.WriteLine($"MS: {memory}"); + return true; + case "mc": + memory = 0; + Console.WriteLine("MC: память очищена"); + return true; + case "mr": + Console.WriteLine($"MR: {memory}"); + return true; + case "c": + lastResult = 0; + Console.WriteLine("C: сброс"); + return true; + default: + return false; + } + } + + static double Calculate(string operation) + { + double first = ReadNumber("First"); + + switch (operation) + { + case "sqrt" when first >= 0: return Math.Sqrt(first); + case "sqrt": throw new ArgumentException("Отрицательное число"); + case "1/" when first != 0: return 1 / first; + case "1/": throw new DivideByZeroException("Делить на 0 нельзя"); + case "^2": return Math.Pow(first, 2); + } + + double second = ReadNumber("Second"); + + switch (operation) + { + case "+": return first + second; + case "-": return first - second; + case "*": return first * second; + case "%": return second * first / 100; + case "^": return Math.Pow(first, second); + case "/" when second != 0: return first / second; + case "/": throw new DivideByZeroException("Делить на 0 нельзя"); + default: throw new ArgumentException("Неподдерживаемая операция"); + } + } + + static double ReadNumber(string prompt) + { + Console.Write($"{prompt} :> "); + if (double.TryParse(Console.ReadLine().Trim(), out double value)) return value; + throw new FormatException("Неверный формат числа"); + } +} diff --git a/Third term/Programming of corporate systems/1/Калинин_ЭФБО-09-23.docx b/Third term/Programming of corporate systems/1/Калинин_ЭФБО-09-23.docx new file mode 100755 index 0000000..ce45d9b Binary files /dev/null and b/Third term/Programming of corporate systems/1/Калинин_ЭФБО-09-23.docx differ diff --git a/Third term/Programming of corporate systems/2/1.cs b/Third term/Programming of corporate systems/2/1.cs new file mode 100644 index 0000000..3840df4 --- /dev/null +++ b/Third term/Programming of corporate systems/2/1.cs @@ -0,0 +1,28 @@ +using System; + +class CalendarProgram +{ + static void Main() + { + Console.Write("Введите номер дня недели, с которого начинается месяц (1-пн, ..., 7-вс): "); + int firstDayOfWeek = int.Parse(Console.ReadLine()); + if (firstDayOfWeek < 1 || firstDayOfWeek > 7) + { + Console.WriteLine("Неверный номер дня недели"); + return; + } + + Console.Write("Введите день месяца (1-31): "); + int dayOfMonth = int.Parse(Console.ReadLine()); + if (dayOfMonth < 1 || dayOfMonth > 31) + { + Console.WriteLine("Неверный день месяца"); + return; + } + + int dayOfWeek = (firstDayOfWeek + (dayOfMonth - 1)) % 7; + if (dayOfMonth <= 5 || (dayOfMoynth >= 8 && dayOfMonth <= 10) || dayOfWeek == 6 || dayOfWeek == 0) + Console.WriteLine("Выходной день"); + else Console.WriteLine("Рабочий день"); + } +} diff --git a/Third term/Programming of corporate systems/2/2.cs b/Third term/Programming of corporate systems/2/2.cs new file mode 100644 index 0000000..51fc558 --- /dev/null +++ b/Third term/Programming of corporate systems/2/2.cs @@ -0,0 +1,35 @@ +using System; + +class ATMProgram +{ + static void Main() + { + int[] banknotes = { 5000, 2000, 1000, 500, 200, 100 }; + + Console.Write("Введите сумму, которую хотите обналичить: "); + int amount = int.Parse(Console.ReadLine()); + + if (amount > 150000) + { + Console.WriteLine("Cумма должна быть меньше 150 000 рублей"); + return; + } + + if (amount % 100 != 0) + { + Console.WriteLine("Cумма должна быть кратна 100"); + return; + } + + Console.WriteLine("Купюры:"); + foreach (int note in banknotes) + { + int count = amount / note; + if (count > 0) + { + Console.WriteLine($"{count} - {note} руб"); + amount -= count * note; + } + } + } +} diff --git a/Third term/Programming of corporate systems/2/ЭФБО-09-23 Калинин Н. В..docx b/Third term/Programming of corporate systems/2/ЭФБО-09-23 Калинин Н. В..docx new file mode 100644 index 0000000..2e6ced7 Binary files /dev/null and b/Third term/Programming of corporate systems/2/ЭФБО-09-23 Калинин Н. В..docx differ diff --git a/Third term/Programming of corporate systems/README.md b/Third term/Programming of corporate systems/README.md new file mode 100755 index 0000000..47df3b9 --- /dev/null +++ b/Third term/Programming of corporate systems/README.md @@ -0,0 +1,7 @@ +# Artificial intelligence systems and big data + +number | grade +:----: | :---: +1 | ✅ + +[Back](/NKTKLN/mirea-projects)