python rzeczy

uczelnia/2_semestr/matematyka_stosowana/Prawdopodobieństwo.md

@@ -246,3 +246,7 @@ Estymator $\theta$ rozkładu zmiennej X nazywamy dowolną statystyką, której w
 Używając lepszego estymatora otrzymujemy większą dokładność.
 
 Sprawdzenie efektywności umożliwia nierówność Rao-Cramera.
+
+
+# Istotna uwaga
+Przy interpretacji przedziału ufności nie należy stosować następującego sformułowania: „parametr z prawdopodobieństwem należy do przedziału w okolicach (...)”, ponieważ parametr nie zalezy od wyników próby losowej. Jest stałą. Zmienny jest natomiast przedział ufności, którego końce zależą od próby  losowej.

uczelnia/2_semestr/matematyka_stosowana/laby/powtórka.R

@@ -0,0 +1,201 @@
+# układ równań
+
+A = matrix(c(-9, 15, -14, -1, 13, 5, 18, 6, 8, 12, 10, -4, -1, 5, 8, 12), 4, 4)
+B = c(4, 298, 294, 120)
+solve(A, B)
+
+solve(A)
+solve(A)[1, 4]
+
+# wektory
+
+## Skonstruować wektor w trzecich potęg wielokrotności liczby 7 od 21 do 29903
+## następnie zliczyć, ile wśród elementów tego wektora jest liczb, których dwie ostatnie cyfry to
+## 23.
+w = seq(21, 29903, 7)^3
+summary.factor(w %% 100 == 23)
+
+
+## Skonstruować wektor w kwadratów liczb od 1 do 100 a następnie zliczyć, które
+## cyfry oraz jak często występują na pozycji jedności w wyznaczonych kwadratach (użyć operatora modulo, funkcji summary oraz typu factor). Ile wśród kwadratów liczb od 1 do 100 jest
+## podzielnych przez 2, przez 3 oraz przez 2 i 3?
+
+w = (1:100)^2
+summary.factor(w %% 2 == 0)
+summary.factor(w %% 3 == 0)
+summary.factor(w %% 3 == 0 & w %% 2 == 0)
+
+# dwumianowy i geom | lista 2
+
+# zad 1
+
+# P(X = 2)
+dbinom(2, 4, 1/3)
+# P(X < 2)
+pbinom(1, 4, 1/3)
+# P(X > 2)
+pbinom(2, 4, 1/3, F)
+
+
+# zad 2
+prob = 0.02
+dgeom(3, prob)
+
+pgeom(2, prob)
+
+# zad 3
+size = 100
+prob = 0.01
+# P(X = 2)
+dbinom(2, size, prob)
+dpois(2, size * prob)
+
+# P(2 < X < 6)
+sum(dbinom(2:6, size, prob))
+
+pbinom(3, size, prob, F)
+
+# zad 4
+dbinom(2, 4, 1/7)
+
+dbinom(3, 5, 1/2) > dbinom(2, 3, 1/2)
+
+# kwantyle
+qnorm(0.97)
+qchisq(0.975, 9)
+qt(0.95, 9)
+qf(0.995, 10, 23)
+
+
+# zad 2
+# d)
+# |x - 2| < 3
+# x - 2 < 3 || x - 2 > -3
+# x < 5 || x > -1
+pnorm(5, 1.5, 2) - pnorm(-1, 1.5, 2)
+
+
+# e)
+# |x| > 0.5
+# x > 0.5 || x < -0.5
+pnorm(-0.5, 1.5 ,2) + pnorm(0.5, 1.5, 2, F)
+
+# f)
+# -1 < 2x - 1 < 1
+# 0 < 2x < 2
+# 0 < x < 1
+pnorm(1, 1.5, 2) - pnorm(0, 1.5, 2)
+
+# g)
+# 3x - 1 > 2 || 3x -1 < -2
+# 3x > 3 || 3x < -1
+# x > 1 || 3 < -1/3
+pnorm(-1/3, 1.5, 2) + pnorm(1, 1.5, 2, F)
+
+# zad 3
+# 5x - 1 > 2.5 || 5x -1 < -2.5
+# 5x > 3.5 || 5x < -1.5
+pnorm(-1.5/5, -4, 3.5) + pnorm(3.5/5, -4, 3.5, F)
+
+# 4x - 2 <= 5.5 || 4x -2 >= -5.5
+# -5.5 < 4x - 2 < 5.5
+# -3.5 < 4x < 7.5
+pnorm(7.5/4, -4, 3.5) - pnorm(-3.5/4, -4, 3.5)
+
+# zad 4
+# P(X < 900)
+round(pnorm(900, 1000, 50) * 4000)
+qnorm(0.13, 1000, 50, F)
+
+# zad 5
+round(pnorm(7.1, 6.8, 0.3) * 30)
+qnorm(0.15, 6.8, 0.3)
+
+# zad 6
+# 22:05 < X < 22:10
+# 22 * 5/60 < X < 22 * 10/60
+pnorm(22 * 1/6 * 60, 15, 13) - pnorm(22 * 5/60 * 60, 15, 13)
+
+pnorm(22, 15, 13, F)
+
+# standaryzacja rozkładu normalnego
+# zad 1
+# P(X > 5) = 70/200
+sigma = 1
+m = 5 - sigma * qnorm(70/200, lower.tail = FALSE)
+round(pnorm(6, m, sigma) - pnorm(3, m, sigma), 4)
+
+# P(X < 6) = 0.8
+sigma = sqrt(4)
+m = 6 - sigma * qnorm(0.8)
+round(pnorm(6, m, sigma) - pnorm(3, m, sigma) ,4)
+
+# zad 2
+m = 5.2
+U = qnorm(0.121)
+sigma = (3 - m)/U
+qnorm(0.8, m, sigma)
+
+# zad 3
+m = -5
+X = -2
+U = qnorm(0.95)
+sigma = (X - m)/U
+pnorm(0, m, sigma, F)
+
+# zad 4
+m = 0.46
+X = 0.5
+U = qnorm(0.6)
+sigma = (X - m)/U
+pnorm(0.7, m, sigma, F)
+
+# zad 1
+A = matrix(c(1, 1, qnorm(3/10), qnorm(3/4)), 2, 2)
+B = c(5281.21, 9090.9)
+wynik = solve(A, B)
+m = wynik[1]
+sigma = wynik[2]
+
+pnorm(7800, m, sigma, F) * 100
+qnorm(0.15, m, sigma)
+
+
+# zad 3
+m = 165.5
+# 155 < X < 176
+U = qnorm((1 - 0.93)/2)
+sigma = (155 - m)/U
+round(pnorm(170, m, sigma, F) * 100)
+
+# zad 4
+A = matrix(c(1, 1, qnorm(1/12, lower.tail = FALSE), qnorm(2/12)), 2, 2)
+B = c(0.9, 0.5)
+wynik = solve(A, B)
+m = wynik[1]
+sigma = wynik[2]
+qnorm(0.1, m, sigma, F)
+
+A = matrix(c(1, 1, qnorm(11/12), qnorm(2/12)), 2, 2)
+B = c(0.9, 0.5)
+wynik = solve(A, B)
+m = wynik[1]
+sigma = wynik[2]
+
+qnorm(0.1, m, sig, F)
+
+# zadanie 2 lista 6
+n = 2000
+p = 0.002
+q = 1 - p
+
+sum(dbinom(6:12, n, p))
+if (n >= 50 & p < 10) {
+  print("Rozkład poissona")
+  sum(dpois(6:12, n * p))
+} else {
+  print("Nie można użyć rozkładu poissona")
+}
+
+
+

uczelnia/2_semestr/python/laby/8/baza.py

@@ -0,0 +1,35 @@
+from osoba import Osoba
+from pracownik import Pracownik
+
+if __name__ == "__main__":
+    baza: set[Pracownik | Osoba] = set()
+
+    baza.add(Osoba("2342348", "Bogdan", "Wojciechowski", 67.67, 69.69))
+    baza.add(Osoba("2983473", "Stanisław", "Pięta", 123.21, 543.23))
+    baza.add(Osoba("2389412", "Stefan", "Cichnicki", 67.67, 233.1))
+    baza.add(Osoba("2983473", "Genowefa", "Pięta", 123.21, 543.23))
+    baza.add(Osoba("2389412", "Aniela", "Głąb", 2384.1, 233.1))
+
+    baza.add(
+        Pracownik(
+            "2389412",
+            "Stanisław",
+            "Lem",
+            "Wydawnictwo niezwykłe",
+            2384.1,
+            233.1,
+            234123,
+        )
+    )
+
+    baza.add(
+        Pracownik("2389412", "Andrzej", "Sapkowski", "CD PROJEKT RED", 2384.1, 233.1, 5)
+    )
+    baza.add(
+        Pracownik(
+            "2389412", "Andrzej", "Duda", "Pałac prezydencki", 2384.1, 233.1, 234123
+        )
+    )
+
+    for element in baza:
+        print(element.__repr__())

uczelnia/2_semestr/python/laby/8/figury.py

@@ -0,0 +1,81 @@
+from abc import ABC, abstractmethod
+from math import pi as PI
+
+
+class Figura(ABC):
+    @abstractmethod
+    def oblicz_pole(self):
+        pass
+
+    @abstractmethod
+    def typ_figury(self):
+        pass
+
+    def print(self):
+        print(" Figura : ", self.typ_figury(), " , Pole : ", self.oblicz_pole())
+
+    def __copy__(self):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        result.__dict__.update(self.__dict__)
+        return result
+
+
+class Kwadrat(Figura):
+    def __init__(self, a: int | float):
+        if isinstance(a, int | float):
+            self.a = a
+        else:
+            raise TypeError("Niewłaściwy typ boku")
+
+    def oblicz_pole(self):
+        return self.a**2
+
+    def typ_figury(self):
+        return " Kwadrat "
+
+
+class Kolo(Figura):
+    def __init__(self, r: int | float) -> None:
+        if isinstance(r, int | float):
+            self.r = r
+        else:
+            raise TypeError("Koło musi mieć r typu liczba !!")
+
+    def oblicz_pole(self) -> float:
+        return 2 * PI * self.r
+
+    def typ_figury(self):
+        return " Koło "
+
+
+class Trojkat(Figura):
+    def __init__(self, a: int | float, h: int | float):
+        if isinstance(a, int | float) and isinstance(h, int | float):
+            self.a = a
+            self.h = h
+        else:
+            raise TypeError("Trojkat ma zle typy na wejsciu :((((")
+
+    def oblicz_pole(self) -> float:
+        return (self.a * self.h) / 2
+
+    def typ_figury(self):
+        return " Trojkat "
+
+
+if __name__ == "__main__":
+    try:
+        kwadrat = Kwadrat(3)
+        kolo = Kolo(2)
+        trojkat = Trojkat(2, 5)
+        trojkat2 = trojkat.__copy__()
+    except TypeError as e:
+        print(f"Bład podczas tworzenia figur: {e}")
+    except Exception as e:
+        print(f"Nieznany błąd poczas tworzenia figur: {e}")
+
+    kwadrat.print()
+    kolo.print()
+    trojkat.print()
+    trojkat2.print()

uczelnia/2_semestr/python/laby/8/osoba.py

@@ -0,0 +1,68 @@
+class Osoba:
+    ilosc_osob: int = 0
+
+    def __init__(
+        self,
+        pesel: str,
+        imie: str,
+        nazwisko: str,
+        wzrost: float = 0.0,
+        waga: float = 0.0,
+    ) -> None:
+        self.__pesel = pesel
+        self.__imie = imie
+        self.__nazwisko = nazwisko
+        self.__wzrost = wzrost
+        self.__waga = waga
+        Osoba.ilosc_osob += 1
+
+    @property
+    def pesel(self) -> str:
+        return self.__pesel
+
+    @property
+    def imie(self) -> str:
+        return self.__imie
+
+    @property
+    def nazwisko(self) -> str:
+        return self.__nazwisko
+
+    @property
+    def wzrost(self) -> float:
+        return self.__wzrost
+
+    @wzrost.setter
+    def wzrost(self, nowy_wzrost: float) -> None:
+        if nowy_wzrost <= 0:
+            self.__wzrost = 0
+            return
+        self.__wzrost = nowy_wzrost
+
+    @property
+    def waga(self) -> float:
+        return self.__waga
+
+    @waga.setter
+    def waga(self, nowa_waga: float) -> None:
+        if nowa_waga <= 0:
+            self.__waga = 0
+            return
+        self.__waga = nowa_waga
+
+    @property
+    def data_urodzenia(self) -> str:
+        return self.__pesel[:6]
+
+    def __del__(self):
+        Osoba.ilosc_osob -= 1
+        del self
+
+    def __hash__(self) -> int:
+        return int(self.__pesel)
+
+    def __str__(self) -> str:
+        return f"{self.__pesel}, {self.__imie}, {self.__nazwisko}"
+
+    def __repr__(self):
+        return f"Osoba(pesel={self.__pesel}, imie={self.__imie}, nazwisko={self.__nazwisko}, wzrost={self.__wzrost}, waga={self.__waga})"

uczelnia/2_semestr/python/laby/8/pracownik.py

@@ -0,0 +1,45 @@
+from osoba import Osoba
+
+
+class Pracownik(Osoba):
+    def __init__(
+        self,
+        pesel: str,
+        imie: str,
+        nazwisko: str,
+        miejsce_zatrudnienia: str,
+        wzrost: float = 0.0,
+        waga: float = 0.0,
+        pensja: float = 0.0,
+    ) -> None:
+        super().__init__(pesel, imie, nazwisko, wzrost, waga)
+        self.__miejsce_zatrudnienia = miejsce_zatrudnienia
+        self.__pensja = pensja
+
+    @property
+    def miejsce_zatrudnienia(self) -> str:
+        return self.__miejsce_zatrudnienia
+
+    @miejsce_zatrudnienia.setter
+    def miejsce_zatrudnienia(self, nowe_miejsce: str):
+        if nowe_miejsce:
+            self.__miejsce_zatrudnienia = nowe_miejsce
+            return
+        nowe_miejsce = ""
+
+    @property
+    def pensja(self) -> float:
+        return self.__pensja
+
+    @pensja.setter
+    def pensja(self, nowa_pensja: float) -> None:
+        if nowa_pensja >= 0:
+            self.__pensja = nowa_pensja
+            return
+        self.__pensja = 0
+
+    def __str__(self):
+        return f"{super().__str__()} | Miejsce zatrudnienia: {self.__miejsce_zatrudnienia} "
+
+    def __repr__(self):
+        return f"Pracownik(pesel={super().pesel}, imie={super().imie}, nazwisko={super().nazwisko}, miejsce_zatrudnienia={self.miejsce_zatrudnienia}, wzrost={super().wzrost}, waga={super().waga}, pensja={self.pensja})"