introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "## Numeryczne Rozwiązywanie Równań Różniczkowych Zwyczajnych\n",
    "### Uniwersytet Jagielloński 2023\n",
    "Katedra Teorii Optymalizacji i Sterowania UJ"
   ],
   "metadata": {
    "id": "qU8WuZMu9lO2"
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "Vl9mFu7m5pqR"
   },
   "source": [
    "# Podstawy Pythona\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "A-PKz2jp5pqV"
   },
   "source": [
    "Python jest językiem interpretowanym, tzn. jest językiem, w którym programy (zwykle) nie są kompilowane do kodu maszynowego, który jest wykonywany, lecz program jest przechowywany w postaci kodu źródłowego i wykonywany przez interpreter języka.<br>\n",
    "Tutaj korzystamy ze środowiska Jupyter, możesz uruchamiać kod zawarty w komórce za pomocą kombinacji `Ctrl+Enter`.\n",
    "Jeżeli masz konto Google, to możesz uruchomić notebooka jupyterowego w Google Colaboratory:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "EKa1srPs5pqW"
   },
   "source": [
    "### Hello world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "iJpm8JML5pqW",
    "outputId": "61c3a2e8-a7cd-4c33-9dbf-433ba807af9d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "YBxBY0WU5pqY"
   },
   "source": [
    "Równie dobrze możesz utworzyć plik `skrypt.py` w którym zawrzesz powyższy kod i możesz go uruchomić poleceniem `python skrypt.py`, jeżeli masz zainstalowany interpreter Pythona."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "B9u1C0o-5pqY"
   },
   "source": [
    "### Zmienne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "oae-oxzL5pqZ"
   },
   "source": [
    "Zmienne nie mają przypisanych typów, możemy w trakcie działania programu przypisywać do nich cokolwiek - raz nasza zmienna a przechowuje liczbę, a później ciąg znaków.\n",
    "Czasem może to utrudniać życie, więc można w pewien sposób \"przypisać\" typ - to będzie właściwie informacja dla naszego edytora, czy środowiska programistycznego (żeby np. odpowiednio podpowiadał metody), będzie to ignorowane przez interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "6L1ce_pN5pqY",
    "outputId": "21fd45b2-4e16-47f7-dc95-4495f0ba5bdc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "ala ma kota\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "print(a + b)\n",
    "c = \"ala ma\"\n",
    "a = \" kota\"\n",
    "print(c + a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "rcoXfHRU5pqZ"
   },
   "source": [
    "### Listy, krotki i słowniki\n",
    "Są to podstawowe struktury danych w Pythonie, przykłady ich są poniżej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "X3vVHz685pqa",
    "outputId": "40fb6217-bab4-4d6d-c362-a6d61aeef672"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 2, 3, 'kot', 1.5, 666]\n"
     ]
    }
   ],
   "source": [
    "# lista\n",
    "my_list = [1,2,3,\"kot\",3/2]\n",
    "my_list.append(666)\n",
    "my_list[0] = -1\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "O6l2KJO15pqa",
    "outputId": "596c6b44-5034-4ed6-9b37-39273074f9ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 2)\n"
     ]
    }
   ],
   "source": [
    "# krotka\n",
    "# różni się tym od listy, że jest niemodyfikowalna\n",
    "my_tuple = (1,2,3)\n",
    "# to poniżej nie przejdzie\n",
    "#my_tuple[1] = 10 \n",
    "print(my_tuple + (2,)) # ale można krotki np. konkatenować"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "RBcUwM_k5pqa",
    "outputId": "69ea579c-b8c2-4639-b284-d3d3f7953e8b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "None\n",
      "0\n",
      "{'a': 10, 'b': 66, 'c': '', 'd': 5}\n"
     ]
    }
   ],
   "source": [
    "# słownik\n",
    "my_dict = {\"a\" : 55, \"b\" : 66, \"c\": \"\"}\n",
    "print(my_dict[\"a\"])\n",
    "# to poniżej nie przejdzie\n",
    "#print(my_dict[\"d\"])\n",
    "print(my_dict.get(\"d\"))\n",
    "# możemy dać domyślną wartość, która zostanie zwrócona, gdy nie znajdziemy elementu\n",
    "print(my_dict.get(\"d\", 0))\n",
    "my_dict[\"d\"] = 5\n",
    "my_dict[\"a\"] = 10\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "UMN9F5_e5pqa"
   },
   "source": [
    "### Instrukcje warunkowe i pętle\n",
    "Mamy do dyspozycji pętlę while oraz for-each. Pętlę będą wykonywać kod w bloku (wydzielonym wcięciem!) dopóki warunek będzie spełniony (while) lub są elementy w obiekcie po którym można iterować (for-each)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "sbzf7Or25pqb",
    "outputId": "6c361e4c-f647-486d-cfbd-7fd2a10d110e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "podzielna przez 3\n"
     ]
    }
   ],
   "source": [
    "a = 6\n",
    "if a % 3 == 0:\n",
    "    print(\"podzielna przez 3\")\n",
    "elif a % 5 == 0:\n",
    "    print(\"podzielna przez 5\")\n",
    "else:\n",
    "    print(\"niepodzielna przez 3 ani 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "OxAKY7Yb5pqc",
    "outputId": "2694c8ea-4b7f-40b8-a8c7-2083d67e1671"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 16, 9, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "my_list_two = list()\n",
    "while i > 0:\n",
    "    my_list_two.append(i*i)\n",
    "    i -= 1\n",
    "print(my_list_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "rKfLh95q5pqc",
    "outputId": "d573f46b-8351-46bd-fded-eb8c2c0823cd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "2\n",
      "3\n",
      "kot\n",
      "1.5\n",
      "666\n"
     ]
    }
   ],
   "source": [
    "for item in my_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "fgYanWZC5pqd",
    "outputId": "c83397d4-1634-4f49-e8c7-91ab8e2176bb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "Aa2H1pCa5pqd",
    "outputId": "e2d01541-bda9-4642-afe1-8f06e4aa03d9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for i in range(3,5):\n",
    "    print(i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "tNogJI_y5pqe"
   },
   "source": [
    "### Funkcje\n",
    "To jak działa funkcja powinno być w miarę jasne :) Po znaku równości jest podana wartość domyślna. Więc podam tylko przykład:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "-k4MMKch5pqe",
    "outputId": "29fb724e-2591-4cea-c62e-cb1db80ca5c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "def list_of_squares(a = 10):\n",
    "    return [x ** 2 for x in range(a)]\n",
    "print(list_of_squares())\n",
    "print(list_of_squares(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "R6z5Vpu-5pqf",
    "outputId": "e33a7f45-cecb-40ce-f1cc-8c5ecc44d562"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "-3\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "#różnica 2 liczb\n",
    "def substract(a, b=5):\n",
    "    return a-b\n",
    "print(substract(2,3))\n",
    "print(substract(2))\n",
    "print(substract(b=2, a=10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "8h8MEwhn5pqf"
   },
   "source": [
    "### Klasy i obiekty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "jnC00BT35pqf",
    "outputId": "ff84639c-8390-43c2-f09a-0b7071c03d04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am static mathod\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "Brum, brum\n",
      "John Doe\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, surname):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, owner: Person, colour = \"black\", max_speed = 100, brand = \"Volvo\"):\n",
    "        self.colour = colour\n",
    "        self.max_speed = max_speed\n",
    "        self.owner = owner\n",
    "        self.brand = brand\n",
    "    \n",
    "    def run(self):\n",
    "        for i in range(self.max_speed // 10):\n",
    "            print(\"Brum, brum\")\n",
    "    \n",
    "    def print_owner(self):\n",
    "        print(self.owner.name + \" \" + self.owner.surname)\n",
    "    \n",
    "    @staticmethod\n",
    "    def some_static():\n",
    "        return \"I am static mathod\"\n",
    "\n",
    "print(Car.some_static())\n",
    "john = Person(\"John\", \"Doe\")\n",
    "car = Car (john, \"yellow\")\n",
    "car.run()\n",
    "car.print_owner()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "_i9wJgMI5pqf"
   },
   "source": [
    "Metoda `__init__()` jest jedną z metod magicznych (https://rszalski.github.io/magicmethods/) - jest tu konstruktorem. <br>\n",
    "Jedna z metod w klasie Car (`some_static()`) jest metodą statyczną - czyli metodą niepowiązaną z obiektem danej klasy. Metody statyczne oznacza się tzw. dekoratorem `@staticmethod`. Pozostałe metody przy wywołaniu `obiekt.metoda()` mają zaaplikownay obiekt jako 1 argument tzn., że wywołanie `obiekt.metoda(argument)` jest równoważne `Klasa.metoda(obiekt,argument)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "fybrNDEn5pqf"
   },
   "outputs": [],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "class B:\n",
    "    pass\n",
    "\n",
    "class C(A,B):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "-YE7vW545pqg"
   },
   "source": [
    "`pass` oznacza instrukcję, która nie orbi nic. Python obsługuje dziedziczenie klas, w tym dziedziczenie wielokrotne - klasa A w przykładzie powyżej dziedziczy jednocześnie po A i B."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Scientific Python = NumPy"
   ],
   "metadata": {
    "id": "4LPeKb_T-0Tr"
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "K-hJc-jZ5p3e"
   },
   "source": [
    "Numpy to podstawowa biblioteka do obliczeń naukowych w Pythonie. Jeżeli masz zainstalowany interpreter Pythona i menedżer pakietów pip, to możesz zainstalować numpy za pomocą: pip install numpy. W Google Collaboratory ten pakiet jest domyślnie zainstalowany.\n",
    "Podstawowym obiektem używanym w pakiecie numpy jest ndarray. Jest to wydajna wielowymiarowa tablica."
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "import numpy as np"
   ],
   "metadata": {
    "id": "MjFAHnr7-6Pl"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "1 2 3\n",
      "[5 2 3]\n",
      "========b========\n",
      "(2, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])   # Tworzy tablicę wymiaru 1 o wartościcach 1, 2, 3\n",
    "print(a.shape) # zwraca krotkę z rozmiarem tablicy w każdym wymiarze\n",
    "print(a[0], a[1], a[2])\n",
    "a[0] = 5\n",
    "print(a)\n",
    "\n",
    "print(\"========b========\")\n",
    "b = np.array([[1,2,3],[4,5,6]])\n",
    "print(b.shape)\n",
    "print(b)\n",
    "print(b[0, 0], b[0, 1])"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "qaujXglo5p3f",
    "outputId": "cb64de33-adf7-4f01-a96a-70d83f9a340d"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Na tablicach wielowymiarowych można wykonywać operacje cięcia (slicing) jak np.:"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "ySdv83Ra5p3g"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[ 1  4  7 10]\n",
      "[[4 5 6]\n",
      " [7 8 9]]\n",
      "[[ 7  8  9]\n",
      " [10 11 12]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6], [7,8,9], [10,11,12]])\n",
    "print(b[0,:]) # wiersz o indeksie 0\n",
    "print(b[:,0]) # kolumna o indekcie 0\n",
    "print(b[1:3,:]) # wiersze od #1 do #3 (bez #3)\n",
    "print(b[2:,:]) # wiersze od #2 do ostatniego\n",
    "print(b[:3,:]) # wiersze od #0 do #3 (bez #3)"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "VVC18uHp5p3h",
    "outputId": "2569fcb3-43b3-4a55-a3eb-2652900ad87c"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Istnieje kilka metod pozwalających stworzyć tablice o określonych właściwościach jak np.:"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "zZxR78W25p3h"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "[[1. 1.]\n",
      " [1. 1.]]\n",
      "[[3 3]\n",
      " [3 3]]\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2))\n",
    "print(a)\n",
    "\n",
    "b = np.ones((2,2))\n",
    "print(b)\n",
    "\n",
    "c = np.full((2,2), 3)\n",
    "print(c)\n",
    "\n",
    "d = np.eye(2)\n",
    "print(d)\n",
    "\n",
    "e = np.arange(10)\n",
    "print(e)"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "jyKXtKfm5p3h",
    "outputId": "ad8f278b-6d8c-4c4d-d63d-4415c19465a1"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Operacje na tablicach numpy'owych"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "kqfTpBMh5p3i"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[19. 22.]\n",
      " [43. 50.]]\n",
      "[[19. 22.]\n",
      " [43. 50.]]\n",
      "[[1. 3.]\n",
      " [2. 4.]]\n",
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "print(x + y) # dodawanie macierzy\n",
    "\n",
    "print(x * y) # mnożenie tzw. element-wise\n",
    "\n",
    "print(x @ y) # mnożenie macierzowe\n",
    "print(x.dot(y)) # alternatywne mnożenie macierzowe\n",
    "\n",
    "print(x.T) # transponowanie macierzy\n",
    "\n",
    "print(np.sqrt(x)) # zadziałanie jakąś funkcją matematyczną przyjmującą jedną liczbę na tablicy sprawi, że zostanie zwrócony wynik na jej każdym elemencie"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "okMj8JSF5p3i",
    "outputId": "1c4fc055-9a50-483a-ea1a-d88eb9333d34"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Broadcasting\n",
    "Broadcasting to potężny mechanizm, który pozwala numpy pracować z tablicami o różnych kształtach podczas wykonywania operacji arytmetycznych. Często mamy mniejszą tablicę i większą tablicę, a chcemy użyć mniejszej tablicy wiele razy, aby wykonać jakąś operację na tej większej."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "nA_Kb65I5p3j"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 3. 4.]\n",
      " [2. 3. 4.]\n",
      " [2. 3. 4.]]\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n",
      "[[2. 2. 2.]\n",
      " [3. 3. 3.]\n",
      " [4. 4. 4.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.ones((3,3))\n",
    "b = np.array([1,2,3])\n",
    "print(a+b)\n",
    "print(b.reshape(-1,1))\n",
    "print(a+b.reshape(-1,1))"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "FV8pW8Kg5p3k",
    "outputId": "521414a8-84eb-4f20-886a-adf609e7fc56"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Presenting Results = Matplotlib"
   ],
   "metadata": {
    "id": "SnCEn4PKAAPG"
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "1MhD4pX75qoy"
   },
   "source": [
    "Matplotlib ject biblioteką umożliwiającą rysowanie wykresów w Pythonie. Przedstawie jej kilka możliwości. Importujemy ją w następujący sposób:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "T-e02yD15qo2"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "D7Vsnoe-5qo3"
   },
   "source": [
    "### Wykresy 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "PGUsUOou5qo4",
    "outputId": "fd22691f-47a6-498b-d980-bc09f0a56338"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Jakiś wykres')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(0,11)\n",
    "# wykres punktowy\n",
    "plt.scatter(x, [1,2,2.5,3,2.5,2,1,2,2,4,3.5], c=\"red\")\n",
    "# wykres liniowy\n",
    "plt.plot(x, [2,2.1,2.2,2.5,2.8,2.9,3,3,3,3,2.9])\n",
    "\n",
    "x = np.linspace(0,10,100)\n",
    "def f(x):\n",
    "    return np.sin(x - np.pi) + 1.5\n",
    "# Kilkukrotnie wywołując funkcję rysującą w jednej komórce nanosimy wszystko na jeden wykres\n",
    "plt.plot(x, f(x), c=\"green\")\n",
    "\n",
    "plt.ylim([0,5]) # Możemy ustawić zakres osi (opcjonalnie), jest też analogiczne polecenie xlim\n",
    "plt.ylabel(\"Wartości\")\n",
    "plt.xlabel(\"Argumenty\")\n",
    "plt.title(\"Jakiś wykres\")"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Zadania\n",
    "\n",
    "1. Napisz jednoargumentową funkcję w Pythonie, która będzie zwracać true, gdy liczba podana jako argument będzie pierwsza lub false w przeciwnym wypadku. Używając tej funkcji napisz list comprehention, które wygeneruje tablicę liczb pierwszych mniejszych od 100. Wskazówka: range(100) zwróci generator liczb od 0 do 99 włącznie.\n",
    "2. Napisz funkcję, która dla danej tablicy numpy'owej zwróci drugą co do wielkości wartość. (Mogą się przydać takie funkcje jak np.max, czy np.where)\n",
    "3. Napisz funkcję używającą numpy, która obliczy przybliżone odwrócenie macierzy korzystając z np.linalg.solve, które służy do rozwiązywania układów równań liniowych i macierzowych.\n",
    "4. Używając broadcastingu napisz funkcję przyjmującą argument n, która wygeneruje tabliczkę mnożenia n na n w postaci tablicy numpy'owej."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "EVWgxUW65p3l"
   }
  },
  {
   "cell_type": "code",
   "source": [],
   "metadata": {
    "id": "1v4cBrgTAI2A"
   },
   "execution_count": null,
   "outputs": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}