Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialization Code\n",
    "This code can be ignored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from ipywidgets import interact\n",
    "import ipywidgets as widgets\n",
    "import random\n",
    "import timeit\n",
    "\n",
    "def plot(xstart = 0.0, xend = 2.0):\n",
    "    x = np.arange(xstart,xend,0.01)\n",
    "    f2 = np.vectorize(f)\n",
    "    y = f2(x)\n",
    "    plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple function call\n",
    "print is a simple function which takes parameters and returns nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print (\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function calls with parameters\n",
    "\n",
    "`pow` is a function which takes two parameters and returns one value ($x ^ y$). Similar functions: `abs`, `max`, `min`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "print (max(range(46)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interactive functions\n",
    "Interactive functions\n",
    "The `math` object contains more functions you can use for your calculations. Here you find e.g. trigonometric functions. The `interact` function executes another function and shows all of the parameters as input controls (e.g. sliders)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e28fba0e2fd428aa4bd79b24feb699c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='xstart', max=1.0), FloatSlider(value=2.0, descriptio…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot(xstart=0.0, xend=2.0)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    return abs(math.sin(x))\n",
    "interact(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursive functions\n",
    "Recursive functions are functions which call themselves. So ideally you have a starting point with a simple result, and a way to break down a complicated calculation to a more simple one. The factorial of n is $1 * 2 * ... * n$. In mathematics it is written as $ n! $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fac(x):\n",
    "    if (x == 0):\n",
    "        return 1\n",
    "    else:\n",
    "        return fac(x-1)*x\n",
    "\n",
    "fac(5)    \n",
    "#fac(100000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List functions\n",
    "List functions\n",
    "Examples for functions `len`, `sorted`. Random is an object which provides you with different methods concerning random numbers, values and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 13, 17, 21, 27, 38]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lotto():\n",
    "        numbers = []\n",
    "        while (len(numbers) < 6):\n",
    "            newNumber = random.randint(1,46)\n",
    "            if (newNumber not in numbers):\n",
    "                numbers.append(newNumber)\n",
    "        return sorted(numbers)\n",
    "            \n",
    "lotto()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different implementation\n",
    "`random.choices` chooses `k` elements of the range. `sorted` works same as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 7, 21, 26, 27, 42]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lottoAlt():\n",
    "    numbers = random.choices(range(46),k=6)\n",
    "    return (sorted(numbers))\n",
    "lottoAlt()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different implementation 2\n",
    "`list()` makes the range changeable\n",
    "`random.shuffle` shuffles the elements of `numbers`\n",
    "`numbers[:6]` cuts off all the elements after the 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 13, 15, 23, 25, 28]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lottoAlt2():\n",
    "    numbers = list(range(46))\n",
    "    random.shuffle(numbers)\n",
    "    numbersResult = numbers[:6]\n",
    "    return (sorted(numbersResult))\n",
    "lottoAlt2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different implementation 3\n",
    "Precache the generation of the 46 numbers. Possible performance win?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 7, 10, 28, 40]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers46 = range(46)\n",
    "def lottoAlt3():\n",
    "    numbers = list(numbers46)\n",
    "    random.shuffle(numbers)\n",
    "    numbersResult= numbers[:6]\n",
    "    return (sorted(numbersResult))\n",
    "lottoAlt3()"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}