Merge branch 'master' of github.com:szymon-jozef/ZUT-notatki

uczelnia/2_semestr/matematyka_dyskretna/wykład 18.md

@@ -0,0 +1,3 @@
+Permutacją zbioru nazywamy dowolną iniekcję sigma an do an. Zbiór wszystkich permutacji zbioru an oznaczamy Sn z działaniem składania funkcji jest grupą.
+
+Grupa ma dobre dzialania :D

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

@@ -1,6 +1,4 @@
 # Spis tematów
-Oto uporządkowana lista tematów, które pojawiają się w przesłanych przez Ciebie notatkach. Zostały one pogrupowane w logiczne kategorie:
-
 **1. Podstawy rachunku prawdopodobieństwa i zdarzenia losowe**
 
 - Przestrzeń zdarzeń elementarnych (Ω) i pojedyncze zdarzenia elementarne (ω)
@@ -289,3 +287,20 @@ $$
 $\chi^2-2.5 e K$, więc na poziomie istotności 0.05 odrzucamy $H_0$ 
 
 
+# Analiza wariancji
+Pobieramy próbki
+$x_{ij}$ j - ty wynik w  i-tej próbce
+Średnia
+Średnia ogólna – średnia ze wszystkich wyników razem (średnia ważona w grupach)
+Analiza wariancji opiera się na obserewacji Karla Pearcena – jakbyśmy policzyli sumy kwadratów i odjęli średnią ogólną to rozbijemy to ona mierzy zmienność między próbkami. Suma kwadratów odchyleń według grup (resztkowa suma kwadratów) $= q_G$
+Suma odchyleń kwadratów między próbami $= q_P$
+Wszystkie q traktujemy jako realizacje zmiennych losowych Q z indeksem odpowiednim do q.
+Rozkład fishera snedekora.
+
+Test Barteletta jednorodności w wariancji w k populacji.
+Zał: 
+- Jednakowe wariancje
+- Rozkład normalny
+
+Test rangowych znaków dla jednej populacji
+Rangowanie polega na nadawaniu rang wartościom. Przy identycznych wartościach nadajemy średnią artmetyczną rang, które przypadałaby na te wartości.

uczelnia/2_semestr/matematyka_stosowana/laby/lab_9.R

@@ -0,0 +1,122 @@
+# zadanie 1
+
+# a)
+
+# założenie: normalność rozkładu – test shapiro-wilka
+
+# hipoteza podstawowa h0 – rozkład wzrostu w populacji mężczyzn jest normalny
+# hipoteza h1 – nieprawda, że h0
+
+shapiro.test(Ankieta.M$Wzrost)
+# Statystyka testowa W = 0.9598, p-value = 0.04048
+# alpha = 0.01 # poziom istotności
+# wniosek alpha < p-value, więc na poziomie istotności 0.01 nie ma podstaw do odrzucenia h0, że rozkład wzrostu w populacji mężczyzn jest zgodny z rozkładem normalnym.
+
+# b)
+# przedzial ufności dla wartości średniej w populacji (mężczyzn)
+t.test(Ankieta.M$Wzrost, conf.level = 0.95)
+#  178.0049 181.6403
+
+# interpretacja: przedział liczbowy od 178.0049 do 181.6403 z prawdopodobieństwem 0.95 obejmuje nieznaną wartość średnią wzrostu w populacji mężczyzn studiujących na pierwszym roku WI ZUT w Szczecinie w tym roku akademickim (2025/2026)
+
+t.test(Ankieta.M$Wzrost, conf.level = 0.98)
+#  177.6509 181.9942
+
+# ze wzrostem współczynnika ufności poszerza się przedział ufności
+
+# c)
+# przedział ufności dla odchylenia standardowego w populacji m.
+
+przedzial.odchylenie = function(x, uf) {
+  # 1 - a = uf
+  # a = 1 - uf
+  a = 1 - uf
+  n = length(x)
+  ss_z_daszkiem = var(x)
+  # s^2 = (n - 1)/n * ss_z_daszkiem
+  ss = (n - 1)/n * ss_z_daszkiem
+  
+  dolna = sqrt((n * ss) / qchisq(1 - (a / 2), n - 1))
+  gorna = sqrt((n * ss) / qchisq(a / 2, n - 1))
+  round(cbind(dolna, gorna), 4)
+}
+
+przedzial.odchylenie(Ankieta.M$Wzrost, 0.97)
+# 5.9801 8.8895
+
+# interpretacja: przedzial o końcach 5.9801 i 8.8895 [cm] z ufnością 0.97 obejmuje rzeczywistą wartość odchylenia standardowego wzrostu w populacji mężczyzn studiujących na pierwszym roku WI ZUT w Szczecinie w tym roku akademickim.
+
+# d)
+# test dla wartości średniej w populacji 
+# hipoteza h0: m = 180
+# hipoteza h1: m > 180
+t.test(Ankieta.M$Wzrost, mu = 180, alternative = 'g')
+# statystyka testowa t = -0.19518, df = 61, p-value = 0.577
+# alpha = 0.01
+# alpha < p-value, więc
+# na poziomie istotności 0.01 nie ma podstaw do odrzucenia hipotezy h0. Nie można zatem potwierdzić hipotezy, że średni wzrost mężczyzn w badanej populacji jest większy niż 180 cm.
+
+
+# zadanie 2
+
+table(Ankieta$Sz.średnia)
+# LO(RM) = 22
+
+# a)
+# przedział ufności dla odsetka (wskaźnika struktury, frakcji, procentu, proporcji) 
+prop.test(22, 72, conf.level = 0.98)
+#  0.1909 0.4489
+# te końce nie mają jednostek!
+
+# interpretacja: przedział o końcach 0.1909 i 0.4489 z ufnością 0.98 obejmuje rzeczywistą wartość odsetka osób, które ukończyły LO(RM) w badanej populacji.
+
+# b)
+# test dla wskaźnika struktury 
+# hipoteza h0: p = 45%
+# hipoteza h1: p < 45%
+prop.test(22, 72, p = 0.45, alternative = 'l')
+# statystyka testowa – X-squared = 5.5, df = 1, p-value = 0.009508
+# alpha = 0.05
+# alpha > p-value, więc
+# odrzucamy h0
+
+# Alpha jest większa niż p-value, więc na poziomie istotności 0.05 odrzucamy hipotezę h0 i przyjmujemy h1, zatem odsetek osób, które ukończyły LO(RM) w badanej populacji studentów jest istotnie mniejszy, niż 45%.
+
+# zadanie 3
+
+# a)
+# hipoteza h0: rozkład wagi w populacji kobiet jest normalny
+# hipotezea h1: rozkład wagi w populacji kobiet nie jest normalny
+
+shapiro.test(Ankieta.K$Waga)
+# W = 0.94975, p-value = 0.6656
+# alpha = 0.05
+# alpha < p-value, więc
+# na poziomie istotności 0.05  nie ma podstaw do odrzucenia h0, że rozkład wagi w populacji kobiet jest normalny
+
+# b)
+t.test(Ankieta.K$Waga, conf.level = 0.98)
+#  49.34915 63.85085
+
+# interpretacja: przedział o końcach 49.34915 i 63.85085 [kg] z ufnością 0.98 zawiera rzeczywistą wartość średniej wagi w populacji wszystkich kobiet studiujących na I roku WI 
+
+# zadanie 4
+# a)
+
+table(Ankieta$M.zamieszkania)
+# akademik = 23
+prop.test(23, 72, conf.level = 0.995)
+#  0.1842 0.4918
+
+# interpretacja: przedział o końcach 0.1842 i 0.4918 z ufnością 0.995 obejmuje rzeczywistą wartość odestka osób, które mieszkają w akademiku podczas studiowania  na pierwszym roku kierunku informatyka na WI ZUT w Szczecinie w tym roku akademickim
+
+# b)
+# hipoteza h0: p = 0.35
+# hipoteza h1: p != 0.35
+prop.test(23, 72, p = 0.35, alternative = 'two.sided')
+# X-squared = 0.17643, df = 1, p-value = 0.6745
+# alpha = 0.05
+# alpha < p-value, więc
+# odrzucamy h0
+
+# wniosek: Alpha jest mniejsze, niż p-value, więc nie ma podstaw do odrzucenia h0, że odsetek osób, które mieszkają w akademiku w populacji wszystkich studentów I roku na WI różnie się istotnie od 35%

uczelnia/2_semestr/programowanie/laby/lab10/zad1.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+
+class Zwierze {
+public:
+  virtual void odglos() { std::cout << "..." << std::endl; }
+  virtual ~Zwierze() = default;
+};
+
+class Pies : public Zwierze {
+public:
+  void odglos() override { std::cout << "Hau hau" << std::endl; }
+};
+
+class Kot : public Zwierze {
+public:
+  void odglos() override { std::cout << "Miau miau" << std::endl; }
+};
+
+class Krowa : public Zwierze {
+public:
+  void odglos() override { std::cout << "Muu muu" << std::endl; }
+};
+
+int main() {
+  const int SIZE = 3;
+  Zwierze *zwierzeta[SIZE];
+  zwierzeta[0] = new Pies();
+  zwierzeta[1] = new Kot();
+  zwierzeta[2] = new Krowa();
+
+  for (int i = 0; i < SIZE; i++) {
+    zwierzeta[i]->odglos();
+  }
+
+  for (int i = 0; i < SIZE; i++) {
+    delete zwierzeta[i];
+  }
+
+  return 0;
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad10.cpp

@@ -0,0 +1,121 @@
+#include <cstddef>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+class Adres {
+  std::string ulica;
+  int nr_mieszkania;
+
+public:
+  Adres(std::string ulica, int nr_mieszkania)
+      : ulica(ulica), nr_mieszkania(nr_mieszkania) {}
+
+  friend std::ostream &operator<<(std::ostream &os, const Adres &adres) {
+    os << adres.ulica << " mieszkania " << adres.nr_mieszkania;
+    return os;
+  }
+};
+
+class Pracownik {
+protected:
+  std::string imie;
+  float pensja;
+  std::unique_ptr<Adres> adres;
+
+public:
+  virtual float obliczWyplate() const = 0;
+
+  Pracownik(std::string imie, float pensja, std::unique_ptr<Adres> adres)
+      : imie(imie), pensja(pensja), adres(std::move(adres)) {}
+
+  virtual ~Pracownik() = default;
+
+  friend std::ostream &operator<<(std::ostream &os, const Pracownik &p) {
+    os << p.imie << " zarabia " << p.obliczWyplate() << " i mieszka na "
+       << *(p.adres);
+    return os;
+  }
+};
+
+class PracownikEtatowy : public Pracownik {
+public:
+  PracownikEtatowy(std::string imie, float pensja, std::unique_ptr<Adres> adres)
+      : Pracownik(imie, pensja, std::move(adres)) {}
+
+  float obliczWyplate() const override { return pensja; }
+};
+
+class Zleceniobiorca : public Pracownik {
+  float godziny;
+
+public:
+  Zleceniobiorca(std::string imie, float pensja, std::unique_ptr<Adres> adres,
+                 float godziny)
+      : Pracownik(imie, pensja, std::move(adres)), godziny(godziny) {}
+
+  float obliczWyplate() const override { return pensja * godziny; }
+};
+
+class Dzial {
+  std::vector<std::shared_ptr<Pracownik>> pracownicy;
+
+public:
+  Dzial() = default;
+
+  void dodajPracownika(std::shared_ptr<Pracownik> pracownik) {
+    pracownicy.push_back(pracownik);
+  }
+
+  float sumaWyplat() const {
+    float sum = 0;
+    for (const auto &pracownik : pracownicy) {
+      sum += pracownik->obliczWyplate();
+    }
+    return sum;
+  }
+
+  void wypiszPracownikow() const {
+    std::cout << "=== Wszyscy pracownicy ===\n";
+    for (const auto &pracownik : pracownicy) {
+      std::cout << *pracownik << std::endl;
+    }
+  }
+};
+
+class Kierownik : public PracownikEtatowy {
+  std::vector<std::shared_ptr<Pracownik>> podwladni;
+
+public:
+  Kierownik(std::string imie, float pensja, std::unique_ptr<Adres> adres)
+      : PracownikEtatowy(imie, pensja, std::move(adres)) {}
+
+  float obliczWyplate() const override { return pensja; }
+
+  float sumaWyplatZespolu() const {
+    float sum = 0;
+    for (const auto &pracownik : podwladni) {
+      sum += pracownik->obliczWyplate();
+    }
+    return sum;
+  }
+
+  void dodajPracownika(std::shared_ptr<Pracownik> p) { podwladni.push_back(p); }
+};
+
+int main() {
+  Kierownik kierownik("Stasiek", 238943,
+                      std::make_unique<Adres>("Wojska polskiego", 23));
+
+  kierownik.dodajPracownika(std::make_shared<PracownikEtatowy>(
+      "Bożena", 2500, std::make_unique<Adres>("Żołnierska", 18)));
+
+  kierownik.dodajPracownika(std::make_shared<Zleceniobiorca>(
+      "Adam", 6700, std::make_unique<Adres>("Wiejska", 1), 30));
+
+  std::cout << "Pracownicy sumarycznie zarabiają: "
+            << kierownik.sumaWyplatZespolu() << std::endl;
+
+  return 0;
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad2.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+
+class Baza {
+public:
+  void metoda() const { std::cout << "Baza" << std::endl; }
+};
+
+class Pochodna : public Baza {
+public:
+  void metoda() const { std::cout << "Pochodna" << std::endl; }
+};
+
+int main() {
+  Pochodna p;
+  Baza &ref = p;
+  Baza *ptr = &p;
+  p.metoda();    // pochodna
+  ref.metoda();  // baza
+  ptr->metoda(); // baza
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad3.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+
+class Baza {
+public:
+  virtual void metoda() const { std::cout << "Baza" << std::endl; }
+};
+
+class Pochodna : public Baza {
+public:
+  void metoda() const { std::cout << "Pochodna" << std::endl; }
+};
+
+int main() {
+  Pochodna p;
+  Baza b = p;
+  b.metoda(); // część pochodna została zgubiona
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad4.cpp

@@ -0,0 +1,54 @@
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+class Figura {
+public:
+  virtual float pole() const = 0;
+  virtual float obwod() const = 0;
+  virtual ~Figura() = default;
+};
+
+class Kolo : public Figura {
+  float r;
+
+public:
+  Kolo(float r) : r(r) {}
+
+  float pole() const override { return M_PI * r * r; }
+  float obwod() const override { return M_PI * 2 * r; }
+};
+
+class Prostokat : public Figura {
+  float a, b;
+
+public:
+  Prostokat(float a, float b) : a(a), b(b) {}
+
+  float pole() const override { return a * b; }
+  float obwod() const override { return 2 * a + 2 * b; }
+};
+
+class Trojkat : public Figura {
+  float a, b, c, h;
+
+public:
+  Trojkat(float a, float b, float c, float h) : a(a), b(b), c(c), h(h) {}
+
+  float pole() const override { return (a * h) * 0.5; }
+  float obwod() const override { return a + b + c; }
+};
+
+int main() {
+  std::vector<std::unique_ptr<const Figura>> figury;
+  figury.push_back(std::make_unique<Kolo>(2.0));
+  figury.push_back(std::make_unique<Prostokat>(2, 3));
+  figury.push_back(std::make_unique<Trojkat>(1, 2, 3, 4));
+
+  for (std::unique_ptr<const Figura> &element : figury) {
+    std::cout << "Obwod figury to: " << element->obwod() << std::endl;
+    std::cout << "Pole figury to: " << element->pole() << std::endl;
+    ;
+  }
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad5.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+
+class Abstrakcyjna {
+public:
+  virtual void f() = 0;
+  virtual ~Abstrakcyjna() = default;
+};
+
+class Konkretna : public Abstrakcyjna {
+public:
+  void f() override { std::cout << "OK"; }
+};
+
+int main() {
+  // Abstrakcyjna a;                      // nie kompiluje się, ponieważ a jest k
+  // lasą abstrakcyjną.
+  Konkretna k;                         // kompiluje
+  Abstrakcyjna *ptr = new Konkretna(); // kompiluje
+  Abstrakcyjna &ref = k;               // kompiluje
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad6.cpp

@@ -0,0 +1,32 @@
+#include <cstddef>
+#include <iostream>
+
+class Zasob {
+  int *arr;
+
+public:
+  Zasob(size_t size) : arr(new int[size]) { std::cout << "Alokujemy arr\n"; }
+
+  virtual ~Zasob() { // bez tego – wyciek pamięci
+    std::cout << "Destruktor virtualny\n";
+    delete[] arr;
+  }
+};
+
+class DuzyZasob : public Zasob {
+  int *arr2;
+
+public:
+  DuzyZasob(size_t size1, size_t size2) : Zasob(size1), arr2(new int[size2]) {
+    std::cout << "Alokujemy arr2\n";
+  }
+  ~DuzyZasob() override {
+    std::cout << "Domyślny Destruktor DużegoZasobu\n";
+    delete[] arr2;
+  }
+};
+
+int main() {
+  Zasob *z = new DuzyZasob(2, 4);
+  delete z;
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad7.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+class Ksztalt {
+public:
+  virtual double pole() const = 0;
+  virtual ~Ksztalt() = default;
+};
+
+class Kolo : public Ksztalt {
+  double r;
+
+public:
+  Kolo(double promien) : r(promien) {}
+  double pole() const { return 3.14 * r * r; }
+};
+
+void wypisz(Ksztalt &k) { std::cout << k.pole(); }
+
+int main() {
+  Kolo k = Kolo(2);
+  wypisz(k);
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad8.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <ostream>
+#include <string>
+
+class Pojazd {
+public:
+  virtual std::string opis() = 0;
+  virtual ~Pojazd() = default;
+
+  friend std::ostream &operator<<(std::ostream &os, Pojazd &p) {
+    os << p.opis();
+    return os;
+  }
+};
+
+class Samochod : public Pojazd {
+public:
+  std::string opis() override { return "To jest samochód"; }
+};
+
+class Rower : public Pojazd {
+public:
+  std::string opis() override { return "To jest rower"; }
+};
+
+int main() {
+  Samochod s;
+  Rower r;
+  std::cout << s << std::endl;
+  std::cout << r << std::endl;
+}

uczelnia/2_semestr/programowanie/laby/lab10/zad9.cpp

@@ -0,0 +1,96 @@
+#include <cstddef>
+#include <iostream>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+class Adres {
+  std::string ulica;
+  int nr_mieszkania;
+
+public:
+  Adres(std::string ulica, int nr_mieszkania)
+      : ulica(ulica), nr_mieszkania(nr_mieszkania) {}
+
+  friend std::ostream &operator<<(std::ostream &os, Adres &adres) {
+    os << adres.ulica << " mieszkania " << adres.nr_mieszkania;
+    return os;
+  }
+};
+
+class Pracownik {
+protected:
+  std::string imie;
+  float pensja;
+  std::unique_ptr<Adres> adres;
+
+public:
+  virtual float obliczWyplate() = 0;
+  Pracownik(std::string imie, float pensja, std::unique_ptr<Adres> adres)
+      : imie(imie), pensja(pensja), adres(std::move(adres)) {}
+  virtual ~Pracownik() = default;
+  friend std::ostream &operator<<(std::ostream &os, Pracownik &p) {
+    os << p.imie << " zarabia " << p.obliczWyplate() << " i mieszka na "
+       << *(p.adres);
+    return os;
+  }
+};
+
+class PracownikEtatowy : public Pracownik {
+
+public:
+  PracownikEtatowy(std::string imie, float pensja, std::unique_ptr<Adres> adres)
+      : Pracownik(imie, pensja, std::move(adres)) {}
+
+  float obliczWyplate() override { return pensja; }
+};
+
+class Zleceniobiorca : public Pracownik {
+  float godziny;
+
+public:
+  Zleceniobiorca(std::string imie, float pensja, std::unique_ptr<Adres> adres,
+                 float godziny)
+      : Pracownik(imie, pensja, std::move(adres)), godziny(godziny) {}
+  float obliczWyplate() override { return pensja * godziny; }
+};
+
+class Dzial {
+  std::vector<std::shared_ptr<Pracownik>> pracownicy;
+
+public:
+  Dzial() {};
+
+  void dodajPracownika(std::shared_ptr<Pracownik> pracownik) {
+    pracownicy.push_back(pracownik);
+  }
+
+  float sumaWyplat() const {
+    float sum = 0;
+    for (auto &pracownik : pracownicy) {
+      sum += pracownik->obliczWyplate();
+    }
+    return sum;
+  }
+
+  void wypiszPracownikow() const {
+    std::cout << "=== Wszyscy pracownicy ===\n";
+    for (const auto &pracownik : pracownicy) {
+      std::cout << *pracownik << std::endl;
+    }
+  }
+};
+
+int main() {
+  Dzial dzial = Dzial();
+  dzial.dodajPracownika(std::make_shared<PracownikEtatowy>(
+      "Bożena", 2500, std::make_unique<Adres>("Żołnierska", 18)));
+
+  dzial.dodajPracownika(std::make_shared<Zleceniobiorca>(
+      "Adam", 6700, std::make_unique<Adres>("Wiejska", 1), 30));
+
+  dzial.wypiszPracownikow();
+  std::cout << "Pracownicy sumarycznie zarabiają: " << dzial.sumaWyplat();
+  return 0;
+}

uczelnia/2_semestr/python/laby/9/zad1.py

@@ -0,0 +1,14 @@
+class PowerOfTwo:
+    def __init__(self, exp) -> None:
+        self.exp = exp
+
+    def __call__(self) -> int:
+        result: int = 2**self.exp
+        self.exp += 1
+        return result
+
+
+if __name__ == "__main__":
+    power = PowerOfTwo(1)
+    for _ in range(10):
+        print(power())

uczelnia/2_semestr/python/laby/9/zad2.py

@@ -0,0 +1,23 @@
+class PowerOfNumber:
+    def __init__(
+        self, number: int, exp: int, min_exp: int = 0, max_exp: int = 10
+    ) -> None:
+        self.exp: int = exp
+        self.number: int = number
+        self.min_exp: int = min_exp
+        self.max_exp: int = max_exp
+
+    def __call__(self) -> int | None:
+        if self.min_exp < self.exp < self.max_exp:
+            result: int = self.number**self.exp
+            self.exp += 1
+            return result
+        return None
+
+
+if __name__ == "__main__":
+    power = PowerOfNumber(3, 1)
+    for _ in range(20):
+        result: int | None = power()
+        if result:
+            print(result)

uczelnia/2_semestr/python/laby/9/zad3.py

@@ -0,0 +1,11 @@
+from typing import Generator
+
+
+def power_of_number(number: int, min_exp: int = 0, max_exp: int = 10) -> Generator[int]:
+    for i in range(min_exp, max_exp):
+        yield number**i
+
+
+if __name__ == "__main__":
+    for i in power_of_number(4):
+        print(i)

uczelnia/2_semestr/python/laby/9/zad4.py

@@ -0,0 +1,94 @@
+from random import randint
+
+
+class DList:
+    class Element:
+        def __init__(self, value, next=None, prev=None):
+            self.__value = value
+            self.next = next
+            self.prev = prev
+
+        @property
+        def value(self):
+            return self.__value
+
+    def __init__(self, args: list[int]) -> None:
+        self.__root = None
+        self.__end = None
+        for i in args:
+            self.insert(i)
+
+    def insert(self, value: int) -> None:
+        new_element = self.Element(value)
+
+        if self.__root is None:
+            self.__root = new_element
+            self.__end = new_element
+            return
+
+        current = self.__root
+
+        while current is not None and current.value < value:
+            current = current.next
+
+        if current == self.__root:
+            new_element.next = self.__root
+            self.__root.prev = new_element
+            self.__root = new_element
+        elif current is None:
+            new_element.prev = self.__end
+            self.__end.next = new_element
+            self.__end = new_element
+        else:
+            new_element.next = current
+            new_element.prev = current.prev
+            current.prev.next = new_element
+            current.prev = new_element
+
+    def __iter__(self):
+        curr = self.__root
+        while curr is not None:
+            yield curr.value  # - zwraca generator
+            curr = curr.next
+
+    def __reversed__(self):
+        curr = self.__end
+        while curr is not None:
+            yield curr.value
+            curr = curr.prev
+
+    def __contains__(self, value):
+        current = self.__root
+        while current is not None and current.value < value:
+            current = current.next
+        return current is not None and current.value == value
+
+
+# - - - - - - - - - - - - - - - - - TESTY - - - - - - - ----------
+dlista = DList([2, 3, 4, 5])
+for i in dlista:
+    print(i)
+print("\n - - - - - - - -\n")
+
+dlista = DList([8, 10, 9, 13])
+dlista.insert(7)
+dlista.insert(12)
+dlista.insert(15)
+
+for i in reversed(dlista):
+    print(i)
+
+print("\n - - - - - - - -\n")
+print(" Contain 8: ", 8 in dlista)
+print(" Contain 13: ", 13 in dlista)
+print(" Contain 15: ", 15 in dlista)
+print(" Contain 6: ", 6 in dlista)
+print(" Contain 11: ", 11 in dlista)
+print(" Contain 17: ", 17 in dlista)
+
+nowa_lista = DList([])
+for i in range(1000):
+    nowa_lista.insert(randint(0, 100))
+
+for i in nowa_lista:
+    print(i)

uczelnia/2_semestr/techniki_cyfrowe/Technika cyfrowa.md

@@ -14,4 +14,5 @@ rlc sratata
 
 Czas propagacji na wykresie czasu to przesunięcie zielonej linii.
 
-Verlilog, jakaś płytka z diodą
+Verlilog, jakaś płytka z diodą
+