From 92bcd4d56b474857d05242782d0cf9997bccbeed Mon Sep 17 00:00:00 2001
From: Solfrid <solfrihj@stud.ntnu.no>
Date: Wed, 15 Jul 2020 12:25:51 +0200
Subject: [PATCH] La til referanse til JN8 i siste seksjon

---
 .../JN3_introduksjon_numpy-checkpoint.ipynb   | 2276 -----------------
 JN3/JN3_introduksjon_numpy.ipynb              |    2 +-
 2 files changed, 1 insertion(+), 2277 deletions(-)
 delete mode 100644 JN3/.ipynb_checkpoints/JN3_introduksjon_numpy-checkpoint.ipynb

diff --git a/JN3/.ipynb_checkpoints/JN3_introduksjon_numpy-checkpoint.ipynb b/JN3/.ipynb_checkpoints/JN3_introduksjon_numpy-checkpoint.ipynb
deleted file mode 100644
index 675fe85..0000000
--- a/JN3/.ipynb_checkpoints/JN3_introduksjon_numpy-checkpoint.ipynb
+++ /dev/null
@@ -1,2276 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"font-size:15px; margin-left:0px\">\n",
-    "  <tr>\n",
-    "    <td><a href=\"../JN0.ipynb\">Tilbake til oversikt over notebooks</td>\n",
-    "  </tr>\n",
-    "\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<h1>Introduksjon til NumPy</h1>\n",
-    "\n",
-    "**Læringsmål**:\n",
-    "- Vite om fordeler og ulemper med bruk av NumPy array over liste\n",
-    "- Lage NumPy array fra en eksisterende liste\n",
-    "- Vite at NumPy arrays har ulike datatyper (int, float og string)\n",
-    "- Utføre regneoperasjoner på arrays\n",
-    "- Bruke funksjonene `np.cos`,`np.sin`, `np.log` og `np.exp` på arrays\n",
-    "- Bruke og forstå forskjellen på `np.linspace`, `np.arange` og `np.zeros`\n",
-    "- Indeksering av endimensjonale og todimensjonale arrays\n",
-    "- Slicing av endimensjonale og todimensjonale arrays\n",
-    "- Finne størrelsen på endimensjonale og todimensjonale arrays\n",
-    "----"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Bakgrunnskunnskaper"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Vi starter med en kort introduksjon til hva en **liste** i Python er, og hvordan du lager en liste med tall. Du trenger ikke vite mer om lister enn det som står i seksjonen under. Dersom du allerede kjenner til lister kan du hoppe over denne delen.\n",
-    "\n",
-    "Etter seksjonen om lister er det en seksjon om **funksjoner** i Python. Dersom du allerede kjenner til funksjoner, kan du hoppe over denne."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Om lister i Python"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "En liste i Python er enkelt sagt en strukturert måte å lagre flere variabler på. For eksempel kan vi ønske å lagre heltallene 1, 2, 3 og 4 i en liste. Dette gjør vi ved å skrive "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "my_list = [1, 2, 3, 4]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Som du ser over, skriver vi inn verdiene mellom klammeparenteser, og bruker komma for å skille de. Vi kan også ha lister som inneholder flyttall, som under (husk at i Python skriver vi punktum for å starte desimaldelen)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "my_float_list = [1.2, 3.3, 4.4]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Dette er det du trenger å vite om lister for å komme igang. (Ønsker du i tillegg en introduksjon som dekker mer om lister kan du se videoen [her](https://www.youtube.com/watch?v=BMcCKu3Wf2Q&index=20&list=PLOdJrz3dHl4pzalJ0jAQdxl7ZLPIvF3nR), selv om dette **ikke er nødvendig**.)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Funksjoner i Python"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "I denne notebooken bruker vi begrepet *funksjon* endel. Dersom du ikke er kjent med dette kan du tenke på funksjoner i Python som lignende funksjoner fra matematikken. Det du trenger å vite er at funksjoner kan ha *input*, dvs. en verdi/variabel vi gir inn til funksjonen. Deretter beregner funksjonen \"noe\" og *returnerer* ofte en verdi. Dette betyr at den \"gir ut\" en verdi vi kan lagre i en variabel, eller f.eks. printe til skjerm. Du trenger ikke å vite hvordan du skriver egne funksjoner, men det som er beskrevet over holder for å kunne forstå delen under.\n",
-    "\n",
-    "For å illustrere bruk av funksjoner har vi et eksempel under, som bruker den innebygde (dvs. den kommer med Python, vi har ikke skrevet den selv) `abs()` funksjonen. Funksjonen returnerer *absoluttverdien* av tallet som blir gitt som *input*. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "20\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Lager en variabel, som har verdien -20\n",
-    "num = -20\n",
-    "# bruker den innebygde abs funksjonen, med num som input\n",
-    "# den gir oss (returnerer) tallet 20, som vi lager i variabelen abs_num\n",
-    "abs_num = abs(num)\n",
-    "print(abs_num)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Når vi bruker funksjoner fra moduler (som forklart i [JN2 Moduler](../JN2/JN2_moduler.ipynb)), må vi kalle på de via navnet til modulen. Dersom vi f.eks. har en modul som heter `math`, og vi skal kalle på funksjonen `sin(x)` som er i `math` må vi skrive `math.sin(x)`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Om NumPy arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Se videoen under, som introduserer NumPy og NumPy arrays. Gjør deretter oppgavene under. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    },
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/n55crWASayU?list=PLt2_5eV52wvrQP0FTFYx5tC7VGjT8Duvn\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from IPython.display import HTML, IFrame\n",
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/n55crWASayU?list=PLt2_5eV52wvrQP0FTFYx5tC7VGjT8Duvn\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- Importerer NumPy ved å skrive `import numpy as np` før vi kan bruke noen av funksjonene\n",
-    "- Lager en array ved å skrive `array_name = np.array(list)`, hvor `list` er en liste vi konverterer til en array\n",
-    "- Printer en array ved å skrive `print(array_name)`\n",
-    "- Vi ser på arrays som kan inneholde heltall eller flyttall\n",
-    "\n",
-    "Koden som ble gjennomgått i videoen er gitt under, med noen kommentarer."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[4 3 1 5]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# importerer NumPy, og gir det navnet np\n",
-    "import numpy as np\n",
-    "\n",
-    "# lager en vanlig liste\n",
-    "my_list = [4, 3, 1, 5]\n",
-    "\n",
-    "# gir lista som input til array funksjonen til NumPy, som vi kaller med np.array\n",
-    "my_array = np.array(my_list)\n",
-    "\n",
-    "# printe resultat\n",
-    "print(my_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2.3 9.9 5.4 4.3 4. ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lage en array med flyttall\n",
-    "my_array_float = np.array([2.3, 9.9, 5.4, 4.3, 4.0])\n",
-    "\n",
-    "# print resultatet, legg merke til at 4.0 printes som 4. \n",
-    "print(my_array_float)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "- Importer NumPy i kodecellen under (fordi du gjør det her, trenger du ikke gjøre det igjen i kodecellene under).\n",
-    "- Lag så liste som inneholder tallene 5, 2, 6 og 7 (i denne rekkefølgen). \n",
-    "- Gjør om listen til en NumPy array og lagre den. \n",
-    "- Print arrayen til skjerm. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# Skriv svar til oppgave 1 her\n",
-    "\n",
-    "# husk å først importere NumPy!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[5 2 6 7]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en liste som inneholder heltall\n",
-    "my_list = [5, 2, 6, 7]\n",
-    "# konverterer til en numpy array, og lagrer i en variabel\n",
-    "my_array = np.array(my_list)\n",
-    "print(my_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Gjør det samme som over, men lag en liste som inneholder noen *flyttall* isteden."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# Skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2.2 4.  3.9]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en liste som inneholder flyttall\n",
-    "my_float_list = [2.2, 4.0, 3.9]\n",
-    "# konvertere til en NumPy array, og lagrer i en variabel\n",
-    "my_float_array = np.array(my_float_list)\n",
-    "print(my_float_array)\n",
-    "# legg merke til at 4.0 printes som 4."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 3**\n",
-    "\n",
-    "Lag en array som inneholder fem elementer, som er strenger. Print den til skjerm."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 3 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['Hei' 'På' 'Deg']\n"
-     ]
-    }
-   ],
-   "source": [
-    "string_array = np.array([\"Hei\", \"På\", \"Deg\"])\n",
-    "print(string_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 4**\n",
-    "\n",
-    "Prøv å lage en array som inneholder noen heltall, og noen strenger. Hva skjer med datatypen til arrayen du får?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv kode til oppgave 4 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['2' 'piggsvin']\n",
-      "['2' '2.2' '3']\n"
-     ]
-    }
-   ],
-   "source": [
-    "strange_array = np.array([2, \"piggsvin\"])\n",
-    "print(strange_array)\n",
-    "# vi ser at tallet 2 blir konvertert til en streng.\n",
-    "\n",
-    "# noen ekstra eksempel for å vise poenget\n",
-    "another_strange_array = np.array([2, 2.2, \"3\"])\n",
-    "print(another_strange_array)\n",
-    "# også her blir alle elementene konvertert til en streng"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 5**\n",
-    "\n",
-    "Lag en array som inneholder noen heltall og noen flyttall, og print resultatet. Hvilken datatype har verdiene i arrayen?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv kode til oppgave 5 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2.2 3.  1.2 5.  5. ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "mixed_array = np.array([2.2, 3, 1.2, 5, 5])\n",
-    "print(mixed_array)\n",
-    "# datatypen til elementene er nå flyttall."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Regneoperasjoner på arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Videoen under handler om å utføre regneoperasjoner, som pluss, minus og gange, på NumPy arrays. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    },
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/txbv7m8UPR8\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/txbv7m8UPR8\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- Når vi utfører regneoperasjoner, som `+`, `-`, `*` , `**` osv. utføres dette på *hvert element*. \n",
-    "- NumPy har funksjoner som `np.sin`, `np.cos`, `np.tan`, `np.log` og `np.exp`. Gir man en array som input, regnes verdien ut på hvert element."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[14.4 12.9 15.4 19.2]\n",
-      "[4.4 2.9 5.4 9.2]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en array\n",
-    "my_array = np.array([4.4, 2.9, 5.4, 9.2])\n",
-    "\n",
-    "# plusser på 10 til hver *element*\n",
-    "my_array_2 = my_array + 10\n",
-    "\n",
-    "# printer resultatet\n",
-    "print(my_array_2)\n",
-    "\n",
-    "# merk, den opprinnelige arrayen er ikke endret på\n",
-    "print(my_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[440. 290. 540. 920.]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# ganger hvert element med 100\n",
-    "my_array_3 = my_array * 100\n",
-    "print(my_array_3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ 0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427]\n"
-     ]
-    }
-   ],
-   "source": [
-    "my_comp_array = np.array([1, 2, 3, 4, 5])\n",
-    "\n",
-    "# regner ut sinus til hvert element i arrayen\n",
-    "my_sin_array = np.sin(my_comp_array)\n",
-    "print(my_sin_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.         0.69314718 1.09861229 1.38629436 1.60943791]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# regner ut den naturlige logaritmen til hvert element i arrayen\n",
-    "my_log_array = np.log(my_comp_array)\n",
-    "print(my_log_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "I koden under er det laget en NumPy array som inneholder tallene fra 1 til 10. Lag en ny variabel, hvor du lagrer den opprinnelige arrayen ganget med seg selv. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "number_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# Skriv svar til oppgave 1 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  1   4   9  16  25  36  49  64  81 100]\n"
-     ]
-    }
-   ],
-   "source": [
-    "mult_array = number_array * number_array\n",
-    "# or\n",
-    "mult_array = number_array**2\n",
-    "print(mult_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Regn ut verdien av eksponentialfunksjonen til hvert element i `number_array` over, og lagre resultatet i en ny variabel. Print ut resultatet."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# Skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01\n",
-      " 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03\n",
-      " 8.10308393e+03 2.20264658e+04]\n"
-     ]
-    }
-   ],
-   "source": [
-    "exponential_array = np.exp(number_array)\n",
-    "print(exponential_array)\n",
-    "# legg merke til at resultatet står som vitenskapelig notasjon."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 3**\n",
-    "\n",
-    "Regn ut $\\cos(\\sin^2(\\ln(x))$, hvor x er hvert av elementene i `number_array`. Print ut resultatet. Merk: Notasjonen $\\sin^2(x)$ betyr $(\\sin(x))^2$. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# Skriv svar til oppgave 3 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1.         0.91780844 0.70162027 0.56831191 0.54155754 0.58008381\n",
-      " 0.64805629 0.72287902 0.79225221 0.85068635]\n"
-     ]
-    }
-   ],
-   "source": [
-    "complicated_array = np.cos((np.sin(np.log(number_array)))**2)\n",
-    "print(complicated_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Generere arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Videoen under handler om hvordan vi kan generere arrays ved å bruke `np.linspace`, `np.arange`, `np.zeros` og `np.ones`. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"878\" height=\"494\" src=\"https://www.youtube.com/embed/fht0TQzDEPo\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"878\" height=\"494\" src=\"https://www.youtube.com/embed/fht0TQzDEPo\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\") "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- Vi kan lage en array med `n` antall elementer, hvor hvert element har verdien 0.0, ved å skrive `np.zeros(n)`, og lagre den i en variabel.\n",
-    "- Vi lager en array med elementer fra og med `start`, til og med `end`, med `num` elementer, ved å skrive `np.linspace(start, stop, num)`. \n",
-    "- For å lage en array med elementer fra og med `start` til **(men ikke med)** `end`, med steglengde `stepsize`, bruker du funksjone `np.arange(start, stop, stepsize)`.\n",
-    "\n",
-    "Koden som blir gjennomgått i videoen står under."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en array med 10 elementer, hvor hvert element er 0\n",
-    "zero_array = np.zeros(10)\n",
-    "print(zero_array)\n",
-    "# legg merke til at datatypen er float"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[7. 7. 7. 7. 7. 7. 7. 7. 7. 7.]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en array hvor vi har den med 0 og legger til 7 til hvert element \n",
-    "seven_array = zero_array + 7\n",
-    "print(seven_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager manuelt en array fra 0 til 1 med 11 elementer, derfor steg på 0.1\n",
-    "manual_array = np.array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])\n",
-    "print(manual_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager samme array som over, 0 er startverdi, 1 er sluttverdi, og 11 er antall elementer i arrayen\n",
-    "linspace_array = np.linspace(0, 1, 11)\n",
-    "print(linspace_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.   0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1  0.11 0.12 0.13\n",
-      " 0.14 0.15 0.16 0.17 0.18 0.19 0.2  0.21 0.22 0.23 0.24 0.25 0.26 0.27\n",
-      " 0.28 0.29 0.3  0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4  0.41\n",
-      " 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5  0.51 0.52 0.53 0.54 0.55\n",
-      " 0.56 0.57 0.58 0.59 0.6  0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69\n",
-      " 0.7  0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8  0.81 0.82 0.83\n",
-      " 0.84 0.85 0.86 0.87 0.88 0.89 0.9  0.91 0.92 0.93 0.94 0.95 0.96 0.97\n",
-      " 0.98 0.99 1.  ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# demonstrerer at vi kan bruke større antall elementer.\n",
-    "large_array = np.linspace(0, 1, 101)\n",
-    "print(large_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager samme array som linspace_arrar, men basert på steglengden, 0.1, ikke antall elementer\n",
-    "# NB! vi må ha 1.1 som sluttverdi, fordi den *ikke* inkluderer siste steg i arrayen.\n",
-    "arange_array = np.arange(0, 1.1, 0.1)\n",
-    "print(arange_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# dersom vi stopper på 1, og ikke 1.1\n",
-    "incorrect_arange_array = np.arange(0, 1, 0.1)\n",
-    "print(incorrect_arange_array)\n",
-    "# observer at det siste elementet, 1.0, ikke er med!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "Lag en array som består av tallene fra og med $0$ til og med $10$, og har $20$ elementer. Print resultatet."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 1 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ 0.          0.52631579  1.05263158  1.57894737  2.10526316  2.63157895\n",
-      "  3.15789474  3.68421053  4.21052632  4.73684211  5.26315789  5.78947368\n",
-      "  6.31578947  6.84210526  7.36842105  7.89473684  8.42105263  8.94736842\n",
-      "  9.47368421 10.        ]\n"
-     ]
-    }
-   ],
-   "source": [
-    "nums = np.linspace(0, 10, 20)\n",
-    "print(nums)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Lag en array som består av tallene fra og med $-10$ **til og med** $0$, og har *steglengde* $2$. Print resultatet. \n",
-    "\n",
-    "*Hint:* Tenk over hva som skjer med det siste elementet i arrayen."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-10  -8  -6  -4  -2   0]\n"
-     ]
-    }
-   ],
-   "source": [
-    "nums_step = np.arange(-10, 1, 2)\n",
-    "print(nums_step)\n",
-    "# merk: fordi np.arange ikke inkluderer det elementet i intervallet, lar vi den gå til 1. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 3**\n",
-    "\n",
-    "Lag en array som består av 16 elementer, hvor alle elementene er lik 200."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 3 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200.\n",
-      " 200. 200.]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lager en array med 16 nuller, og legger til 200\n",
-    "arr_alt = np.zeros(16) + 200\n",
-    "print(arr_alt)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Indeksering av arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Vi skal nå se på hvordan vi kan hente ut elementer fra en array, og hvordan vi kan endre på elementer i en array. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    },
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"880\" height=\"542\" src=\"https://www.youtube.com/embed/f5uvxbGTki8\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"880\" height=\"542\" src=\"https://www.youtube.com/embed/f5uvxbGTki8\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\") "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- Vi kan **hente ut verdien** til enkelelementer, eller deler av en array\n",
-    "- Vi kan **endre på verdien** til enkeltelementer, eller deler av en array\n",
-    "- Hvert element i en array har en *indeks*. Indeksene starter på $0$, som er indeksen til første element (lengst til venstre), og øker med en for hvert element.\n",
-    "- Vi **henter ut verdien** til et element, ved å skrive `array_name[index_number]`,hvor `array_name` er en array, og `index_number` er indeksen til elementet. Resultatet kan lagres i en variabel. Merk at du vil få feilmelding om indeksen er større en den til det siste elementet.\n",
-    "- Vi **endrer på verdien** til et element ved å skrive `array_name[index_number] = new_value`. Dette skriver over verdien som var der før. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3\n"
-     ]
-    }
-   ],
-   "source": [
-    "my_array = np.array([4, 5, 3, 1, 2, 3])\n",
-    "# henter ut verdien lagret i indeks 2, og lagrer den i en variabel\n",
-    "my_value = my_array[2]\n",
-    "print(my_value)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[4 5 3 1 9 3]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# endrer på verdien lagret i indeks 4\n",
-    "my_array[4] = 9\n",
-    "# printer arrayen, og ser at 2 er endret til9\n",
-    "print(my_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "Print det *nest* siste elementet i arrayen, `test_array`, som er definert under.  (NB: husk å kjøre kodecellen under før du starter på oppgaven)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_array = np.array([4, 2, 9, 121, 43, 2, 0, 5, 8])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 1 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "5\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(test_array[-2])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Oppdater det femte elementet (dvs. på indeks 4) i `test_array` til å være lik 190."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  4   2   9 121 190   2   0   5   8]\n"
-     ]
-    }
-   ],
-   "source": [
-    "test_array[4] = 190\n",
-    "print(test_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Slicing av arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nå skal vi se på hvordan vi kan bruke *slicing* for å hente ut deler av en array, og for å oppdatere verdiene til deler av en array"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    },
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"880\" height=\"542\" src=\"https://www.youtube.com/embed/4mM4iw8e264\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"880\" height=\"542\" src=\"https://www.youtube.com/embed/4mM4iw8e264\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\") "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- Vi kan bruke *slicing* for å **hente ut deler av en array**. Vi skriver `array_name[start_index: stop_index: step_size]`. Resultatet kan lagres i en variabel.\n",
-    "- Vi kan også bruke slicing for å **endre på verdien til deler av en array**. Vi skriver da `array_name[start_index:stop_index:step_size] = new_array`. Merk at arrayen som kommer fra slicingen må ha like mange elementer som `new_array`.\n",
-    "- Kan finne antall elementer ved å skrive `np.size(array)`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[3 1]\n"
-     ]
-    }
-   ],
-   "source": [
-    "to_slice = np.array([4, 3, 2, 1, 0, 9])\n",
-    "# lagrer den nye arrayen i en ny variabel \n",
-    "sliced_array = to_slice[1:4:2]\n",
-    "print(sliced_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2 4 1 9]\n"
-     ]
-    }
-   ],
-   "source": [
-    "test_array = np.array([2, 3, 6, 9])\n",
-    "# array som skal \"settes inn\"\n",
-    "new_array = np.array([4, 1])\n",
-    "# skriver over element 1 og 2, til den nye arrayen\n",
-    "test_array[1:3] = new_array\n",
-    "print(test_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4\n"
-     ]
-    }
-   ],
-   "source": [
-    "# finner antall elementer\n",
-    "num_elements = np.size(test_array)\n",
-    "print(num_elements)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "Vi ser på `test_array_two`, som er definert under. Kjør kodecellen under før du svarer på oppgaven. Bruk *slicing* for å lagre en ny array, som inneholder elementene fra og med indeks $4$ til og med $6$.\n",
-    "\n",
-    "*Hint*: Husk at for å slice en array skriver vi `array_name[start_index: end_index]`, hvor `array_name` er navnet til arrayen vi slicer, `start_index` er verdien til start indeksen,  og `end_index` er én større enn den siste indeksen vi ønsker å ha med."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_array_two = np.array([4, 2, 9, 121, 43, 2, 0, 5, 8])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[43  2  0]\n"
-     ]
-    }
-   ],
-   "source": [
-    "slice_test = test_array_two[4:7]\n",
-    "print(slice_test)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Print ut antall elementer i `test_array_two` fra oppgave 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 4 her "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "9\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(np.size(test_array_two))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 3**\n",
-    "\n",
-    "Bruk *slicing* på `test_array_two` slik at resultatet når vi printer ut den nye arrayen er `[9 2 8]`. \n",
-    "\n",
-    "*Hint:* Start på tredje element, og slutt på siste. Hva er steglengden?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 3 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[9 2 8]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# legg merke til at når det er tomt mellom parantesene her inkluderer vi helt til slutten av arrayen. \n",
-    "# har steglengde på 3\n",
-    "sliced = test_array_two[2::3]\n",
-    "print(sliced)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 4**\n",
-    "\n",
-    "Bruk *slicing* til å oppdatere de tre siste elementene i `test_array_two` til å være 4, 9, 10."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 6 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  4   2   9 121  43   2   4   9  10]\n",
-      "[  4   2   9 121  43   2   4   9  10]\n"
-     ]
-    }
-   ],
-   "source": [
-    "update_array = np.array([4, 9, 10])\n",
-    "# slicer fra indeks -3, som betyr det tredje målt fra slutten, til resten av arrayen, og oppdaterer\n",
-    "test_array_two[-3:] = update_array\n",
-    "print(test_array_two)\n",
-    "\n",
-    "# alternativ måte å slice, ved å starte på element 6, og gå til slutten\n",
-    "test_array_two[6:] = update_array\n",
-    "print(test_array_two)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Todimensjonale arrays"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Vi kan også lage arrays som har elementer som også er arrays. Dette kalles todimensjonale arrays. I videoen under ser vi på hvordan vi kan lage de, hvordan vi kan indeksere de, bruke slicing og finne antall kolonner og rader."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "hide_input": true,
-    "init_cell": true,
-    "run_control": {
-     "frozen": true
-    },
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/AJIFTfHBkaI\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "HTML(\"\"\"\n",
-    "   <iframe width=\"880\" height=\"495\" src=\"https://www.youtube.com/embed/AJIFTfHBkaI\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
-    "\"\"\") "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
-   "source": [
-    "## Oppsummering av video"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "- En todimensjonal array er en array hvor hvert *element* også er en array\n",
-    "- Vi kan lage en 2D array ved å definere en variabel, `two_d_array = np.array([row_1, row_2, ... ])`, hvor `row_1`, `row_2`, osv. er arrays. \n",
-    "- Indekserer ved å skrive `array[row_index, column_index]`\n",
-    "- Slicing ved å skrive `array[start_row:end_row:stepsize, start_col:end_col:stepsize]`\n",
-    "- Finner antall rader og antall kolonner ved å bruke funksjonen `np.shape(array)`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[10  2  1 32 81]\n",
-      " [ 5 98 22 71 18]\n",
-      " [ 2 92 78 43  3]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# lage en todimensjonal array\n",
-    "row_1 = np.array([10, 2, 1, 32, 81])\n",
-    "row_2 = np.array([5, 98, 22, 71, 18])\n",
-    "row_3 = np.array([2, 92, 78, 43, 3])\n",
-    "table_array = np.array([row_1, row_2, row_3])\n",
-    "print(table_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "18\n"
-     ]
-    }
-   ],
-   "source": [
-    "# henter ut tallet 18, fra index 1,4\n",
-    "var = table_array[1, 4]\n",
-    "print(var)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[10  2  1 32 81]\n",
-      " [ 5 11 22 71 18]\n",
-      " [ 2 92 78 43  3]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# endrer en verdi, ved å skrive over den gamle\n",
-    "table_array[1, 1] = 11\n",
-    "print(table_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[98 18]\n",
-      " [92  3]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# tilbakestiller til slik den var\n",
-    "table_array[1, 1] = 98\n",
-    "# slicing av array\n",
-    "sliced_array = table_array[1:3:1, 1:5:3]\n",
-    "print(sliced_array)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(3, 5)\n",
-      "15\n"
-     ]
-    }
-   ],
-   "source": [
-    "# finner størrelsen på\n",
-    "shape_array = np.shape(table_array)\n",
-    "print(shape_array)\n",
-    "# tre rader og fem kolonner\n",
-    "# ser at size gir antall elementer, som er tre ganger fem\n",
-    "print(np.size(table_array))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Oppgaver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 1**\n",
-    "\n",
-    "Lag en to-dimensional array av tabellen under, og print til skjerm.\n",
-    "\n",
-    "<style type=\"text/css\">\n",
-    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
-    ".tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
-    "  overflow:hidden;padding:10px 5px;word-break:normal;}\n",
-    ".tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
-    "  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}\n",
-    ".tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}\n",
-    "</style>\n",
-    "<table class=\"tg\">\n",
-    "<tbody>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">43</td>\n",
-    "    <td class=\"tg-0pky\">84</td>\n",
-    "    <td class=\"tg-0pky\">21</td>\n",
-    "    <td class=\"tg-0pky\">98</td>\n",
-    "    <td class=\"tg-0pky\">-23</td>\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">2</td>\n",
-    "    <td class=\"tg-0pky\">0</td>\n",
-    "    <td class=\"tg-0pky\">43</td>\n",
-    "    <td class=\"tg-0pky\">-300</td>\n",
-    "    <td class=\"tg-0pky\">32</td>\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">32</td>\n",
-    "    <td class=\"tg-0pky\">67</td>\n",
-    "    <td class=\"tg-0pky\">43</td>\n",
-    "    <td class=\"tg-0pky\">0</td>\n",
-    "    <td class=\"tg-0pky\">38</td>\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">5</td>\n",
-    "    <td class=\"tg-0pky\">8</td>\n",
-    "    <td class=\"tg-0pky\">3</td>\n",
-    "    <td class=\"tg-0pky\">4</td>\n",
-    "    <td class=\"tg-0pky\">1</td>\n",
-    "  </tr>\n",
-    "</tbody>\n",
-    "</table>\n",
-    "    \n",
-    "*Hint:* Lag først en array for hver rad, og så la hver rad være et element i den to-dimensjonale arrayen. Husk å lage listen på formen `np.array([[row_1], [row_2], ...])`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 1 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[  43   84   21   98  -23]\n",
-      " [   2    0   43 -300   32]\n",
-      " [  32   67   43    0   38]\n",
-      " [   5    8    3    4    1]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "two_d = [[43, 84, 21, 98,-23], [2, 0, 43, -300, 32], [32, 67, 43, 0, 38], [5, 8, 3, 4, 1]]\n",
-    "two_d_array = np.array(two_d)\n",
-    "print(two_d_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 2**\n",
-    "\n",
-    "Bruk slicing på arrayen, `test_2d_array` (som er definert under), for å hente ut *siste kolonne*. Lagre kolonnen i en ny array, og print resultatet."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_2d_array = np.array([[2, 3, 4], [3, 1, 9], [0, 2, 3], [7, 5, 9]])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 2 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[4 9 3 9]\n"
-     ]
-    }
-   ],
-   "source": [
-    "sliced_array = test_2d_array[:,-1]\n",
-    "print(sliced_array)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 3**\n",
-    "\n",
-    "Print ut elementet som er lagret på andre rad, og tredje kolonne i `test_2d_array`.\n",
-    "\n",
-    "*Hint:* Indeksering i en todimensjonal array er på formen `array_name[row_index, column_index]`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 3 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "9\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(test_2d_array[1, 2])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 4**\n",
-    "\n",
-    "Arrayen `test_2d_array` kan representeres som en tabell slik som under \n",
-    "\n",
-    "\n",
-    "<style type=\"text/css\">\n",
-    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
-    ".tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
-    "  overflow:hidden;padding:10px 5px;word-break:normal;}\n",
-    ".tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
-    "  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}\n",
-    ".tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}\n",
-    "</style>\n",
-    "<table class=\"tg\">\n",
-    "<tbody>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">2</td>\n",
-    "    <td class=\"tg-0pky\">3</td>\n",
-    "    <td class=\"tg-0pky\">4</td>\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">3</td>\n",
-    "    <td class=\"tg-0pky\" style=\"color:red\">1</td>\n",
-    "    <td class=\"tg-0pky\" style=\"color:red\">9</td>\n",
-    "\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">0</td>\n",
-    "    <td class=\"tg-0pky\" style=\"color:red\">2</td>\n",
-    "    <td class=\"tg-0pky\" style=\"color:red\">3</td>\n",
-    "\n",
-    "  </tr>\n",
-    "  <tr>\n",
-    "    <td class=\"tg-0pky\">7</td>\n",
-    "    <td class=\"tg-0pky\">5</td>\n",
-    "    <td class=\"tg-0pky\">9</td>\n",
-    "\n",
-    "  </tr>\n",
-    "</tbody>\n",
-    "</table>.\n",
-    "\n",
-    "I tabellen er fire av elementene farget rød. Bruk slicing av `test_2d_array` for å lagre disse elementene i en ny array, og print resultatet.\n",
-    "\n",
-    "*Hint:* For en to-dimensional array, er slicing på formen `[start_row:end_row, start_col:end_col]`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 72,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 4 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[1 9]\n",
-      " [2 3]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "four_elements = test_2d_array[1:-1, 1:]\n",
-    "print(four_elements)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Oppgave 5**\n",
-    "\n",
-    "Skriv kode som printer antall rader og antall kolonner i `test_2d_array`.\n",
-    "\n",
-    "*Hint:* Bruk `np.shape(array_name)`, hvor `array_name` er variabelnavnet til arrayet vi ønsker å finne dimensjonene til. Funksjonen gir output som er på formen `(number_of_rows, number_of_cols)`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 74,
-   "metadata": {
-    "solution2": "hidden",
-    "solution2_first": true
-   },
-   "outputs": [],
-   "source": [
-    "# skriv svar til oppgave 5 her"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 75,
-   "metadata": {
-    "solution2": "hidden"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(4, 3)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(np.shape(test_2d_array))\n",
-    "# 4 rader, og 3 kolonner. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tips til å lære mer"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nå har du lært mye om NumPy, slik at du enkelt kan komme igang med å programmere selv. Likevel er det greit å vite at NumPy har *veldig* mange flere funksjoner du kan benytte deg av. *Dokumentasjonen* til NumPy finner du  på https://numpy.org/doc/1.18/reference/index.html. Her ser du en oversikt over de ulike funksjonene som finnes. Det kan være vanskelig å lese dokumentasjonen til en pakke når man er ny i programmering, men om du blar nederst på siden til funksjonen du ser på, står det ofte flere eksempler på bruk. Disse kan være nyttige å se på for å skjønne hvordan man skal bruke en funksjon.\n",
-    "\n",
-    "Det er verdt å merke seg at NumPy blant annet har en egen pakke for *lineær algebra*, som heter `linalg`. Her finnes det mange funksjoner for å enkelt manipulere arrays; F.eks. transponere, løse egensystem, regne ut prikkprodukt og mye mer.\n",
-    "\n",
-    "For en gjennomgang av `np.reshape`, meshgrids og komplekse tall i NumPy, kan du følge [denne](https://nbviewer.jupyter.org/urls/www.numfys.net/media/notebooks/NumpyIntermediate.ipynb) linken (Ressursen er fra Institutt for Fysikk på NTNU). \n",
-    "\n",
-    "For en introduksjon til lineær algebra pakken kan du følge [denne](https://nbviewer.jupyter.org/urls/www.numfys.net/media/notebooks/linear_algebra_in_python.ipynb) linken (også denne ressursen er fra IFY på NTNU)."
-   ]
-  }
- ],
- "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.6"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": true,
-   "sideBar": true,
-   "skip_h1_title": false,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/JN3/JN3_introduksjon_numpy.ipynb b/JN3/JN3_introduksjon_numpy.ipynb
index 675fe85..ed47fb3 100644
--- a/JN3/JN3_introduksjon_numpy.ipynb
+++ b/JN3/JN3_introduksjon_numpy.ipynb
@@ -2229,7 +2229,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Nå har du lært mye om NumPy, slik at du enkelt kan komme igang med å programmere selv. Likevel er det greit å vite at NumPy har *veldig* mange flere funksjoner du kan benytte deg av. *Dokumentasjonen* til NumPy finner du  på https://numpy.org/doc/1.18/reference/index.html. Her ser du en oversikt over de ulike funksjonene som finnes. Det kan være vanskelig å lese dokumentasjonen til en pakke når man er ny i programmering, men om du blar nederst på siden til funksjonen du ser på, står det ofte flere eksempler på bruk. Disse kan være nyttige å se på for å skjønne hvordan man skal bruke en funksjon.\n",
+    "Nå har du lært mye om NumPy, slik at du enkelt kan komme igang med å programmere selv. Likevel er det greit å vite at NumPy har *veldig* mange flere funksjoner du kan benytte deg av. *Dokumentasjonen* til NumPy finner du  på https://numpy.org/doc/1.18/reference/index.html. Her ser du en oversikt over de ulike funksjonene som finnes. Det kan være vanskelig å lese dokumentasjonen til en pakke når man er ny i programmering, men om du blar nederst på siden til funksjonen du ser på, står det ofte flere eksempler på bruk. Disse kan være nyttige å se på for å skjønne hvordan man skal bruke en funksjon. I en senere notebook, [JN8 Lese dokumentasjon til bibliotek](../JN8/JN8_dokumentasjon.ipynb), går vi igjennom hvordan vi kan lese dokumentasjonen til Python.\n",
     "\n",
     "Det er verdt å merke seg at NumPy blant annet har en egen pakke for *lineær algebra*, som heter `linalg`. Her finnes det mange funksjoner for å enkelt manipulere arrays; F.eks. transponere, løse egensystem, regne ut prikkprodukt og mye mer.\n",
     "\n",
-- 
GitLab