From 2a93e0273186b0f7fc51c3d3a893055a067d9677 Mon Sep 17 00:00:00 2001 From: tomkys144 Date: Fri, 26 Feb 2021 09:56:01 +0000 Subject: [PATCH] Upload New File --- numpy_empty.ipynb | 635 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 635 insertions(+) create mode 100644 numpy_empty.ipynb diff --git a/numpy_empty.ipynb b/numpy_empty.ipynb new file mode 100644 index 0000000..5ab5aa4 --- /dev/null +++ b/numpy_empty.ipynb @@ -0,0 +1,635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "failing-galaxy", + "metadata": {}, + "source": [ + "### inicializace" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "protective-shepherd", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import time\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "alternate-farmer", + "metadata": {}, + "source": [ + "# NumPy\n", + "\n", + "* Rychlý a jednoduchý způsob jak pracovat s matematickými problémy v Pythonu\n", + "* Je na něm založena velká část dalších vědeckých knihoven (SciPy, BioPython, AstroPy, PyChem, PsychoPy, ...)\n", + "* [numpy.org](https://numpy.org/)" + ] + }, + { + "cell_type": "markdown", + "id": "tired-feature", + "metadata": {}, + "source": [ + "## numpy.ndarray\n", + "\n", + "- Základní a jediný datový typ v NumPy\n", + "- Multidimenzionální\n", + "- Musí bý kompletně definován\n", + "- Vytváří se pomocí fce `numpy.array()`\n", + "- K jednotlivým prvkům/řádkům se dostaneme téměř jako k v normálním nested array (normální nested array: `a[0][0]` X numpy.ndaray: `a[0, 0]`\n", + "- Narozdíl od nested array, lze s ndarray pracovat jako s jedním prvkem" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "subject-billion", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n", + "\n", + "[1 2 3]\n", + "\n", + "1\n", + "\n" + ] + } + ], + "source": [ + "a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n", + "\n", + "print(a)\n", + "print(type(a))\n", + "\n", + "print(a[0])\n", + "print(type(a[0]))\n", + "\n", + "print(a[0, 0])\n", + "print(type(a[0, 0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "pressed-providence", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[list([1, 2, 3]) list([4, 5, 6]) list([7, 8])]\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " b = np.array([[1, 2, 3], [4, 5, 6], [7, 8]])\n" + ] + }, + { + "ename": "IndexError", + "evalue": "too many indices for array: array is 1-dimensional, but 2 were indexed", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m: too many indices for array: array is 1-dimensional, but 2 were indexed" + ] + } + ], + "source": [ + "b = np.array([[1, 2, 3], [4, 5, 6], [7, 8]])\n", + "\n", + "print(b)\n", + "print(type(b))\n", + "print(type(b[0]))\n", + "print(type(b[0, 0]))" + ] + }, + { + "cell_type": "markdown", + "id": "instrumental-oriental", + "metadata": {}, + "source": [ + "## \"Narovnání\" pole\n", + "* možnost použít funkce `ravel()` a `flatten()`\n", + "* `ravel()` vrací odkaz na původní objekt\n", + "* `flatten()` vrací kopii původního objekt" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "formed-necklace", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]\n", + " [13 14 15 16]]\n", + "--x--\n", + "[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]\n", + "--x--\n", + "[150 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]\n", + "--x--\n", + "[[150 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]\n", + " [ 13 14 15 16]]\n" + ] + } + ], + "source": [ + "A = np.array([[1,2,3,4],\n", + " [5,6,7,8],\n", + " [9,10,11,12],\n", + " [13,14,15,16]])\n", + "print(A)\n", + "print('--x--')\n", + "A2 = A.ravel()\n", + "print(A2)\n", + "print('--x--')\n", + "A2[0] = 150\n", + "print(A2)\n", + "print('--x--')\n", + "print(A)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "mechanical-nebraska", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]\n", + " [13 14 15 16]]\n", + "--x--\n", + "[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]\n", + "--x--\n", + "[150 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]\n", + "[[ 1 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]\n", + " [13 14 15 16]]\n" + ] + } + ], + "source": [ + "B = np.array([[1,2,3,4],\n", + " [5,6,7,8],\n", + " [9,10,11,12],\n", + " [13,14,15,16]])\n", + "print(B)\n", + "print('--x--')\n", + "B2 = B.flatten()\n", + "print(B2)\n", + "print('--x--')\n", + "B2[0] = 150\n", + "print(B2)\n", + "print(B)" + ] + }, + { + "cell_type": "markdown", + "id": "differential-decline", + "metadata": {}, + "source": [ + "# Změna dimenze\n", + "* Pomocí fce `reshape()`" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "painful-detection", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]\n", + "--x--\n", + "[[ 0 1 2 3 4]\n", + " [ 5 6 7 8 9]\n", + " [10 11 12 13 14]]\n", + "--x--\n", + "[10 11 12 13 14 15]\n" + ] + } + ], + "source": [ + "A = np.arange(15) # arange(n) vypíše seznam n prvků | arange(n, m) vypíše seznam m-n prvků od n po m-1\n", + "print (A)\n", + "print('--x--')\n", + "A2 = A.reshape(3, 5)\n", + "print (A2)\n", + "print('--x--')\n", + "\n", + "B = np.arange(10, 16)\n", + "print (B)" + ] + }, + { + "cell_type": "markdown", + "id": "incorporate-royal", + "metadata": {}, + "source": [ + "## univerzální fce" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "talented-mainstream", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "--x--\n", + "5\n", + "--x--\n", + "[[ 5 6 7 8 9]\n", + " [10 11 12 13 14]\n", + " [15 16 17 18 19]]\n", + "--x--\n", + "[12 13 14 15 16]\n" + ] + } + ], + "source": [ + "# np.add() je aliasem pro +\n", + "\n", + "a = 2\n", + "b = 3\n", + "\n", + "print(a+b)\n", + "print('--x--')\n", + "print(np.add(a, b))\n", + "print('--x--')\n", + "\n", + "A = np.arange(15).reshape(3, 5)\n", + "B = np.arange(10, 15)\n", + "\n", + "print(A + 5)\n", + "print('--x--')\n", + "print(a + B)" + ] + }, + { + "cell_type": "markdown", + "id": "cheap-navigation", + "metadata": {}, + "source": [ + "# Příklady" + ] + }, + { + "cell_type": "markdown", + "id": "vertical-adventure", + "metadata": {}, + "source": [ + "## 1) Největší hodnota menší než x\n", + "\n", + "Zaokrouhlete všechny prvky matice A:\n", + "1. dolu (výstup X)\n", + "2. nahoru (výstup Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "institutional-router", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-1.98643344 1.60467616]\n", + " [-0.29895081 -4.54944384]\n", + " [-4.93949233 -2.05539344]\n", + " [ 0.27281693 1.24578692]\n", + " [ 2.60088802 1.83716508]\n", + " [-1.26717949 1.10522095]\n", + " [ 4.13325414 3.25656857]]\n", + "[[-2. 1.]\n", + " [-1. -5.]\n", + " [-5. -3.]\n", + " [ 0. 1.]\n", + " [ 2. 1.]\n", + " [-2. 1.]\n", + " [ 4. 3.]]\n", + "[[-1. 2.]\n", + " [-0. -4.]\n", + " [-4. -2.]\n", + " [ 1. 2.]\n", + " [ 3. 2.]\n", + " [-1. 2.]\n", + " [ 5. 4.]]\n", + "Elapsed time during the whole program in seconds: 0.0014526999998452084\n" + ] + } + ], + "source": [ + "def func1(array):\n", + " ###############\n", + " # INSERT CODE #\n", + " ###############\n", + " print(X)\n", + " print(Y)\n", + "\n", + "A = np.random.uniform(-5, 5, (np.random.randint(2, 10), np.random.randint(2, 10)))\n", + "print(A)\n", + "t1_start = time.perf_counter()\n", + "func1(A)\n", + "t1_stop = time.perf_counter()\n", + " \n", + "print(\"Elapsed time during the whole program in seconds:\", t1_stop-t1_start) " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "herbal-drill", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2. 1.]\n", + " [-1. -5.]\n", + " [-5. -3.]\n", + " [ 0. 1.]\n", + " [ 2. 1.]\n", + " [-2. 1.]\n", + " [ 4. 3.]]\n", + "[[-1. 2.]\n", + " [-0. -4.]\n", + " [-4. -2.]\n", + " [ 1. 2.]\n", + " [ 3. 2.]\n", + " [-1. 2.]\n", + " [ 5. 4.]]\n", + "Elapsed time during the whole program in seconds: 0.0012762000001202978\n" + ] + } + ], + "source": [ + "# ukázka bez NumPy\n", + "import math\n", + "def func1_1(array):\n", + " ###############\n", + " # INSERT CODE #\n", + " ###############\n", + " print (X)\n", + " print (Y)\n", + "\n", + "A = A.tolist()\n", + "t1_start = time.perf_counter()\n", + "func1(A)\n", + "t1_stop = time.perf_counter()\n", + " \n", + "print(\"Elapsed time during the whole program in seconds:\", t1_stop-t1_start) " + ] + }, + { + "cell_type": "markdown", + "id": "comprehensive-emission", + "metadata": {}, + "source": [ + "## 2) Graf\n", + "\n", + "Nakreslete sloupcový graf se jménem ***Average Ratings on the Training Set***" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "existing-overhead", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "labels = [\"Baseline\", \"System\"]\n", + "data = [3.75, 4.75]\n", + "error = [0.3497, 0.3108]\n", + "\n", + " ###############\n", + " # INSERT CODE #\n", + " ###############\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "female-sapphire", + "metadata": {}, + "source": [ + "## Příklady poctivě převzaté\n", + "\n", + "### Tlmený harmonický oscilátor\n", + "\n", + "Vykreslite časovú zmenu amplitúdy tlmeného harmonického oscilátora s dekrementom útlmu $\\lambda = 1$ a nulovou počiatočnou fázou. Za riešenie periódy kmitov považujte $T=1~\\mathrm{s}$. Maximálna amplitúda je $A=1$.\n", + "\n", + "* Amplitúda kmitov: $y(t) = A\\exp(-\\lambda t) \\cos(2\\pi f t + \\phi)$\n", + " - $A$ je maximálna amplitúda\n", + " - $\\lambda$ je koeficient útlmu\n", + " - $\\phi$ je fáza v počiatku časovej osi." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "worthy-coffee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "A = 1 # Amplitúda kmitov\n", + "lambda_ = 1 # logaritmický dekrement útlmu\n", + "phi = 0 # Počiatočná fáza\n", + "f = 1 # Frekvencia\n", + "\n", + " ###############\n", + " # INSERT CODE #\n", + " ###############\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Pomocné čiary a grafy\n", + "ax.axhline(0, color='k', alpha=.3)\n", + "ax.plot(t, x_undamped, 'k', alpha=.3)\n", + "ax.plot(t, damping, 'k', alpha=.3)\n", + "ax.plot(t, -damping, 'k', alpha=.3)\n", + "\n", + "# Tlmené kmitanie\n", + "ax.plot(t, x, lw=5)\n", + "\n", + "# Nadpis, popis osí\n", + "plt.title(r'Tlmené kmitanie, $A=${:.3f}, $\\lambda=${:.3f}, $f={:.1f}~$Hz'.format(A, lambda_, f))\n", + "ax.set_xlabel(r'$t~(\\mathrm{s})$')\n", + "ax.set_ylabel(r'$y$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "yellow-baseline", + "metadata": {}, + "source": [ + "### Mandelbrotova množina\n", + "\n", + "* Je to množina komplexných čísel $z$, pre ktoré funkcia $f(z) = z^2 + c$ pri nekonečnej iterácii počínajúcej v $z=0+0\\jmath$ *konverguje*.\n", + " * Iterácia funkcie $f$: $f(f(f(\\cdots f(f(z))\\cdots )))$\n", + "* Možno ju zobraziť ako obrázok\n", + " * Istý výsek komplexnej roviny rozdelíme\n", + " * V každom bode delenia vyhodnotíme, či je preň podmienka príslušnosti do Mandelbrotovej množiny splnená\n", + " * Pokiaľ áno, vykreslíme príslušný pixel (alebo množinu pixelov) farbou $F_1$, pokiaľ do Mandelbrotovej množiny nepatrí, vykreslíme ho (ju) farbou $F_2$\n", + "* Vizualizácia sa dá ale urobiť ešte krajšie (i keď z hľadiska vyhodnotenia príslušnosti čísel k Mandelbrotovej množine menej informatívne):\n", + " * Zvolíme si hodnotu prahu $t$ a hodnotu maximálneho počtu iterácií $m$.\n", + " * Pokiaľ po $n$ iteráciach dosiahne hodnota iterovanej funkcie v čísle $z$ hodnotu $t$, prehlásime číslo $z$ za nemandelbrotovské. Priradíme mu však hodnotu $n$\n", + " * Pokiaľ v bode $z$ ani po $m$ iteráciach nedosiahne iterovaná funkcia hodnotu $t$, priradíme číslu $z$ hodnotu $n=0$.\n", + " * Maticu čísel $\\{n\\}$ pre skúmaný výsek komplexnej roviny namapujeme na farebnú škálu a vykreslíme." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "insured-developer", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def mandelbrot(xlim, ylim, n_real=1000, n_imag=1000, threshold_value=3., threshold_iterations=100):\n", + " x = np.linspace(*xlim, n_real, dtype=np.float32)\n", + " y = np.linspace(*ylim, n_imag, dtype=np.float32)\n", + " c = x + y.reshape(len(y), 1) * 1j # Komplexné čísla v skúmanom výseku\n", + " n = np.zeros_like(c, dtype=int) # Počty iterácií\n", + " z = np.zeros_like(c, dtype=np.complex64) # Medzivýsledky iterácie\n", + " \n", + " for i in range(threshold_iterations):\n", + " where_less = np.less(np.abs(z), threshold_value)\n", + " n[where_less] = i\n", + " z[where_less] = z[where_less] ** 2 + c[where_less]\n", + " \n", + " n[n == threshold_iterations - 1] = 0\n", + " # n[n != 0] = 1 # Pre binárny výstup\n", + " \n", + " return n\n", + "\n", + "xlim = [-1.5, 1]\n", + "ylim = [-1.5, 1.5]\n", + "\n", + "n = mandelbrot(xlim, ylim)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.imshow(n, extent=xlim + ylim)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "prime-burlington", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}