bla bla

uczelnia/2_semestr/python/laby/6/6.py

@@ -0,0 +1,56 @@
+import math
+
+from converters import FuelConsumptionConverter as f
+from converters import UnitConventer as u
+from math_stuff import matrix
+
+
+def zad1():
+    print(dir(math))
+
+
+def zad2():
+    help(math.cos)  # radiany
+
+
+def zad4_5():
+    liczba = 10
+    print(u.funt_kg(liczba))
+    print(u.stopy_m(liczba))
+    print(u.cale_m(liczba))
+    print(u.mile_km(liczba))
+    print(u.gale_l(liczba))
+    print(u.kg_funty(liczba))
+    print(u.m_stopy(liczba))
+    print(u.m_cale(liczba))
+    print(u.km_mile(liczba))
+    print(u.l_gale(liczba))
+
+
+def zad6():
+    print(f.lp100km2mp(15))
+    print(f.mpg2lp100km(15))
+
+
+def zad7():
+    help(f.lp100km2mp)
+
+
+def zad8():
+    m1: matrix.matrix = matrix.matrix([[1, 1, 1], [1, 2, 3]])
+    m2: matrix.matrix = matrix.matrix([[3, 2, 1], [1, 2, 3]])
+    matrix.add(m1, m2)
+    print(m1.matrix)
+
+    matrix.add_constant(m1, 5)
+    print(m1.matrix)
+
+    print(matrix.multiplication(m1, m2).matrix)
+    matrix.multiplication_scalar(m1, 5)
+    print(m1.matrix)
+    print(matrix.multiplication_hadamar(m1, m2).matrix)
+    print(matrix.multiplication_kronecker(m1, m2).matrix)
+
+
+if __name__ == "__main__":
+    zad8()

uczelnia/2_semestr/python/laby/6/converters/FuelConsumptionConverter.py

@@ -0,0 +1,14 @@
+def lp100km2mp(europejski: float) -> float:
+    """
+        Pozwalająca na przeliczenie spalania z systemu Europejskiego l/100km
+    (litry na 100 kilometrów) na system Ameryka«ski mi/1g (mile ameryka«skie na jeden
+    galon),
+    """
+    return 235.215 / europejski
+
+
+def mpg2lp100km(amerykanski: float) -> float:
+    """
+    konwersja odwrotna
+    """
+    return 235.21 / amerykanski

uczelnia/2_semestr/python/laby/6/converters/UnitConventer.py

@@ -0,0 +1,38 @@
+def funt_kg(funty: float) -> float:
+    return funty * 0.45359237
+
+
+def stopy_m(stopy: float) -> float:
+    return stopy * 0.3048
+
+
+def cale_m(cale: float) -> float:
+    return cale * 0.0254
+
+
+def mile_km(mile: float) -> float:
+    return mile * 1.609344
+
+
+def gale_l(gale: float) -> float:
+    return gale * 3.785411784
+
+
+def kg_funty(kg: float) -> float:
+    return kg / 0.45359237
+
+
+def m_stopy(m: float) -> float:
+    return m / 0.3048
+
+
+def m_cale(m: float) -> float:
+    return m / 0.0254
+
+
+def km_mile(km: float) -> float:
+    return km * 1.609344
+
+
+def l_gale(litry: float) -> float:
+    return litry / 3.785411784

uczelnia/2_semestr/python/laby/6/math_stuff/matrix.py

@@ -0,0 +1,74 @@
+class matrix:
+    def __init__(self, mat: list[list[int]] = None) -> None:
+        self.matrix = [] if mat is None else mat
+
+
+def add(m1: matrix, m2: matrix) -> None:
+    for i in range(len(m1.matrix)):
+        for j in range(len(m1.matrix[0])):
+            m1.matrix[i][j] += m2.matrix[i][j]
+
+
+def add_constant(m1: matrix, constant: int) -> None:
+    for i in range(len(m1.matrix)):
+        for j in range(len(m1.matrix[0])):
+            m1.matrix[i][j] += constant
+
+
+def multiplication(A: matrix, B: matrix) -> matrix:
+    rows_A = len(A.matrix)
+    cols_B = len(B.matrix[0]) if B.matrix else 0
+
+    C_mat = [[0 for _ in range(cols_B)] for _ in range(rows_A)]
+    C: matrix = matrix(C_mat)
+
+    for i in range(len(A.matrix)):
+        for j in range(len(B.matrix[0])):
+            for k in range(len(B.matrix)):
+                C.matrix[i][j] += A.matrix[i][k] * B.matrix[k][j]
+    return C
+
+
+def multiplication_scalar(A: matrix, scalar: int) -> None:
+    for i in range(len(A.matrix)):
+        for j in range(len(A.matrix[0])):
+            A.matrix[i][j] *= scalar
+
+
+def multiplication_hadamar(A: matrix, B: matrix) -> matrix:
+    rows = len(A.matrix)
+    cols = len(A.matrix[0]) if rows > 0 else 0
+
+    C_mat = [[0 for _ in range(cols)] for _ in range(rows)]
+    C: matrix = matrix(C_mat)
+
+    for i in range(rows):
+        for j in range(cols):
+            C.matrix[i][j] = A.matrix[i][j] * B.matrix[i][j]
+
+    return C
+
+
+def multiplication_kronecker(A: matrix, B: matrix) -> matrix:
+    rows_A = len(A.matrix)
+    cols_A = len(A.matrix[0]) if rows_A > 0 else 0
+
+    rows_B = len(B.matrix)
+    cols_B = len(B.matrix[0]) if rows_B > 0 else 0
+
+    rows_C = rows_A * rows_B
+    cols_C = cols_A * cols_B
+
+    C_mat = [[0 for _ in range(cols_C)] for _ in range(rows_C)]
+    C: matrix = matrix(C_mat)
+
+    for i_a in range(rows_A):
+        for j_a in range(cols_A):
+            for i_b in range(rows_B):
+                for j_b in range(cols_B):
+                    row_c = i_a * rows_B + i_b
+                    col_c = j_a * cols_B + j_b
+
+                    C.matrix[row_c][col_c] = A.matrix[i_a][j_a] * B.matrix[i_b][j_b]
+
+    return C