bla bla

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

@@ -219,3 +219,30 @@ Centralne twierdzenie graniczne — jeśli ciąg zmiennych losowych $Y_{n\space
 Twierdzenie Lindberga - Levy'ego i Moivre'a - Laplace'a
 
 Elementy statystyki opisowej
+
+# Szereg statystyczny
+- Prosty – uporządkowany niemalejąco
+- Punktowy – dla cech skokowych (na wykresie kropki)
+- Przedziałowy – dla cech ciągłych (na wykresie takie prostokąciki)
+
+# Statystyka i estymacja
+## Definicje
+- Cecha – zmienna losowa
+- Badanie próbne – wysoce wiarygodne, ale estymowane na podstawie próbki, więc nieidealne
+- Estymacja – policzenie próbki i uogólnienie wyników
+- Weryfikacja hipotez
+
+- Próba losowa prosta – mamy zmienną losową X. Ciąg zmiennych $X_1$, $X_2$, ..., nazywamy n-elementową statystyczną próba losowa prosta. Jeśli zmienne są niezależnie i rozkłada $X_i$ nie jest taki sam jak rozkład X.
+- Statystyka – dowolna funkcja statystyczna
+
+## Średnia z próby
+Przy zmiennych losowych o rozkładzie normalnym, średnia artymetyczna z próby ma rozkład normalny.
+
+
+## Estymacja punktowa
+Mamy nieznane $\theta$ rozkładu zmiennej losowej X.
+Estymator $\theta$ rozkładu zmiennej X nazywamy dowolną statystyką, której wartości przyjmujemy za ocenę wielkości parametru $\theta$
+
+Używając lepszego estymatora otrzymujemy większą dokładność.
+
+Sprawdzenie efektywności umożliwia nierówność Rao-Cramera.

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

@@ -0,0 +1,88 @@
+# zadanie 1 | zmienne ciągłe
+n = 130
+m = 7
+sig = 1/2
+
+# P(x1 + x2 + ... + xn > 900)
+
+pnorm(900, n * m, sig * sqrt(n), F) # 0.9602947
+
+# zadanie 2 na kolokwium | zmienne skokowe
+n = 2000
+p = 0.002
+q = 1 - p
+
+# a)
+# P(6 <= Sn <= 12)
+# rozkład dwumianowy
+sum(dbinom(6:12, n, p)) # 0.2144444
+
+# rozkład poissona
+sum(dpois(6:12, n * p)) # 0.2145959
+
+# b)
+# P(Sn >= 1992)
+n = 2000
+q = 0.002
+p = 1 - q
+
+# rozkład dwumianowy
+sum(dbinom(1992:2000, n, p)) # 0.9787556
+
+# CTG P(Sn >= 1992) = P(Sn >= 1991.5)
+pnorm(1991.5, n * p, sqrt(n * p * q), F) # 0.9878469
+
+# zadanie 3 | zmienne ciągłe
+n = 500 / 2
+m = 1.99
+sig = 0.05
+
+# P(x1 + x2 ... + xn < 500)
+pnorm(500, n * m, sig * sqrt(n)) # 0.9992173
+
+# zadanie 4
+n = 1000 # ok
+p = 0.525 # nie ok
+q = 1 - p
+
+# P(450 < Sn < 520)
+# P(451 <= Sn <= 519)
+
+sum(dbinom(451:519, n, p)) # 0.3636469
+# nie można użyć poissona
+pnorm(519.5, n * m, sqrt(n * p * q)) - pnorm(450.5, n * m, sqrt(n * p * q))
+
+# zadanie 5
+n = 1200
+p = 0.08
+q = 1 - p
+
+# P(0.07 < Sn < 0.11)
+sum(dbinom(0.08:0.10, n, p))
+pnorm(0.10, n * p, sqrt(n * p * q)) - pnorm(0.08, n * p, sqrt(n * p * q)) # 2.053723e-26
+
+# zadanie 6
+n = 5000
+p = 0.01
+q = 1 - p
+
+z = 0.015 * n
+
+# n * p nie jest <= 10, więc nie można użyć poissona
+# P(x1 + ... + xn < z)
+sum(dbinom(1:z, n, p)) # 0.9996532
+pnorm(z, n * p, sqrt(n * p * q)) # 0.9998098
+# poprawka ctg
+pnorm(z - 0.5, n * p, sqrt(n * p * q)) # 0.9997514
+
+
+# zadania na kolokwium
+# 1. układ równań | lab1
+# 2. wektor wielokrotności i do potęgi i zliczyć ile elementów jest podzielnych przez jakieś wartości | lab1
+# 3. rozkład z listy nr 2 geometryczny albo dwumianowy
+# 4. rozkład normalny i prawdopodobieństwo z wartością bezwzględną | lab 3
+# 5. kwantyle | lab 3
+# 6. zadanie nr 2 tego co dzisiaj
+# 7. standaryzacja rozkładu normalnego, ale 1 niewiadoma (m/sig nieznane) | lab 4 i 5
+# 8. standaryzacja rozkładu normalnego, dwie niewiadome | lab 5
+

uczelnia/2_semestr/prawo_podatkowe/Prawo podatkowe.md

@@ -6,3 +6,46 @@ Będzie praca jakaś o prawie intelektualnym coś tam.
 
 Zaczynamy o 12:30
 
+Prawa:
+- autorskie
+- pokrewne
+- do baz danych
+- do odmian roślin i ras zwierząt
+- do farmaceutyków
+- do własności przemysłowej
+- zwalczanie nieuczciwej konkurencji
+
+Jak się chronić:
+- z mocy prawa w momencie powstania przedmiotu ochrony – prawa autorskie, pokrewne i bazy danych
+- prezerwatywy
+- ochrona urzędowa, rejestracyjna
+
+Geneza własności intelektualnej:
+- pojawienie się koncepcji – starożny Rzym Mercjalis (twórca plagiatu), Horacy(tworca praw majątkowych)
+- Średniowiecze – Masowe kradzieże autorastwa, oprócz da Vinciego. Znaczenie zyskały znaki towarowe, przynależność cechowa.
+- Renesans – opracowanie maszyny drukarskiej i upowszechnienie druku, skutkuje powstaniem przywilejów drukarskich.
+- Oświecenie – pierwsze przepisy o wlasności intelektualnej
+- IXX wiek  – nie wiem, za szybko zamknął
+- XX wiek – rozwój regulacji międzynarowdowych w tym konwencja o ustanowieniu czegoś tam, za szybko zamknął
+
+Dlaczego on mówi o ideologii średniowiecznej? Co to są za komentarze? Jakaś absurdalna teza, że bez średniowiecza rozwijalibyśmy się szybciej.  Otóż po pierwsze: jakby wyciąć z historii średniowiecze to nie rozwijalibyśmy się 200 lat szybciej tylko oświecenie zostaloby średniowieczem. Po drugie: to nie jest miejsce na takie dziwne komentarze.
+Jestem oburzony.
+
+Jakbyśmy się rozebrali do bielizny to, nie licząc majtek i skarpetek, nic nie byłoby z unii europejskiej. (Jaka jest bielizna oprócz majtek i skarpetek? Biustonosz? Tego akurat nie noszę)
+
+Producenci tworzą słabe towary, za drogo i jest niedobrze, więc ludzie sięgają po podróbki.
+
+Utwór to – każdy przejaw działalności twórczej o indywidualnym charakterze, ustalony w jakiejkolwiek postaci , niezależnie od wartości, przeznaczenia i sposobu wyrażenia.
+
+Ochronę nie są objęte odkrycia, idee i koncepcje matematyczne, bo jebać matematyków, chuj im w dupe!
+
+Rodzaje utworów:
+- wspólne
+- zależne
+- zbiorowe
+
+Tantiemy – pieniądze za każde wykonanie utworu
+
+Teraz streszcza jakiś film amerykański.
+
+Hejtuje ring of pala, bardzo dobrze.

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

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+class Prostokat {
+public:
+  double szerokosc;
+  double wysokosc;
+  double pole() { return szerokosc * wysokosc; }
+  double obwod() { return 2 * szerokosc + 2 * wysokosc; }
+};
+
+int main() {
+  Prostokat p1;
+  p1.szerokosc = 2;
+  p1.wysokosc = 2;
+  double pole = p1.pole();
+  double obwod = p1.obwod();
+  printf(
+      "Pole o szerokości %0.2f i wysokości %0.2f ma pole %0.2f i obwód %0.2f", 
+      p1.szerokosc, p1.wysokosc, pole, obwod);
+}

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

@@ -0,0 +1,35 @@
+#include <stdexcept>
+#include <stdio.h>
+
+class Konto {
+  static int liczbaKont;
+  float saldo;
+
+public:
+  Konto(int saldoPoczatkowe) : saldo(saldoPoczatkowe) { Konto::liczbaKont++; }
+  void wplac(float pieniadze) { saldo += pieniadze; }
+  void wyplac(float pieniadze) {
+    if (saldo - pieniadze <= 0) {
+      throw std::invalid_argument(
+          "Saldo po wypłacie nie może być mniejsze niż 0!!!\n");
+    }
+    saldo -= pieniadze;
+  }
+  void pokazSaldo() { printf("Aktualne saldo to: %0.2f\n", saldo); }
+
+  static void ileKont() {
+    printf("Aktualnie jest %d kont\n", Konto::liczbaKont);
+  }
+};
+
+int Konto::liczbaKont = 0;
+
+int main() {
+  Konto::ileKont();
+  Konto k1 = Konto(20);
+  Konto::ileKont();
+  Konto k2 = Konto(20);
+  Konto::ileKont();
+  Konto k3 = Konto(20);
+  Konto::ileKont();
+}

uczelnia/2_semestr/programowanie/laby/lab6/zad11.cpp

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <string>
+
+class Produkt {
+public:
+  std::string nazwa;
+  float cena;
+  Produkt(std::string nazwa, float cena) : nazwa(nazwa), cena(cena) {}
+  Produkt() : nazwa(""), cena(0) {}
+
+  const Produkt &operator=(const Produkt *p) {
+    if (this != p) {
+      nazwa = p->nazwa;
+      cena = p->cena;
+    }
+    return *this;
+  }
+};
+
+class Magazyn {
+public:
+  Produkt *produkty;
+  size_t max_pojemnosc;
+  size_t aktualna_pojemnosc;
+
+  Magazyn(size_t pojemnosc) {
+    this->max_pojemnosc = pojemnosc;
+    this->aktualna_pojemnosc = 0;
+    produkty = new Produkt[pojemnosc];
+  }
+  ~Magazyn() { delete[] produkty; }
+
+  void dodaj(const Produkt &p) {
+    if (aktualna_pojemnosc >= max_pojemnosc) {
+      printf("Nie można dołożyć elementu, za mało miejsca\n");
+      return;
+    }
+
+    produkty[aktualna_pojemnosc++] = p;
+  }
+
+  Produkt *znajdz(std::string nazwa) {
+    for (size_t i = 0; i < aktualna_pojemnosc; i++) {
+      if (produkty[i].nazwa == nazwa) {
+        return &produkty[i];
+      }
+    }
+    return nullptr;
+  }
+
+  void wypiszWszystkie() const {
+    for (size_t i = 0; i < aktualna_pojemnosc; i++) {
+      printf("Nazwa: %s | Cena: %0.2f\n", produkty[i].nazwa.c_str(),
+             produkty[i].cena);
+    }
+  }
+};
+
+int main() {
+  Magazyn m(5);
+  m.dodaj(Produkt("Laptop", 3500.0));
+  m.dodaj(Produkt("Mysz", 49.99));
+  m.dodaj(Produkt("Klawiatura", 129.0));
+  Produkt *p = m.znajdz("Mysz");
+  if (p != nullptr) {
+    p->cena = 39.99; // zmiana przez wskaźnik
+  }
+  m.wypiszWszystkie();
+}

uczelnia/2_semestr/programowanie/laby/lab6/zad12.cpp

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <string>
+#include <vector>
+
+class Student {
+  std::string imie;
+  std::vector<double> oceny;
+
+public:
+  Student(std::string imie) : imie(imie) {}
+
+  void dodajOcene(double ocena) { oceny.push_back(ocena); }
+  double srednia() const {
+    double sum = 0;
+    for (double ocena : oceny) {
+      sum += ocena;
+    }
+    double avg = sum / oceny.size();
+    return avg;
+  }
+
+  void wypisz() const {
+    printf("Imie %s\n", imie.c_str());
+    printf("Oceny:\n");
+    for (double ocena : oceny) {
+      printf("- %0.1f\n", ocena);
+    }
+    printf("Średnia: %0.2f\n", srednia());
+  }
+};
+
+class Dziennik {
+  std::vector<std::reference_wrapper<Student>> studenci;
+
+public:
+  void zarejestruj(Student &s) { studenci.push_back(s); }
+  void dodajOceneWszystkim(double ocena) {
+    for (Student &student : studenci) {
+      student.dodajOcene(ocena);
+    }
+  }
+
+  void raport() const {
+    printf("--- Wszyscy studenci ---\n");
+    for (const Student student : studenci) {
+      student.wypisz();
+    }
+  }
+};
+
+int main() {
+  Student s1 = Student("Bogdan");
+  Student s2 = Student("Wojciech");
+
+  Dziennik dziennik = Dziennik();
+  dziennik.zarejestruj(s1);
+  dziennik.zarejestruj(s2);
+  dziennik.dodajOceneWszystkim(5);
+  dziennik.raport();
+}

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

@@ -0,0 +1,22 @@
+class Prostokat {
+private:
+  double szerokosc;
+  double wysokosc;
+
+public:
+  Prostokat(double szerokosc, double wysokosc)
+      : szerokosc(szerokosc), wysokosc(wysokosc) {}
+  double pole() { return szerokosc * wysokosc; }
+  double obwod() { return 2 * szerokosc + 2 * wysokosc; }
+  double getSzerokosc() { return szerokosc; }
+  double getWysokosc() { return wysokosc; }
+};
+
+int main() {
+  Prostokat p1 = Prostokat(2, 2);
+  // p1.szerokosc = 4; taka operacja jest nieakceptowalna albowiem skrajnie
+  // nierozsądnym i można powiedzieć __nieakceptowalnym__ jest próba przypisania 
+  // wartości do pola oznaczonego mianem prywatnego. Na szczęście jaśnie 
+  // oświecony kompilator języka c++ powstrzymuje nas przed takim godnym 
+  // potępienia występkiem.
+}

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

@@ -0,0 +1,20 @@
+#include <iostream>
+
+class Licznik {
+  int wartosc;
+
+public:
+  Licznik() : wartosc(0) {}
+  void dodaj() { wartosc++; }
+  int ile() const { return wartosc; }
+};
+int main() {
+  Licznik a; // 0
+  Licznik b; // 0
+  a.dodaj(); // 1
+  a.dodaj(); // 2
+  a.dodaj(); // 3
+  b.dodaj(); // 1
+  std::cout << a.ile() << " " << b.ile()
+            << "\n"; // a.ile() == 2 && b.ile() == 1
+}

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

@@ -0,0 +1,22 @@
+#include <iostream>
+
+class Kalkulator {
+public:
+  void podwoj(int x) { x *= 2; }
+  void podwojRef(int &x) { x *= 2; }
+  void zamien(int &a, int &b) {
+    int tmp = a;
+    a = b;
+    b = tmp;
+  }
+};
+int main() {
+  Kalkulator k;
+  int a = 5, b = 10;
+  k.podwoj(a); // a = 5
+  std::cout << a << std::endl;
+  k.podwojRef(a); // a = 10
+  std::cout << a << std::endl;
+  k.zamien(a, b); // a = 10, b = 10
+  std::cout << a << ' ' << b << std::endl;
+}

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

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <vector>
+class Tablica {
+  std::vector<int> tablica;
+
+public:
+  void dodaj(int x) { tablica.push_back(x); }
+
+  void wypelnij(std::vector<int> &cel) {
+    cel.insert(cel.end(), tablica.begin(), tablica.end());
+  }
+
+  int suma() const {
+    int sum = 0;
+    for (int element : tablica) {
+      sum += element;
+    }
+    return sum;
+  }
+
+  void wyczysc() { tablica.clear(); }
+
+  void wyswietl() {
+    for (int element : tablica) {
+      std::cout << element << ' ';
+    }
+
+    std::cout << std::endl;
+  }
+};
+
+int main() {
+  Tablica t;
+  t.dodaj(3);
+  t.wyswietl();
+  t.dodaj(7);
+  t.wyswietl();
+  t.dodaj(1);
+  t.wyswietl();
+  std::vector<int> kopia;
+  t.wypelnij(kopia);
+  std::cout << "Kopia: " << std::endl;
+  for (int element : kopia) {
+    std::cout << element << ' ';
+  }
+  std::cout << std::endl;
+  // kopia zawiera: 3, 7, 1
+  int suma = t.suma();
+  std::cout << "Suma wynosi: " << suma << std::endl;
+  t.wyczysc();
+  t.wyswietl();
+}

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

@@ -0,0 +1,25 @@
+#include <iostream>
+
+class Licznik {
+  int wartosc;
+
+public:
+  Licznik(int w) : wartosc(w) {}
+  void zwieksz() { wartosc++; }
+  int pobierz() const { return wartosc; }
+  void resetuj() { wartosc = 0; }
+};
+int main() {
+  Licznik a(10);
+  Licznik *wsk = &a;
+  wsk->zwieksz();
+  std::cout << a.pobierz() << '\n';    // 11 (linia A)
+  std::cout << wsk->pobierz() << '\n'; // 11 (linia B)
+  Licznik b(100);
+  wsk = &b;
+  wsk->zwieksz();
+  std::cout << a.pobierz() << '\n'; // 11 (linia C)
+  std::cout << b.pobierz() << '\n'; // 101 (linia D)
+  a.resetuj();
+  std::cout << a.pobierz(); // 0
+}

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

@@ -0,0 +1,48 @@
+#include <iostream>
+
+class Punkt {
+public:
+  int x, y;
+  Punkt(int x, int y) : x(x), y(y) {}
+
+  void wyswietl() { std::cout << '(' << x << ',' << y << ')' << std::endl; }
+};
+
+void zamienRef(Punkt &a, Punkt &b) {
+  int x = a.x;
+  int y = a.y;
+  int i = b.x;
+  int j = b.y;
+  a.x = i;
+  a.y = j;
+  b.x = x;
+  b.y = y;
+}
+
+void zamienWsk(Punkt *a, Punkt *b) {
+  int x = a->x;
+  int y = a->y;
+  int i = b->x;
+  int j = b->y;
+  a->x = i;
+  a->y = j;
+  b->x = x;
+  b->y = y;
+}
+
+int main() {
+  std::cout << "Punkty: " << std::endl;
+  Punkt p1(1, 2), p2(3, 4);
+  p1.wyswietl();
+  p2.wyswietl();
+  std::cout << "Zamiana referencją: " << std::endl;
+  zamienRef(p1, p2); // wywołanie przez referencję
+                     //
+  p1.wyswietl();
+  p2.wyswietl();
+
+  std::cout << "Zamiana wskaźnikiem: " << std::endl;
+  zamienWsk(&p1, &p2); // wywołanie przez wskaźnik
+  p1.wyswietl();
+  p2.wyswietl();
+}

uczelnia/2_semestr/programowanie/laby/lab6/zad7_2.cpp

@@ -0,0 +1,11 @@
+#include <string>
+
+class Samochod {
+  std::string marka;
+  int predkosc;
+
+  Samochod(std::string marka, int predkosc) {
+    this->marka = marka;
+    this->predkosc = predkosc;
+  }
+};

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

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+class Pies {
+public:
+  static int liczba;
+  Pies() { Pies::liczba++; }
+};
+
+int Pies::liczba = 0;
+
+int main() {
+  printf("Aktualnie jest %d psów\n", Pies::liczba); 
+  Pies p1 = Pies();
+  printf("Aktualnie jest %d psów\n", Pies::liczba); 
+  Pies p2 = Pies();
+  printf("Aktualnie jest %d psów\n", Pies::liczba); 
+  Pies p3 = Pies();
+  printf("Aktualnie jest %d psów\n", Pies::liczba); 
+}

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

@@ -0,0 +1,40 @@
+#include <stdexcept>
+#include <stdio.h>
+
+class Konto {
+  float saldo;
+
+public:
+  Konto(int saldoPoczatkowe) : saldo(saldoPoczatkowe) {}
+  void wplac(float pieniadze) { saldo += pieniadze; }
+  void wyplac(float pieniadze) {
+    if (saldo - pieniadze <= 0) {
+      throw std::invalid_argument(
+          "Saldo po wypłacie nie może być mniejsze niż 0!!!\n");
+    }
+    saldo -= pieniadze;
+  }
+  void pokazSaldo() { printf("Aktualne saldo to: %0.2f\n", saldo); }
+};
+
+int main() {
+  float n = 200;
+  printf("Tworzymy konto z saldem początkowym %0.2f\n", n);
+  Konto k = Konto(n);
+  k.pokazSaldo();
+
+  printf("Wypłacamy 100 zł\n");
+  k.wyplac(100);
+  k.pokazSaldo();
+
+  printf("Wpłacamy 50 zł\n");
+  k.pokazSaldo();
+
+  printf("Próbujemy wypłacić 6769 złoty\n");
+
+  try {
+    k.wyplac(6769);
+  } catch (std::invalid_argument &ex) {
+    printf("Nie wolno wypłacić aż tyle pieniędzy! %s", ex.what());
+  }
+}

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

uczelnia/2_semestr/techniki_cyfrowe/Technika cyfrowa.md

@@ -12,4 +12,6 @@ Nudy gówno tralalalalalal
 
 rlc sratata
 
-Czas propagacji na wykresie czasu to przesunięcie zielonej linii.
+Czas propagacji na wykresie czasu to przesunięcie zielonej linii.
+
+Verlilog, jakaś płytka z diodą