Что-то похожее на третью лабу

1 files changed, 308 insertions, 0 deletions

diff --git a/lab3/lab3.py b/lab3/lab3.py
new file mode 100644
index 0000000..8921b7d
--- /dev/null
+++ b/lab3/lab3.py
@@ -0,0 +1,308 @@
+import numpy as np
+
+#####################
+# Бинарные операции #
+#####################
+
+def check_associativity(cayley: np.array, elements: list) -> bool:
+    n = cayley.shape[0]
+    for i in range(n):
+        for j in range(n):
+            for k in range(n):
+                q = elements.index(cayley[i, k])
+                p = elements.index(cayley[j, i])
+                if cayley[p, k] != cayley[j, q]:
+                    return False
+    return True
+
+
+def check_commutativity(cayley: np.array, elements: list) -> bool:
+    n = cayley.shape[0]
+    for i in range(n):
+        for j in range(n):
+            if cayley[i, j] != cayley[j, i]:
+                return False
+    return True
+
+
+def check_idempotence(cayley: np.array, elements: list) -> bool:
+    n = cayley.shape[0]
+    for i in range(n):
+        a = elements[i]
+        if cayley[i, i] != a:
+            return False
+    return True
+
+
+def check_reversibility(cayley: np.array, elements: list) -> bool:
+    n = cayley.shape[0]
+    for i in range(n):
+        for j in range(n):
+            if cayley[i, j] != 1 or cayley[j, i] != 1:
+                return False
+    return True
+
+
+# cayley1 - *, cayley2 - +
+def check_distributivity(cayley1: np.array, cayley2: np.array, elements: list) -> bool:
+    n = cayley1.shape[0]
+    for i in range(n):
+        for j in range(n):
+            for k in range(n):
+                t = elements.index(cayley2[j, k])
+                p = elements.index(cayley1[i, j])
+                q = elements.index(cayley1[i, k])
+                r = elements.index(cayley1[j, i])
+                s = elements.index(cayley1[k, i])
+                if cayley1[i, t] != cayley2[p, q] or \
+                    cayley1[t, i] != cayley2[r, s]:
+                    return False
+    return True
+
+
+def check_operation():
+    print("Введите элементы множества, на котором определена операция:")
+    elements = input().strip().split()
+    n = len(elements)
+    print("Введите таблицу Кэли:")
+    cayley = []
+    for i in range(n):
+        line = input().strip().split()
+        cayley.append(line)
+    cayley = np.array(cayley, dtype=str)
+
+    status = []
+
+    if check_associativity(cayley, elements):
+        status.append("ассоциативность")
+    if check_commutativity(cayley, elements):
+        status.append("коммутативность")
+    if check_idempotence(cayley, elements):
+        status.append("идемпотентность")
+    if check_reversibility(cayley, elements):
+        status.append("обратимость")
+    
+    flag = input("Проверить на дистрибутивность? (да/НЕТ) ")
+    if flag.lower() == "да":
+        print("Введите таблицу Кэли второй операции:")
+        cayley2 = []
+        for i in range(n):
+            line = input().strip().split()
+            cayley2.append(line)
+        cayley2 = np.array(cayley2, dtype=str)
+        if check_distributivity(cayley, cayley2, elements):
+            status.append("дистрибутивность")
+    
+    print("Заданная бинарная операция обладает следующими свойствами:")
+    for i in status:
+        print(i)
+
+
+######################
+# Бинарные отношения #
+######################
+
+def make_union(a: np.array, b: np.array):
+    return a + b
+
+
+def make_intersection(a: np.array, b: np.array):
+    return np.multiply(a, b)
+
+
+def make_complement(m: np.array):
+    return 1 - m
+
+
+def make_reverse(m: np.array):
+    return np.transpose(m)
+
+
+def make_composition(a: np.array, b: np.array):
+    return np.matmul(a, b)
+
+
+def check_relations():
+    def read_array(n: int) -> np.array:
+        a = []
+        for _ in range(n):
+            line = list(map(int, input().strip().split()))
+            a.append(line)
+        return np.array(a, dtype=bool)
+
+    n = input("Введите размерность проверяемых отношений: ")
+
+    print("Введите бинарное отношение A")
+    a = read_array(n)
+    print("Введите бинарное отношение B")
+    b = read_array(n)
+
+    print("Объединение бинарных отношений:")
+    print(np.int(a + b))
+
+    print("Пересечение бинарных отношений:")
+    print(np.int(np.multiply(a, b)))
+
+    print("Дополнение бинарного отношения A:")
+    print(np.int(1 - a))
+
+    print("Дополнение бинарного отношения B:")
+    print(np.int(1 - b))
+
+    print("Бинарное отношение, обратное A:")
+    print(np.int(np.transpose(a)))
+
+    print("Бинарное отношение, обратное B:")
+    print(np.int(np.transpose(b)))
+
+    print("Композиция отношений:")
+    print(np.int(np.matmul(a, b)))
+
+########################
+# Операции с матрицами #
+########################
+
+def mat_add(a: np.array, b: np.array):
+    return a + b
+
+
+def mat_scale(m: np.array, alpha: float):
+    return alpha * m
+
+
+def mat_transpose(m: np.array):
+    return np.transpose(m)
+
+
+def mat_multiply(a: np.array, b: np.array):
+    return np.matmul(a, b)
+
+
+def check_matrices():
+    def read_matrix(n: int, m: int) -> np.array:
+        a = []
+        for _ in range(n):
+            line = list(map(int, input().strip().split()))
+            a.append(line)
+        return np.array(a, dtype=bool)
+
+    print("1 - Сложение матриц;")
+    print("2 - Умножение матрицы на скаляр;")
+    print("3 - Транспонирование матриц;")
+    print("4 - Умножение матриц;")
+    test = int(input("> "))
+    if test == 1:
+        n, m = map(int, input("Введите размерность матриц: ").split())
+        print("Введите матрицу A:")
+        a = read_matrix(n, m)
+
+        print("Введите матрицу B:")
+        b = read_matrix(n, m)
+
+        print("Сумма матриц:")
+        print(mat_add(a, b))
+    elif test == 2:
+        n, m = map(int, input("Введите размерность матриц: ").split())
+        print("Введите матрицу A:")
+        a = read_matrix(n, m)
+
+        alpha = float(input("Введите скаляр: "))
+
+        print("Результат:")
+        print(mat_scale(a, alpha))
+    elif test == 3:
+        n, m = map(int, input("Введите размерность матриц: ").split())
+        print("Введите матрицу A:")
+        a = read_matrix(n, m)
+
+        print("Результат:")
+        print(mat_transpose(a))
+    elif test == 4:
+        n, m = map(int, input("Введите размерность матриц: ").split())
+        print("Введите матрицу A:")
+        a = read_matrix(n, m)
+
+        print("Введите матрицу B:")
+        b = read_matrix(n, m)
+
+        print("Произведение матриц:")
+        print(mat_multiply(a, b))
+
+############
+# Задача 1 #
+############
+
+def task1():
+    print("Задача 1:")
+    elements = "a b c d".split()
+    cayley = np.array([
+        list("abab"),
+        list("abab"),
+        list("abcd"),
+        list("abcd"),
+    ])
+    if check_associativity(cayley, elements):
+        print("Данная операция является ассоциативной")
+    else:
+        print("Данная операция не является ассоциативной")
+
+############
+# Задача 2 #
+############
+
+def task2(l: float):
+    print("Задача 2:")
+    a = np.array([
+        [1, -2],
+        [-3, l]
+    ])
+    e = np.identity(2)
+    b = mat_add(
+        mat_add( mat_multiply(a, a), 
+                 mat_scale(10 - l / 2, a) ), 
+        mat_scale(l / 2, e)
+    )
+    print(b)
+
+############
+# Задача 3 #
+############
+
+def task3(l: float):
+    print("Задача 3:")
+    a = np.array([
+        [   -1, l,         3],
+        [l / 3, 2, 8 - l / 3]
+    ])
+    b = np.array([
+        [-l,          2],
+        [ 1, 10 - l / 2],
+        [-3,          l]
+    ])
+    print(mat_multiply(a, b))
+
+############
+
+def main():
+    flag = input("Проверить свойства бинарных операций? (да/НЕТ) ")
+    if flag.lower() == "да":
+        check_operation()
+
+    flag = input("Проверить операции с бинарными отношениями? (да/НЕТ) ")
+    if flag.lower() == "да":
+        check_relations()
+
+    flag = input("Проверить операции с матрицами? (да/НЕТ) ")
+    if flag.lower() == "да":
+        check_matrices()
+
+    flag = input("Выполнить задания? (да/НЕТ) ")
+    if flag.lower() == "да":
+        l = 6
+        task1()
+        task2(l)
+        task3(l)
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file