diff --git a/Ovinger/Oving1/Avrundingsfeil - subtraksjon.ipynb b/Ovinger/Oving1/Avrundingsfeil - subtraksjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0459baf4a48fc9473c32aaf228dace488754aae5
--- /dev/null
+++ b/Ovinger/Oving1/Avrundingsfeil - subtraksjon.ipynb
@@ -0,0 +1,349 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "b2dd49dc",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li class = \"active\"><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Avrundingsfeil, subtraksjon mellom nesten like tall\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Avrundingsfeil\n",
+ "* Flyttallrepresentasjon\n",
+ "* Binære tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "528e52b5",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## Tutorial: Binære tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7293b584",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Du har sikkert hørt at datamaskiner er bygd opp av $1$-ere og $0$-ere. Dette er sant, og tallen kalles for binære tall. Binære tall er egentlig ikke noe skummelt, men kan være vankskelig å \"wrappe\" hodet rundt i starten. \n",
+ "\n",
+ "Til vanlig er vi vant med titallsystemet (base 10). Alle tall vi vanligvis jobber med og tenker på er bygd opp av tallene fra $0-9$. F.eks er $153$ bygd opp av $1$, $5$ og $3$. Binære tall er også kalt base 2 eller totallsystemet, og basen vår i totallsystemet er tallene $0$ og $1$. Med andre ord er alle tall i totallsystemet bygget opp av disse to tallene. For eksempel er $153$ i binært $10011001$.\n",
+ "\n",
+ "Andre måter å tenke på denne oppbyggingen av tall er ved hjelp av base-tallet ($10$ eller $2$). F.eks er $153$ lik $1 * 10^2 + 5 * 10^1 + 3 * 10^0$ (eller $100 + 50 + 3$). Akkurat det samme gjelder for binære tall. $10011001 = 1 * 2^7 + 0 * 2^6 + 0 * 2^5 + 1 * 2^4 + 1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 153$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9af175c4",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## Tutorial: Flyttallrepresentasjon"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0aac08d2",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Ved bruk av samme måte som vi kan representere heltall i base 10 med basetallet ($1 * 10^2 + 5 * 10^1 + 3 * 10^0$), kan vi representere desimaltall (flytall) med basetallet. Vi bare gjør eksponenten negativ. For eksempel har tallet $0.125$ (base 10) verdien $\\frac{1}{10} + \\frac{2}{100} + \\frac{5}{10000}$ eller $1 * 10^{-1} + 2 * 10^{-2} + 5 * 10^{-3}$ . I totallsystemet (eller base 2 / binært / binary) er $0.125$ lik $0.001$. Representert ved hjelp av basetallet får vi $\\frac{0}{2} + \\frac{0}{4} + \\frac{1}{8}$ (eller $0 * 2^{-1} + 0 * 2^{-2} + 1 * 2^{-3}$). \n",
+ "\n",
+ "Dessverre, kan vi ikke representere alle mulige desimaltall helt korrekt. $\\frac{1}{3}$ (base 10) vet vi er $0.33333...$. dette kan vi runde av til$0.3$, som blir $\\frac{3}{10}$. Eventuelt kan vi være mer presise ved å gjøre $\\frac{3}{10} + \\frac{3}{100}$ og få $0.33$ eller $\\frac{3}{10} + \\frac{3}{100} + \\frac{3}{1000}$ for å få $0.333$ osv.. I binært er dette enda verre. Ta for eksempel desimaltallet $0.1$ (base 10). Dette tallet kan ikke representeres nøyaktig med binære tall. Vi kan jo prøve. Fra over vet vi at flyttall i binært representeres ved $2$ med negative eksponenter: \n",
+ "* $1 * 2^{-1} = 0.5$. Det vil si vi er over $0.1$. Det binære tallet vårt er hittil $0.0$\n",
+ "* Hva med $1 * 2^{-2}$? Det er $0.25$ - fortsatt over. Det binære tallet vårt er hittil $0.00$\n",
+ "* $1 * 2^{-3}$? $0.125$. Fortsatt over. Det binære tallet vårt er hittil $0.000$\n",
+ "* $1 * 2^{-4}$? $0.0625$. Kult, nå er vi under. Det binære tallet vårt er nå $0.0001$, men vi er nå under $0.1$ (base 10)\n",
+ "* $1 * 2^{-4} + 1 * 2^{-5} = 0.09375$. Under $0.1$, så vi har det binære tallet $0.00011$ nå.\n",
+ "* $1 * 2^{-4} + 1 * 2^{-5} + 1 * 2^{-6} = 0.109375$. Nå er vi over igjen, så vi får det binære tallet $0.000110$\n",
+ "* $1 * 2^{-4} + 1 * 2^{-5} + 1 * 2^{-7} = 0.1015625$. Forstatt over, så vi får det binære tallet $0.0001100$\n",
+ "* La oss ta én til før vi stopper. $1 * 2^{-4} + 1 * 2^{-5} + 1 * 2^{-8} = 0.09765625$. Nå er vi under igjen og får det binære tallet $0.00011001$. \n",
+ "\n",
+ "Slik kan vi fortsette ut i evigheten, uten å få nøyaktig $0.1$. Vi approksimerer derfor $0.1$ til et tall _veldig nærme_ $0.1$, men ikke akkurat $0.1$. Dette skjer i datamaskiner og i Python også, noe som gjør at vi kan få avrundingsfeil. Et veldig klassisk eksempel på dette er $0.1 + 0.2$, som vi forventer at skal bli $0.3$. Prøv å kjøre kodeblokken under og se hva output blir."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "61abb57c",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f'0.1 + 0.2 = {0.1 + 0.2}')\n",
+ "print(f'0.1 + 0.2 == 0.3? {0.1 + 0.2 == 0.3}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6590f7e5",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I kodeblokken over ser du at $0.1 + 0.2$ faktisk ikke er $0.3$ i Python. Dette er siden vi ikke kan representere $0.1$ og $0.2$ nøyaktig i binær form. \n",
+ "\n",
+ "Python representerer flyttall med 32 bits, etter IEEE 754-standarden. Denne standarden sier, forkortet, at tall :\n",
+ "\n",
+ "* Bruk en bit til fortegn (sign) ($+ / -$)\n",
+ "* Bruk 8 bit til eksponent (exponent)\n",
+ "* Bruk 23 bit til signifikanten (fraction)\n",
+ "\n",
+ "Det er en matematisk formel for å representere slike tall, men her ser vi på et litt lettere eksempel. Ta tallet $625.9$. Det kan skrives som $0.6259 * 10^3$. Her er $0.6259$ _signifikanten_ og $3$ er _eksponenten_. I binært, etter IEEE 745-standarden, er dette $0\\;10001000\\;00111000111100110011010$ (delt opp slik at det blir lettere å lese). Den første biten ($0$) sier at dette er et positivt tall (fortegnet). De åtte neste bitsene ($10001000$) er eksponenten ($136$). Dette er en veldig høy eksponent, og dette er fordi den faktiske eksponenten er $127$ mindre, da altså $9$. De siste $23$ bitene ($00111000111100110011010$) er signifikanten. Denne blir regnet ut til å være $2^0 + (2^{-3} + 2^{-4} + 2^{-5} + 2^{-9} + 2^{-10}+ 2^{- 11} + 2^{-12}+ 2^{-15} + 2^{-16} + 2^{-19} + 2{-20} + 2^{-22}) = 1.22246098518$ hvor parentesen er signifikanten omgjort til binærrepresentasjon av flyttall. Resultatet blir $1.22246098518 * 2^9 = 625.9$ (ish). (Signifikant ganger 2 opphøyd i eksponent)\n",
+ "\n",
+ "En slik $32$-bit representasjon av flyttall kalles for \"single precision\" floating point number. Dersom vi hadde brukt $64$ bit for å representere hadde vi hatt en \"double precision\" floating point number. \n",
+ "\n",
+ "Du kan lese mer om IEEE 754-standarden [her](https://en.wikipedia.org/wiki/IEEE_754)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6016823",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## a) Tredje kvadratsetning"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3be988f",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Matematisk er $(a+b)(a-b)$ ekvivalent med $a^2 – b^2$ og de to skal dermed ideelt sett gi samme resultat. Beregninger med flyttall med endelig presisjon i en datamaskin kan imidlertid gi ulike resultat, hvor typisk den ene utregningsmåten er mer sårbar for avrundingsfeil enn den andre.\n",
+ "\n",
+ "Lag tre funksjoner:\n",
+ "\n",
+ "* `a_pluss_b_ganger_a_minus_b(a, b)` som tar inn tallene `a` og `b` og returnerer $(a+b)(a-b)$\n",
+ "* `a_opphoyd_i_annen_minus_b_opphoyd_i_annen(a, b)` som tar inn tallene `a` og `b` og returnerer $a^2 – b^2$\n",
+ "* `avvik(a, b)` som tar inn tallene `a` og `b` og returnerer avviket mellom $(a+b)(a-b)$ og $a^2 – b^2$\n",
+ "\n",
+ "Svar også på følgende spørsmål:\n",
+ "\n",
+ "Hvorfor skjer det en slik avrundingsfeil? Hvilken av måtene å regne ut $a^2 - b^2$ er å foretrekke?\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under. Skriv svaret på spørsmålet som en kommentar i koden***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b0ce1918",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce653a5b",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har gjort alt rett, skal kodeblokken under gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "0.21^2 - 0.2^2 = 0.0040999999999999925\n",
+ "0.21^2 - 0.2^2 = 0.004099999999999986\n",
+ "Avvik mellom de to regnemetodene = 6.938893903907228e-18\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a98b289c",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = 0.21\n",
+ "b = 0.2\n",
+ "\n",
+ "print(f'0.21^2 - 0.2^2 = {a_pluss_b_ganger_a_minus_b(a, b)}')\n",
+ "print(f'0.21^2 - 0.2^2 = {a_opphoyd_i_annen_minus_b_opphoyd_i_annen(a, b)}')\n",
+ "print(f'Avvik mellom de to regnemetodene = {avvik(a, b)}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f790cf1e",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## b) Flate trekanter"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8a56652",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis man ikke kjenner høyden på en trekant (og dermed ikke kan bruke den vanligste formelen for beregning av areal), men kjenner lengden på alle de tre sidene $a$, $b$ og $c$, kan man regne ut arealet ved formelen $A = \\sqrt{s(s-a)(s-b)(s-c)}$ , der $s = (a+b+c)/2$. Hvis trekanten er svært flat, vil den lengste siden $a$ være nesten like stor som $s$, slik at faktoren (s-a) gir subtraksjon av to nesten like tall, som er kjent for å kunne gi avrundingsfeil. For å unngå dette problemet, kan man i stedet bruke formelen $A = \\frac{\\sqrt{(a + (b + c))(c - (a - b))(c + (a - b))(a + (b - c))}}{4}$. Matematisk er de to formlene ekvivalente, men i praktisk beregning kan de gi ulike resultat.\n",
+ "\n",
+ "Funksjonen for $s$ og funksjon for avvik mellom de to formlene er allerede laget for deg under. Husk å kjøre denne kodeblokken om du vil bruke disse funksjonene:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cb218f8c",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def s(a, b, c):\n",
+ " return (a + b + c) / 2\n",
+ "\n",
+ "def avvik2(a, b, c):\n",
+ " return areal1(a, b, c) - areal2(a, b, c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "351496aa",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Din oppgave er:\n",
+ "\n",
+ "* Lag to funksjoner. `areal1(a, b, c)` tar inn sidene i en trekant, `a`, `b` og `c` og returnerer arealet av trekanten basert på den første formelen over. Den andre funksjonen `areal2(a, b, c)` gjør det samme, men med den andre formelen.\n",
+ "* Kall på funksjonen `avvik2(a, b, c)` med forskjellige verdier av `a`, `b` og `c`, og observer når det dukker opp et avvik mellom de to formlene\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee108f02",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bb54fc16",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har skrevet funksjonene rett, skal kodeblokken nedenfor, med `a = 4`, `b = 3.9` og `c = a + b - 1` gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "Areal med første formel: 6.635510530471639\n",
+ "Areal med andre formel: 6.635510530471637\n",
+ "Avvik mellom formlene: 1.7763568394002505e-15\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "539ddbdb",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Lek deg med a, b og c her!\n",
+ "\n",
+ "a = 4\n",
+ "b = 3.9\n",
+ "c = a + b - 1\n",
+ "\n",
+ "print(f'Areal med første formel: {areal1(a, b, c)}')\n",
+ "print(f'Areal med andre formel: {areal2(a, b, c)}')\n",
+ "print(f'Avvik mellom formlene: {avvik2(a, b, c)}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc4a5ad7",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "### Hint:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c916dde",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Husk å importere `numpy` og bruke `np.sqrt()` for kvadratrot."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Ovinger/Oving1/Avrundingsfeil - summering.ipynb b/Ovinger/Oving1/Avrundingsfeil - summering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..180cb151fa40d3e2e72cfe0a1c5696a853b80ebe
--- /dev/null
+++ b/Ovinger/Oving1/Avrundingsfeil - summering.ipynb
@@ -0,0 +1,226 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4531dc56",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li class = \"active\"><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Avrundingsfeil, summering av små og store tall\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Avrundingsfeil\n",
+ "* Flyttallrepresentasjon"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3f45f2e9",
+ "metadata": {},
+ "source": [
+ "<p style=\"color: red;\">Vi anbefaler at du leser igjennom tutorialene i oppgavene <a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a> og <a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a> før du gjør denne oppgaven.</p>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bb7153a3",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cc98d9d7",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Matematisk er rekkefølgen på leddene i en sum likegyldig, dvs. f.eks. skal $a + b + c + d + e + f + g$ gi samme resultat som $g + f + e + d + c + b + a$ (eller hvilken som helst annen rekkefølge), uavhengig av størrelsen til leddene. \n",
+ "\n",
+ "I en praktisk beregning med flyttall med endelig presisjon kan imidlertid rekkefølgen ha betydning, særlig hvis det er stor forskjell på tallenes størrelse (noen veldig store tall og noen bitte små tall). \n",
+ "\n",
+ "I denne oppgaven er det laget et program for deg. Dette programmet skal du lese, kjøre, endre og forstå. Det som er viktig at du får med deg her er at de ulike summeringsrekkefølgene gir ulike resultater. \n",
+ "\n",
+ "*Hvilken av metodene gir det mest korrekte svaret?*\n",
+ "\n",
+ "***Les, kjør, endre på tallene, og forså hva koden under gjør. Svar på spørsmålet som kommentar i koden***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "2cca24b5",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Sum av bare de små: 0.001209\n",
+ "Sum med stort tall først: 310000000000.0024\n",
+ "Sum med lite tall først: 310000000000.0012\n"
+ ]
+ }
+ ],
+ "source": [
+ "T = 3.1e11 # et stort tall\n",
+ "t = 3.1e-5 # et lite tall\n",
+ "\n",
+ "#sum av mange små tall\n",
+ "sum_mange = t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t\n",
+ "\n",
+ "# summerer med stort tall fremst, så de små\n",
+ "stor_fremst = T+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t\n",
+ "\n",
+ "# samme sum men nå med stort tall bakerst\n",
+ "stor_bakerst = t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+t+T\n",
+ "\n",
+ "print(f'Sum av bare de små: {sum_mange}')\n",
+ "print(f'Sum med stort tall først: {stor_fremst}')\n",
+ "print(f'Sum med lite tall først: {stor_bakerst}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b94c34a8",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e3833a90",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I denne oppgaven er det også skrevet et lite program for deg. Din oppgave her er å bytte ut alle `...` med rett kode. Hva koden skal gjøre står beskrevet i kommentarene. Du skal også svare på følgende spørsmål som kommentar i koden: \n",
+ "\n",
+ "*Hvilken av summeringsmetodene er å foretrekke når det kommer til avrundingsfeil?*\n",
+ "\n",
+ "Det som er viktig å få med seg fra denne oppgaven er at de ulike summeringsfunksjoner gir forskjellige resultat.\n",
+ "\n",
+ "***Endre kodeblokken under slik at du får forventet output, og svar på spørsmålet over som kommentar i koden***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "917774d1",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Standard sum(): 310000000000.0024\n",
+ "Numpy sum(): 310000000000.00134\n",
+ "Math fsum(): 310000000000.0012\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Liste med stort tall fremst, bruker Pythons standard sum-funksjon\n",
+ "L = [T,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t]\n",
+ "print(f'Standard sum(): {...}')\n",
+ "\n",
+ "# Numpy array, stort tall fremst, np.sum() funksjon\n",
+ "A = np.array(...)\n",
+ "print(f'Numpy sum(): {...}')\n",
+ "\n",
+ "# math.fsum() funksjonen\n",
+ "print(f'Math fsum(): {...}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1bcfa983",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har gjort alt rett skal output fra kodeblokken, med `T = 3.1e11` og `t = 3.1e-5`, bli:\n",
+ "\n",
+ "```python\n",
+ "Standard sum(): 310000000000.0024\n",
+ "Numpy sum(): 310000000000.00134\n",
+ "Math fsum(): 310000000000.0012\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25362937",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Hint:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9542530c",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Bruk metodene `np.sum()`, `sum()` og `math.fsum()`). Husk å importere `numpy` og `math`."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Ovinger/Oving1/Funksjoner og kalkulasjoner.ipynb b/Ovinger/Oving1/Funksjoner og kalkulasjoner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..223b6b1dcbf3b314ed5b5e66166a7bb13360c1b0
--- /dev/null
+++ b/Ovinger/Oving1/Funksjoner og kalkulasjoner.ipynb
@@ -0,0 +1,564 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li class = \"active\"><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Funksjoner og kalkulasjoner\n",
+ "\n",
+ "**Læringsmål**:\n",
+ "\n",
+ "* Funksjoner\n",
+ "* Aritmetikk\n",
+ "* Matematiske utrykk i Python\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du lære hvordan du skriver matematiske uttrykk for å gjøre utregninger i Python. I tillegg skal du lære enkel bruk og opprettelse av funksjoner."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n",
+ "Les gjerne denne før du starter med oppgavene"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n",
+ "\n",
+ "Tabellen under oppsummerer det mest grunnleggende:\n",
+ " \n",
+ "Matematikk | Python | Merknad\n",
+ "--- | --- | ---\n",
+ "a + b | a + b | Det er vanlig å sette et mellomrom på hver side av + men ikke påkrevd. <br> Kunne også ha skrevet a+b. Samme gjelder for andre regneoperatorer. <br> Smak og behag, men litt luft gjør ofte uttrykk lettere å lese.\n",
+ "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n",
+ "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n",
+ "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n",
+ "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n",
+ "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n",
+ "[(a + b) * c - d]|((a + b) * c - d)|I matematisk notasjon brukes av og til ulike parentessymboler () [] {} <br> hvis det er uttrykk med flere nivåer av parenteser nøstet inn i hverandre. <br> I Python må vanlig parentes () brukes for **alle** nivåer. [] og {} har en annen betydning.\n",
+ "\n",
+ "**Presedens** mellom operatorer fungerer som i matematikken.\n",
+ "\n",
+ "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n",
+ " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n",
+ " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n",
+ "* Potens har høyere presedens enn multiplikasjon og divisjon.\n",
+ " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n",
+ "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n",
+ " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n",
+ " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n",
+ " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n",
+ "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n",
+ "\n",
+ "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n",
+ "\n",
+ " $$\\frac{2-x}{2+x}$$ \n",
+ "\n",
+ "Horisontal brøkstrek viser tydelig at hele 2-x er teller og hele 3+x nevner. Med Pythons skråstrek for divisjon må man bruke parenteser her: (2 - x) / (3 + x)\n",
+ "\n",
+ " $$3^{xy+1}$$\n",
+ "\n",
+ "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a) Korrekt programmering av aritmetiske utrykk"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv følgende matematikk-setninger korrekt i Python:\n",
+ "\n",
+ "La $a$ være $2$\n",
+ "\n",
+ "La $b$ være $3$\n",
+ "\n",
+ "La $c$ være $5a + b$\n",
+ "\n",
+ "La $d$ være $a * b + c$\n",
+ "\n",
+ "La $e$ være $\\frac{-b + 4}{a - 4}$\n",
+ "\n",
+ "La $f$ være $5^{a * b + 2}$\n",
+ "\n",
+ "La $g$ være $[(a + b) * c - d]$\n",
+ "\n",
+ "**_Skriv koden din i kodeblokken under_**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Kjør kodeblokken under for å se at koden din fungerer som forventet. Hvis du har gjort alt rett, vil output være:\n",
+ "\n",
+ "```python\n",
+ "2\n",
+ "3\n",
+ "13\n",
+ "19\n",
+ "-0.5\n",
+ "390625\n",
+ "46\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n",
+ "print(a)\n",
+ "print(b)\n",
+ "print(c)\n",
+ "print(d)\n",
+ "print(e)\n",
+ "print(f)\n",
+ "print(g)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "### Tutorial - Funksjoner:\n",
+ "Les gjerne denne før du begynner på oppgaven"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I tillegg til likheter mellom matematikk og Python med hensyn til aritmetiske uttrykk, finnes det likheter for funksjoner. I matematikken mapper funksjoner en input $X$ til en output $Y$. Vi kan for eksempel ha funksjonen $f(x) = 2x + 3$, som mapper inputen $x$ til $2x + 3$. Setter man inn en verdi i denne funksjonen, f.eks $2$, vil man få outputen $2 * 2 + 3 = 4 + 3 = 7$. \n",
+ "\n",
+ "Det samme gjelder for funksjoner i Python. Forskjellen mellom funksjoner i Python og funksjoner i matematikken er at i Python trenger ikke nødvendigvis funksjonene å være matematiske. I tillegg er det en forskjell i opprettelsen av funksjonene. Denne øvingen vil gi en smakebit på bruk av funksjoner i Python, resten kommer i en senere øving. \n",
+ "\n",
+ "I denne øvingen skal du lære å skrive matematiske funksjoner, som over, i Python. En funksjon i Python defineres med `def`-nøkkelordet. Deretter kommer et funksjonsnavn, for eksempel `f`. Funksjonsnavnet kan være hva som helst, så lenge det følger de vanlige reglene for variabelnavn. Funksjonsdefinisjonen avsluttes med parenteser `()` og kolon `:`. Parentesene kan være tomme, eller de kan inneholde _parametere_ som i matematikken. Et parameter i matematikken er gjerne `x`, og er et tall. I Python kan parameterene være av hvilken som helst variabeltype, og er en helt vanlig variabel.\n",
+ "\n",
+ "Etter definisjonen av funksjonen kommer funksjonskroppen. Her skiller funksjonene i Python seg mest ut fra matematiske funksjoner. Matematiske funksjoner gir deg kun ett output. De gjør kun én ting. Funksjoner i Python kan være lengre og gjøre flere ting før den gir output. Dette kan f.eks være å sjekke at parameteren som gis med i funksjonen er korrekt, eller mellomlagre verdier og gjøre flere utregninger. \n",
+ "\n",
+ "Når en funksjon i Python skal gi output brukes `return`-nøkkelordet. Her sier man \"returner denne verdien\". Den returnerte verdien kan være av hvilken som helst variabeltype, i motsetning til matematikken som gir et tall som output. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def f(x): # Definerer funksjonen\n",
+ " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Når en funksjon står for seg selv, som funksjonen over, får vi ingen output når vi kjører koden. Funksjonen er kun _definert_, akkurat som når man oppretter seg en variabel. På samme måte som man ikke kan bruke variabler før de er definert, kan man ikke bruke funksjoner før de er definert:\n",
+ "\n",
+ "```py\n",
+ "# Her kan man ikke bruke a eller min_funksjon\n",
+ "\n",
+ "a = 1.3 # Assosierer navnet a med et flyttallsobjekt i minnet\n",
+ "\n",
+ "# Her kan man bruke a, men ikke min_funksjon\n",
+ "\n",
+ "def min_funksjon(): # Assosierer navnet min_funksjon med et funksjonsobjekt i minnet\n",
+ "\n",
+ "# Her kan man bruke begge\n",
+ "```\n",
+ "\n",
+ "\n",
+ "Prøv å kjøre kodeblokken over og se at du ikke får noe output.\n",
+ "\n",
+ "Når en funksjon er definert, kan vi _kalle_ på den. Dette kan man gjøre ved å skrive funksjonsnavnet, etterfulgt av parenteser og eventuelle _argumenter_ i parentesene. Kodeblokken under kaller på funksjonen `f(x)`, med argumentet $2$. Prøv å kjøre den!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "f(2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "### b) Skrive funksjonsuttrykk riktig i Python"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "**Skriv følgende matematiske funksjoner i Python:**\n",
+ "\n",
+ "$f(x) = 2x + 1$\n",
+ "\n",
+ "$g(x) = \\frac{-4x + 2}{5x + 3}$\n",
+ "\n",
+ "$h(x) = x^2 + 2x + 1$\n",
+ "\n",
+ "$i(x) = \\sqrt(x)$\n",
+ "\n",
+ "$j(x) = \\sin{x} + \\cos{x}$\n",
+ "\n",
+ "**_Skriv koden din i kodeblokken under_**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Kjør kodeblokken under for å se at koden din fungerer som forventet. Hvis du har gjort alt rett, vil output være:\n",
+ "\n",
+ "```python\n",
+ "21\n",
+ "-0.6428571428571429\n",
+ "16\n",
+ "2.0\n",
+ "-0.6752620891999122\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f(10))\n",
+ "print(g(5))\n",
+ "print(h(3))\n",
+ "print(i(4))\n",
+ "print(j(5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### Tutorial - Matteoperasjoner del 2: Heltallsdivisjon og Modulo:\n",
+ "\n",
+ "Les gjerne denne før du begynner på neste oppgave"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "I tillegg til vanlig divisjon / har Python også heltallsdivisjon som skrives // og modulo som skrives med operatoren %.\n",
+ "\n",
+ "Heltallsdivisjon og modulo minner om måten du lærte divisjon på barneskolen før du hadde lært desimaltall, altså med hele tall og rest.\n",
+ "\n",
+ "Tabellen under illustrerer hvordan disse operatorene virker:\n",
+ "\n",
+ "**Utrykk i Python**|**Resultat**|**Forklaring**\n",
+ "---|---|---\n",
+ "17 / 5\t|3.4\t|Vanlig divisjon\n",
+ "17 // 5|\t3\t|Heltallsdivisjon, gir hvor mange hele ganger nevneren 5 går opp i telleren 17\n",
+ "17 % 5\t|2|\tModulo, gir resten av 17 // 5, dvs. de 2 som blir til over\n",
+ "7.75 / 2.5\t|3.1|\tVanlig divisjon\n",
+ "7.75 // 2.5\t|3.0|\tHeltallsdivisjon, gir hvor mange hele ganger nevneren 2.5 går opp i 7.75.<br> Her blir svaret et flyttall (3.0) heller enn heltallet 3, fordi teller og nevner er flyttall.\n",
+ "7.75 % 2.5\t|0.25|\tModulo, Resten av 7.75//2.5 er 0.25 fordi 2.5 * 3.0 er 7.5\n",
+ "\n",
+ "Heltallsdivisjon og modulo har en rekke nyttige bruksområder i programmering.\n",
+ "\n",
+ "Ett eksempel er regning med enheter som aggregeres på andre måter enn det typiske 10, 100, 1000, slik som 60 sekund per minutt, 60 minutt per time, 24 timer per døgn, 7 døgn per uke.\n",
+ "\n",
+ "Koden under viser hvordan // og % kan brukes til slike beregninger. Prøv å kjør den."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def antall_hele_uker(dager):\n",
+ " return dager // 7\n",
+ "\n",
+ "def antall_uker_dager(dager):\n",
+ " uker = dager // 7\n",
+ " dager = dager % 7\n",
+ " return uker, dager\n",
+ "\n",
+ "print(antall_hele_uker(10))\n",
+ "print(antall_uker_dager(15))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T09:01:23.971652Z",
+ "start_time": "2019-07-01T09:01:23.962336Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det fins også mange andre nyttige anvendelser av // og %, som vil vise seg etter hvert som vi kommer til mer avanserte problemer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c) Bruk av heltallsdivisjon og modulo"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Lag tre funksjoner `antall_minutt_sekund(minutter)`, `antall_dogn_timer(timer)` og `antall_timer_minutt_sekund(sek)`, som gjør om sekunder til hele minutter, timer til hele døgn og sekunder til timer og minutter.\n",
+ "\n",
+ "**_Skriv koden din i kodeblokken under_**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Kjør kodeblokken under for å se at koden din fungerer som forventet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "print(antall_minutt_sekund(120))\n",
+ "print(antall_dogn_timer(75))\n",
+ "print(antall_timer_minutt_sekund(19832))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Riktig utskrift hvis du har fått det til, skal bli**\n",
+ "```\n",
+ "2\n",
+ "3\n",
+ "(5, 32)\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Geometri.ipynb b/Ovinger/Oving1/Geometri.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f68069aadcec511e6a5d282fd350f1972c4fba6e
--- /dev/null
+++ b/Ovinger/Oving1/Geometri.ipynb
@@ -0,0 +1,264 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li class = \"active\"><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Geometri\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Funksjoner\n",
+ "* Aritmetikk\n",
+ "* Matplotlib"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "I denne oppgaven skal du lage **funksjoner** for å finne omkrets og areal av en sirkel med gitt radius $r$, og areal og volum av en sylinder med gitt radius $r$ og høyde $h$. Formlene for omkrets, areal og volum finner du under:\n",
+ "\n",
+ "- Omkretsen til en sirkel er gitt ved $ O = 2\\pi r $, hvor $ r $ er radiusen til sirkelen.\n",
+ "- Arealet til en sirkel finner man med formelen $ A = \\pi r^2 $\n",
+ "- Arealet til en sylinder finner man ved å plusse sammen arealet til sikrelen på topp og bunn av sylinderen og arealet av \"den utbrettede\" rektangelen. Se illustrasjon nedenfor. Formelen for arealet er $A = 2\\pi r^2 + 2\\pi rh$, hvor $r$ er radius, og $h$ er høyden til sylinderen.\n",
+ "- Volumet av en sylinder finner man ved å multiplisere arealet av grunnflaten med høyden i sylinderen, eller med formelen $V = G \\cdot h = \\pi r^2 h$\n",
+ "\n",
+ "\n",
+ "\n",
+ "Du kan lese mer om areal og volum av sylinder på [Matematikk.org](https://www.matematikk.org/artikkel.html?tid=154998&within_tid=154319)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag fire funksjoner `omkrets_sirkel(r)`, `areal_sirkel(r)`, `areal_sylinder(r, h)` og `volum_sylinder(r, h)`. Bruk **numpy** for verdien til $\\pi$.\n",
+ "\n",
+ "**_Skriv koden din i kodeblokken under_**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:56:48.846273Z",
+ "start_time": "2019-07-01T11:56:48.833816Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her\n",
+ "\n",
+ "import numpy as np\n",
+ "\n",
+ "def omkrets_sirkel(r):\n",
+ " return\n",
+ "\n",
+ "def areal_sirkel(r):\n",
+ " return \n",
+ "\n",
+ "def areal_sylinder(r, h):\n",
+ " return \n",
+ "\n",
+ "def volum_sylinder(r, h):\n",
+ " return "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Hvis koden din er skrevet rett skal du få følgende ouput av kodeblokken under:\n",
+ "\n",
+ "```py\n",
+ "En sirkel med radius 5 har omkrets 31.41592653589793 og areal 78.53981633974483\n",
+ "En sylinder med radius 5 og høyde 6 har areal 345.5751918948772 og volum 471.23889803846896\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "run_control": {
+ "frozen": false
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "En sirkel med radius 5 har omkrets 31.41592653589793 og areal 78.53981633974483\n",
+ "En sylinder med radius 5 og høyde 6 har areal 345.5751918948772 og volum 471.23889803846896\n"
+ ]
+ }
+ ],
+ "source": [
+ "r = 5\n",
+ "h = 6\n",
+ "print(\"En sirkel med radius\", r, \"har omkrets\", omkrets_sirkel(r), \"og areal\", areal_sirkel(r))\n",
+ "print(\"En sylinder med radius\", r, \"og høyde\", h, \"har areal\", areal_sylinder(r, h), \"og volum\", volum_sylinder(r, h))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:57:35.984163Z",
+ "start_time": "2019-07-01T11:57:35.979863Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Formelene for areal og volum for sylinder innheholder mye likt som formlene for sirkel. Kan du gjenbruke kode?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "I denne oppgaven skal du lage et plot som inneholder to grafer; en for arealet til en sirkel og en for arealet til en sylinder. Dette skal gjøres ved bruk av Matplotlib.\n",
+ "\n",
+ "Plot funksjonene `areal_sirkel` og `areal_sylinder` du lagde i oppgave **a)**, med radiusen `r` på x-aksen. Velg `r`-verdier selv, men bruk `np.linspace`. Velg også høyden `h` til sylinderet selv.\n",
+ "\n",
+ "*Eksempel på hvordan plottet kan se ut:*\n",
+ "\n",
+ "\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "**Hint 1:** Les tutorialen i oppagaven [Plotting](./Plotting.ipynb)\n",
+ "\n",
+ "**Hint 2:** Husk å importere `matplotlib.pyplot as plt` og `numpy as np`"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Intro til jupyter.ipynb b/Ovinger/Oving1/Intro til jupyter.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d3dfbb83dd78656b6099a3da1d150d1f9eb9c505
--- /dev/null
+++ b/Ovinger/Oving1/Intro til jupyter.ipynb
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li class = \"active\"><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Introduksjon til Jupyter\n",
+ "\n",
+ "Hei, og velkommen til Jupyter, en annen måte å skrive kode på! Jupyter er et system som lar deg lage dokumenter som inneholder både tekst og kode på en gang. Det fine her er at du kan kjøre koden i dokumentet og se resultatet umiddelbart. Dette kan du prøve ut nå. \n",
+ "\n",
+ "**oppgave a)** Klikk på kodeblokken under og trykk `ctrl + enter` på tastaturet for å kjøre koden. (Det er også mulig å klikke på kodeblokken for så å klikke `run` i menyen på toppen)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Velkommen til Jupyter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser kommer resultatet av koden ut rett nedenfor kodeblokken. Dette er veldig praktisk og du kan kjøre koden så mange ganger du vil! Hvis du trykker på `ctrl + enter` i kodeblokken over en gang til vil du se at tallet til venstre for kodeblokken øker. Dette tallet brukes bare som referanse og er ikke noe du trenger å tenke på til vanlig.\n",
+ "\n",
+ "Alle kodeblokker i et dokument kan endres på, og dette oppfordres på det sterkeste! Det er mye god læring i å endre kode, tenke seg til hva som skal skje og sjekke om dette faktisk skjer. Du kan for eksempel prøve å kjøre programmet under med `ctrl + enter`, gjøre et par endringer og sjekke om den nye versjonen din gjør det du hadde tenkt."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Oppgave b)** Endre første linje i koden under til `print(\"Dette er mitt første Jupyter-program\")`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Dette er et program i jupyter\") #endre denne linjen\n",
+ "print(\"Nå skal programmet stille et spørsmål\")\n",
+ "navn = input(\"Hva heter du? \")\n",
+ "print(\"Hei\", navn)\n",
+ "\n",
+ "alder = int(input(\"Hvor gammel er du? \")) # Her må du kun skrive et tall\n",
+ "print(\"Da er du\", alder + 5, \"år gammel om 5 år\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Variabler mellom kodeblokker"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Noe som er verdt å merke seg er at data kan eksistere mellom kodeblokkene i en Jupyter Notebook. La oss se på et eksempel. Trykk `ctrl + enter` i kodeblokken nedenfor slik at den kjører."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "message = \"Wow! Dette var kult!\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kjør så kodeblokken nedenfor:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(message)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser får vi printet ut verdien av `message` selv om `message` ikke er definert i den nederste kodeblokken. Dette kan være veldig praktisk, men kan noen ganger være forvirrende. Prøv å endre på verdien til `message` (\"Wow! Dette var kult!\") i den første kodeblokken, for så å trykke `ctrl + enter` i den andre blokken.\n",
+ "\n",
+ "Som du ser er ikke `message` blitt oppdatert. Dette er fordi **vi er nødt til å kjøre kodeblokken med `message =` for at `message` skal bli oppdatert**. \n",
+ "\n",
+ "Prøv nå å kjøre kodeblokken med `message =` igjen for så å kjøre blokken med `print` på nytt. Da burde riktig melding printes.\n",
+ "\n",
+ "**Oppgave c)** Endre message til `\"Wow, Jupyter er kult!\"`, og print det ut i blokken under.\n",
+ "\n",
+ "Dette gjelder ikke bare for *variabler*, men også for *funksjoner*, som dere skal lære å bruke etterhvert. Hvis du skriver en funksjon og ønsker å bruke den i en annen kodeblokk må du kjøre kodeblokken hver gang funksjonen endres akkurat som med variabler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Restarting dersom problemer skulle oppstå"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du ønsker å fjerne all output fra dokumentet og *starte på nytt* kan du trykke på `Kernel -> Restart and clear output` i menyen på toppen. Det vil komme opp en boks med en skummel rød knapp, men dette går helt fint. Å kunne restarte kan også være nyttig hvis dokumentet henger seg opp. Dette skal vi se et eksempel på nå.\n",
+ "\n",
+ "Kjør kodeblokken under to ganger uten å taste inn noe i inputfeltet som dukker opp (du må trykke på blokken igjen for å kjøre den andre gang)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "navn = input(\"Hva heter du?\")\n",
+ "print(\"Hei,\", navn)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dette var veldig uheldig. Nå skjer det ingenting og vi kan heller ikke kjøre andre kodeblokker i dokumentet :(\n",
+ "\n",
+ "Når en kodeblokk venter på input kan man ikke kjøre andre kodeblokker, så hvis man da prøver å kjøre andre kodeblokker vil disse bli satt på vent.\n",
+ "\n",
+ "Nå ser vi at det står `In [*]` ved flere av blokkene våre, dette betyr at de venter på andre blokker før de selv kjører, i vårt tilfelle kjørte vi input-blokken på nytt, uten å gi inn noe til forrige kjøring av blokken. Programmet venter fortsatt på input til forrige kjøring av blokken, selv om feltet er borte, som ikke er helt optimalt! Om du ikke forstår helt hva som skjer her er ikke det noe farlig. For å komme oss ut av dette kan vi restarte med `Kernel -> Restart and clear output` i toppmenyen. **Merk: Dette endrer ikke på koden du selv har skrevet.**\n",
+ "\n",
+ "**Oppgave d)** Restart notebooken med kommandoen beskrevet over."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Endring av tekst"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er også mulig å endre på teksten i et dokument ved å dobbelklikke på en tekstboks, men dette er noe du sjeldent trenger å gjøre. For å gjøre teksten «vanlig» igjen etter at du har endret trykker du her også på `ctrl + enter`.\n",
+ "\n",
+ "Jupyter bruker noe som heter markdown til formatering av tekst. Dette er ikke pensum, men hvis du ønsker å se litt på det finnes det en ganske fin oversikt (på engelsk) [her](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet?fbclid=IwAR2PRFaYr3YAPnKBzNRpgaumRufU4WHbT6Xd-0v9EsJwxtgqxOyzLluvPOA#tables). Det er også mulig å legge til LaTeX (et tekst-format til å lage fine matteuttrykk) i jupyter-tekstbokser. Dette er heller ikke pensum.\n",
+ "\n",
+ "Hvis vi skal be dere om et tekst-svar vil vi dere se noe sånt som under. Her kan dere selv fjerne det som står inne i krokodilletegnene.\n",
+ "\n",
+ "**Oppgave e)** Endre tekstboksen under til `ITGK er gøy`. *Merk: I en tekstboks trenger man ikke skrive python-kode*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Ditt svar:** <dobbelklikk her for å svare\\>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# En advarsel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Jupyter er generelt ikke så glad i at du har samme dokument åpnet i flere faner. Hvis du har dette er det mulig at endringene du gjør i den ene fanen overskriver endringene du gjør i en annen fane, noe som kan være uheldig. Sørg derfor for at du aldri har mer enn en fane åpnet med det samme dokumentet."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Til slutt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er mange muligheter som ligger inne i jupyter, og vi skal ikke bruke alt i dette kurset. Det er ingenting som hindrer dere fra i å finne andre jupyter-notatbøker på nettet selv hvis dere ønsker mer utfordring eller å utforske hva som er mulig.\n",
+ "\n",
+ "**Lykke til videre med jupyter!**"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Plotting.ipynb b/Ovinger/Oving1/Plotting.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..375d1c2dd3fcd2d24f3426a68c174fb9b5ab8953
--- /dev/null
+++ b/Ovinger/Oving1/Plotting.ipynb
@@ -0,0 +1,509 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "9787c3b2",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li class = \"active\"><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Plotting\n",
+ "\n",
+ "**Læringsmål**:\n",
+ "\n",
+ "* Matplotlib\n",
+ "* Numpy\n",
+ "* Matematiske funksjoner"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e4c072e4",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## Tutorial - Plotting\n",
+ "Les gjerne denne før du starter med oppgavene"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "97a14d69",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "For å tegne grafer er vi nødt til å bruke ekstrafunksjoner som er utenfor \"standard python\". Disse funksjonene er lagret i såkalte *bibliotek*, som er kode andre har laget og som vi kan bruke. Biblioteket vi skal bruke for å plotte grafer heter `matplotlib`.\n",
+ "\n",
+ "Ofte er det ikke nødvendig å vite alt om hvordan et bibliotek fungerer, men heller hvordan man bruker det. Dette kan man finne ut av ved for eksempel å google eksempler på bruk (tutorials) eller lese dokumentasjonen for biblioteket. Den offisielle oversikten over matplotlib (fra de som har laget det) ligger for eksempel [her](https://matplotlib.org/3.5.2/users/index.html). Denne inneholder informasjon om alt det er mulig å bruke matplotlib til (som er veldig mye!) og trengs ikke å leses for å kunne følge med videre i dette dokumentet.\n",
+ "\n",
+ "## Importering av matplotlib\n",
+ "\n",
+ "For å kunne bruke biblioteket `matplotlib` må vi først *importere* det. I vårt tilfelle trenger vi ikke å importere hele matplotlib, men bare delen `pyplot` som er den delen som lar oss tegne grafer. Denne importerer vi i koden under og kaller for `plt`. Dette gjør at vi senere kun trenger å skrive `plt` i stedet for `matplotlib.pyplot`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "feadbae8",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8bb01543",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "`%matplotlib inline` gjør at grafene vises direkte i dokumentet. Uten denne vil du ikke kunne se grafene.\n",
+ "\n",
+ "## NÃ¥: La oss tegne noen grafer! :D\n",
+ "Under ser du et eksempel på en enkel kode som tegner en graf. Dette eksempelet består av tre kodelinjer som alle bruker `pyplot` fra `matplotlib`-biblioteket (som vi har døpt om til `plt`)\n",
+ "\n",
+ "- Funksjonen `plt.plot` tar inn en liste med verdier som blir y-verdiene i grafen.\n",
+ "- Funksjonen `plt.ylabel` brukes for å sette teksten som skal være på y-aksen.\n",
+ "- Funksjonen `plt.show` brukes for å vise grafen\n",
+ "\n",
+ "**Kjør koden under og se hva som skjer!**. Lek deg med å endre verdiene og kjøre koden på nytt :)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ab8d0b9",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "plt.plot(np.array([1, 2, 4, 3]))\n",
+ "plt.ylabel('Noen tall')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44b44af9",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det verdt å merke seg at listen som plt.plot tar inn også kan være en variabel. Dette er gjort i eksemepelet under. Her er listen lagret i en variabel `x`, som så brukes for plotting.\n",
+ "\n",
+ "**Kjør koden under og se om du forstår hvordan den fungerer**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f2b82228",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "%matplotlib inline\n",
+ "\n",
+ "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])\n",
+ "\n",
+ "plt.plot(x)\n",
+ "plt.ylabel('Tall')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec8d2ede",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det virker kanskje som om `plt.plot` ikke er så nyttig, siden alle punktene kun har 1 mellom seg på x-aksen. Dette er feil. Funksjonen har faktisk et hav av muligheter! Vi kan for eksempel spesifisere punkter både på x-aksen og y-aksen ved å gi inn to lister til funksjonen.\n",
+ "\n",
+ "**Kjør koden under og prøv å endre verdiene for å se hva som skjer!** Prøv gjerne også å se hva som skjer hvis man har x-verdier som ikke er i stigende rekkefølge som nå."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d088efc5",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np \n",
+ "%matplotlib inline\n",
+ "\n",
+ "x_verdier = np.array([2, 4, 8, 16])\n",
+ "y_verdier = np.array([2, 4, 6, 8])\n",
+ "plt.plot(x_verdier, y_verdier)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "47ed3e98",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Så langt har vi ikke plottet det man vanligvis tenker på funksjoner, for eksempel $f(x) = 2x + 2$. Vi har kun laget våre egne verdier og plottet de, istedenfor å få verdiene fra en slik funksjon. La oss lage funksjonen vår:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1a2b4a5f",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def f(x):\n",
+ " return x**2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d80d52c8",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Når vi så har funksjonen vår, trenger vi x-verdier. I kodeblokkene over har vi skrevet x-verdiene våre manuelt. Dette er ikke alltid like lett, dersom vi skal ha mange x-verdier. Heldigvis finnes det en funksjon i **numpy**-biblioteket som gjør dette for oss! `np.linspace(start, stop, num)` tar inn parameterene `start`, `stop` og antall intervaller `num`. Den gir deg et array med `num` antall jevnt fordelte verdier mellom `start` og `stopp`. Dette kan vi bruke for å lage x-verdiene våre, samt plotte funksjonen $f(x) = 2x + 2$ i et gitt x-intervall. Etter vi har laget oss disse x-verdiene, kan vi lage y-verdier som er x-verdiene kjørt igjennom funksjonen `f(x)`. Deretter kan vi plotte resultatet.\n",
+ "\n",
+ "**Kjør koden nedenfor og se hva som skjer!**. Prøv også å endre både `f(x)` over, `start`, `stop` og `intervaller` for å se hvordan grafen endrer seg. Legg spesielt merke til hvordan grafen blir \"hakkete\" jo mindre `intervaller` vi har."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d84dca4",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "%matplotlib inline\n",
+ "\n",
+ "start = -10\n",
+ "stop = 10\n",
+ "intervaller = 5\n",
+ "\n",
+ "x_verdier = np.linspace(start, stop, intervaller)\n",
+ "y_verdier = f(x_verdier) # Her kjører vi alle x-verdiene våre gjennom funksjonen f(x)\n",
+ "\n",
+ "plt.plot(x_verdier, y_verdier)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cd11edbb",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Lek deg mer med np.linspace her\n",
+ "import numpy as np\n",
+ "\n",
+ "start = -10\n",
+ "stop = 10\n",
+ "intervaller = 5\n",
+ "print(np.linspace(start, stop, intervaller))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4342043a",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det er også mulig å lage punkter i stedet for linjer. Her må det legges med en streng i et spesielt format til `plt.plot`. I eksempelet under betyr strengen `\"ro\"` at vi bruker røde prikker. `r` for *red*, `o` for *runding*.\n",
+ "\n",
+ "**Kjør koden under og se hva som skjer!** Prøv også å bytte ut `'ro'` med andre strenger, som `'g-'`, `'b^'`, `'r--'`, `'k:`' og `'ys'`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "393bdc76",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "%matplotlib inline\n",
+ "\n",
+ "plt.plot(np.array([1, 2, 3, 4]), np.array([1, 4, 9, 16]), 'ro')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d89ea5e",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Dette gjør at vi også kan plotte flere grafer oppå hverandre og skille mellom de, som i eksempelet under:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e83ec416",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "\n",
+ "plt.plot(np.array([0, 1, 2, 3, 4, 5]), np.array([0, 1, 2, 3, 4, 5]), 'r-')\n",
+ "plt.plot(np.array([0, 1, 2, 3, 4, 5]), np.array([0, 1, 4, 9, 16, 25]), 'b-')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c40397e5",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8417ae82",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det du skal gjøre i denne oppgaven er å lage tre funksjoner:\n",
+ "* $f(x) = x^2 - 3x + 2$\n",
+ "* $g(x) = 3\\sin(x)$\n",
+ "* $h(x) = \\frac{42x}{x^2+4}$ \n",
+ "\n",
+ "i Python, og plotte disse i _samme_ plot. Bruk de oppgitte x-verdiene. Husk å importere **matplotlib** :)\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "05d31b50",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her\n",
+ "import numpy as np\n",
+ "\n",
+ "x_verdier = np.array([-3, -1, 1, 3, 5])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "976e8f5a",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d17f277",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Ser du at plottene i oppgave **a)** er \"hakkete\"? I denne oppgaven skal du fikse opp i det. Bruk de samme funksjonene som du lagde i oppgave **a)**, men denne gangen, skriv om koden slik at plottene blir \"smoothere\". \n",
+ "\n",
+ "***Skriv koden din i kodeblokken nedenfor***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ce9f7a57",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Kopier over koden din fra a) her, og gjør endringer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "671da685",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Eksempel på hvordan plottet kan bli:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b43942f3",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## c) Frivillig (vanskelig)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44ac5f43",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Denne oppgaven er frivillig og du trenger ikke gjøre den for å få oppgaven godkjent."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8ddf0d55",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I denne oppgaven skal du gjøre plottet fra **b)** enda penere. \n",
+ "\n",
+ "Det er frivillig hvordan du gjør plottet penere, noen tips er:\n",
+ "\n",
+ "* Sett aksene som et \"kors\" i midten av plottet\n",
+ "* Legg på merkelapper på grafene, slik av vi kan differensiere mellom f, g og h\n",
+ "* Legg til en tittel til plottet\n",
+ "* Legg på merkelapper på aksene\n",
+ "\n",
+ "Vi oppfordrer til å lese [dokumentasjonen til matplotlib](https://matplotlib.org/3.5.2/api/index.html) for å løse denne oppgaven.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a452b2d4",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "317588c8",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Et eksempel på hvordan grafen _kan_ se ut vises på bildet under:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08d6c5e8",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Hint:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7260fe91",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Les deg opp på funksjonen [`plt.figure()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.figure.html), [`Axes`](https://matplotlib.org/stable/api/axes_api.html#matplotlib.axes.Axes), [`Figure.gca()`](https://matplotlib.org/stable/api/figure_api.html#matplotlib.figure.Figure.gca) og [`Axes.legend()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.legend.html)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Ovinger/Oving1/Priser med og uten moms.ipynb b/Ovinger/Oving1/Priser med og uten moms.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..04bf16a5b3b4ed032ca3d6aaab275b85202a4f1d
--- /dev/null
+++ b/Ovinger/Oving1/Priser med og uten moms.ipynb
@@ -0,0 +1,220 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "44c0dc8c",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li class = \"active\"><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Priser med og uten moms\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Aritmetikk\n",
+ "* Funksjoner"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "abd1ec0a",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4fe0ec27",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I denne oppgaven skal du lage to funksjoner. Den første `pris_u_moms(pris_m_moms)` tar inn en `pris_m_moms` som parameter og returnerer prisen uten moms. Anta $25\\%$ moms i denne funksjonen. \n",
+ "\n",
+ "Det er ikke alltid momsen er $25\\%$. Når du kjøper mat på restaurant og velger \"ta med\" for eksempel, er momsen bare $15\\%$. Du skal derfor også lage en funksjon `pris_m_valgfri_moms(pris_u_moms, moms)` som tar inn både prisen uten moms (`pris_u_moms`) og momsen som skal legges til (`moms`), og returnerer den nye prisen.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken nedenfor***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a6e16b70",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f\"\"\"\n",
+ " Kvittering hos ITGK shopen\n",
+ " --------------------------------\n",
+ " Imsdal (0.5dl)\n",
+ " 1 25 \n",
+ " --------------------------------\n",
+ " Pris ex. moms {pris_u_moms(25)}\n",
+ " Moms 25 % {25 - pris_u_moms(25)}\n",
+ " TOTAL {pris_m_valgfri_moms(pris_u_moms(25), .25)} \n",
+ " \"\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5bb84ced",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har gjort oppgaven rett, skal kodeblokken under gi output:\n",
+ "\n",
+ "```python\n",
+ "\n",
+ " Kvittering hos ITGK shopen\n",
+ "--------------------------------\n",
+ "Imsdal (0.5dl)\n",
+ " 1 25 \n",
+ "--------------------------------\n",
+ "Pris ex. moms 20.0\n",
+ "Moms 25 % 5.0\n",
+ "TOTAL 25.0\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0823d408",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30174002",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Vi ønsker nå å bergene for mye total moms vi skal betale for en del varer samtidig. Vi har fått vite at for hver vare skal vi betale $10\\%$ moms, men vi sliter litt med koden vår. Kan du hjelpe oss?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cea3791f",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "priser_inkl_moms = np.array([27.5, 19.8, 46.2, 82.5, 5.5, 37.95])\n",
+ "moms = ...\n",
+ "moms_til_betaling = ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34e5d7a8",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har skrevet koden over rett, skal output av kodeblokken under gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "Moms pr. vare: [2.5 1.8 4.2 7.5 0.5 3.45]\n",
+ "Total moms å betale: 19.95\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27ac47bf",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f'Moms pr. vare: {moms}')\n",
+ "print(f'Total moms å betale: {moms_til_betaling}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fc86338b",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c456451e",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "**Hint 1:** Sjekk ut oppgaven [Tall- og Typekonvertering](Tall-%20og%20Typekonvertering.ipynb) og tutorialen på \"Datatyper\". Her kan du lese om **Numpy arrays**.\n",
+ "\n",
+ "**Hint 2:** `np.sum()` summerer alle tallene i et array"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.9.7 ('tdt4195')",
+ "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.7"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "63b89d9bfc14eb4486c27c9b239bf0a08c4c63a21c176f83036370f0e204c130"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Ovinger/Oving1/Tall- og Typekonvertering.ipynb b/Ovinger/Oving1/Tall- og Typekonvertering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b742ccf41226627a09023fcbaa1815be7e3e681f
--- /dev/null
+++ b/Ovinger/Oving1/Tall- og Typekonvertering.ipynb
@@ -0,0 +1,1287 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li class = \"active\"><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Tall- og Typekonvertering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Datatyper\n",
+ "* Konvertering mellom datatyper\n",
+ "* Funksjoner\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## Tutorial: Datatyper"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I Python, og andre programmeringsspråk, kan data ha forskjellige _typer_. Forskjellige datatyper egner seg for forskjellige bruksområder. For eksempel hvis vi skal lagre alderen til en person, vil det lønne seg å lagre dette i en `int`. Navnet til samme person, derimot, bør være en `string`. \n",
+ "\n",
+ "Det finnes mange forksjellige datatyper, men vi skal ikke gå igjennom alle her. Det kommer i en senere øving. De du skal lære her er:\n",
+ "\n",
+ "* **Integer** - et heltall. F.eks `10`. I Python brukes `int` for en integer\n",
+ "* **Float** - et flyttall (tall med desimal). F.eks `10.5`\n",
+ "* **String** - tekst. F.eks `\"ITGK\"`. I Python brukes `str` for en string\n",
+ "* **Boolean** - sannhetsverdi. Enten `True` eller `False`. I Python brukes `bool` for boolean\n",
+ "* **List** - en liste med verdier. En liste inneholder variabler/verdier av hvilken som helst datatype. F.eks `[1, 2, \"Er ITGK kult?\", True]`\n",
+ "* **ndarray**/**np.array** - et array. F.eks `np.array([1,2,3,4])`. \n",
+ "\n",
+ "Les mer om de forksjellige datatypene nedenfor:\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Integer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Integers er enten et negativt heltall, 0 eller et positivt heltall. Som kjent fra matematikken er Integers tallene denotert som $\\mathbb{Z}$. (les mer om Integers i matematikken [her](https://en.wikipedia.org/wiki/Integer). La oss nå lage noen ints i Python, det er utrolig lett. Kjør kodeblokken nedenfor:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = -10\n",
+ "b = 0\n",
+ "c = 10"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Integers følger et set med regler, akkurat som i matematikken. Vi kan for eksempel addere integers, hvor resultatet også vil være en integer. Det samme gjelder for multiplikasjon. Utfører vi _divisjon_ med to integers derimot, vil resultatet være en `float`. La oss gjøre litt aritmetiske operasjoner på ints. Prøv å kjøre kodeblokken under:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(a + b) # Samme som å si -10 + 0\n",
+ "print(b - c) # Samme som 0 - 10\n",
+ "print(a * c) # Samme som -10 * 10\n",
+ "print(b * c) # Samme som 0 * c\n",
+ "print(a / b) # Samme som -10 : 0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Whoops, ser du koden over ga en feilmelding? Karer du å se hva feilen er? Hvis ikke er ikke det så farlig, vi forteller deg nå; på siste linje prøver vi å dele på `0`. Dette vet vi fra matematikken at er fyfy, og det samme gjelder i Python. Det som er fint med Python ovenfor matetmatikken er at Python sier ifra når du gjør noe som ikke er lov, slik som over. Det aller verste som kan skje er at programmet kræsjer, og vi må fikse opp i bugs. Se om du klarer å fikse opp i feilen over, slik at programmet kjører uten å kræsje."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Float"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Floats oppfører seg på nesten samme måte som Integers. De består av de rasjonale tallene $\\mathbb{Q}$. De skiller seg fra Integers ved at de kan ligge mellom heltall. La oss lage noen floats. Kjør kodeblokken nedenfor:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "d = 1.2\n",
+ "e = -4.2\n",
+ "f = 0.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "På samme måte som med `int`s kan vi utføre aritmetiske operasjoner på floats. Kjør kodeblokken under og se at du forstår hva som skjer:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(c + e) # Samme som 1.2 + (-4.2)\n",
+ "print(c - e) # Samme som 1.2 - (-4.2)\n",
+ "print(f * e) # Samme som 0.0 * (4.2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### String"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "String er en datatype som inneholder tekst. For å lage en streng skriver vi tekst omringet av \"fnutter\". Vi kan bruke både enkeltfnutter `'Jeg er en streng'`, dobbeltfnutter `\"Jeg er en annen streng\"` eller trippelfnutter `\"\"\"Jeg er enda en streng\"\"\"`. Alle tre måtene å skrive strenger på er like riktig, men de har forskjellige bruksområder. Enkelt- og dobbeltfnutter er veldig like. En av forskjellene er at om du bruker enkeltfnutter, kan du ha dobbeltfnutter i teksten uten noe problem, og omvendt ved bruk av dobbeltfnutter. For eksempel `'Ordet \"stein\" kan være både et navn og et objekt man finner i naturen'` eller `\"Ordet 'stein' kan være både et navn og et objekt man finner i naturen\"`. Trippeltfnutter lager såkalte \"multiline\"-strenger. Altså kan vi få strenger på flere linjer. Kjør kodeblokken under og se om du forstår hva som skjer:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "s1 = 'Jeg er en streng med enkeltfnutter'\n",
+ "s2 = \"Jeg er en streng med dobbeltfnutter\"\n",
+ "s3 = \"\"\"Jeg er en\n",
+ "multiline streng\"\"\"\n",
+ "\n",
+ "print(s1)\n",
+ "print(s2)\n",
+ "print(s3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Vi kan ikke gjøre aritmetiske operasjoner på strenger, på samme måte som `int`s og `float`s. Det betyr derimot ikke at vi ikke kan bruke matematiske operatorer på strenger:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "s4 = '10' + '15' + '20'\n",
+ "print(s4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "`+` operatoren \"setter sammen\" strenger. Som i eksempelet over setter vi sammen, eller konkatinerer, tre strenger; `'10'`, `'15'` og `'20'`, til én stor streng `'101520'`. Du ser forhåpentligvis at tallene `10`, `15` og `20` _ikke_ blir addert til `45` slik de ville blitt om de var `int`s eller `float`s, men strengene blir konkatinert. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "s5 = '10' * 10\n",
+ "print(s5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "`*` operatoren ganger strengen antall ganger. I eksempelet over ganger vi strengen `'10'` med `10`, og får den resulterende strengen `'10101010101010101010'` ('10' 10 ganger), ikke `100` som om vi hadde ganget `int`en `10` med `int`en `10`. Operatorene `-` og `/` kan vi ikke bruke på strenger."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Innimellom er det fint å ha andre datatyper inne i strenger. Dette gjøres lett med **f-strings**:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "s6 = f'Jeg er en f-string, og jeg kan ha for eksempel ints i meg: {12345}, eller floats: {123.45}'\n",
+ "print(s6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det som er verdt å merke seg med **f-strings** er at så fort andre datatyper blir inkorporert inne i strengen, er de ikke lenger sin egen datatype. De er nå en del av den nye strengen. F-strings er helt vanlige strenger, men de er litt lettere å formatere de. Inne i krøllparentesene {} kan vi ha stort sett det vi vil, også variabler:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "tall = 12345\n",
+ "s7 = f'Her er et tall: {tall}'\n",
+ "print(s7)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Boolean"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "En `bool` er en sannhetsverdi, enten `True` eller `False`, og er en _veldig_ sentral datatype i programmering. Booleans kan brukes for eksempel til å sjekke om en alder er under eller over `18`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "gjort_oving = False\n",
+ "print(f'Jeg har gjort øvingen min: {gjort_oving}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Senere i emnet vil du lære om if-setninger. Da står booleans sentralt. En liten smakebit her:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "fint_vaer = True\n",
+ "if fint_vaer:\n",
+ " print('Det er fint vær, gå ut!')\n",
+ "else:\n",
+ " print('Det er ikke fint vært, bli inne du')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Prøv å endre variabelen `fint_vaer` til `False` og se hva som skjer. Dette er et eksempel på bruk av booleans og hvordan de kan endre utfallet av et program."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### List"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Lister er en annen fundamental datatype i Python. Lister er er en samling av verdier, enten av andre datayper, eller av lister selv. For å lage en liste brukes klammeparantesene []. Inne i klammene legger vi verdiene våre, sparert med komma. Prøv å kjøre kodeblokken under, gjerne endre på verdiene også."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "liste_med_tall = [1, 2, 3, 4]\n",
+ "print(f'Her har du en liste med tall: {liste_med_tall}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Du vil lære mer om lister senere, som for eksempel hvordan du henter ut elementer. Det viktigste for nå er å vite hvordan du oppretter en :) Lister kan som sagt inneholde flere forskjellige datatyper:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "liste_med_forskjellige_verdier = [1.0, 4, True, 'hei på deg']\n",
+ "print(f'Her har du en liste med forskjellige verdier: {liste_med_forskjellige_verdier}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "På samme måte som strenger kan vi ikke gjøre vanlige matematiske operasjoner på lister. Vi kan derimort gange en liste med et tall, og plusse sammen lister. Oppførselen blir det samme som når vi ganger en streng med et tall, eller plusser sammen to strenger. _Elementente_ i listen blir ikke ganget med tallet, de vil bli replikert X ganger. _Elementene_ i listene vil heller ikke bli plusset sammen ved bruk av `+`, men den ene listen blir lagt til i den andre listen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "liste_med_tall = [1,2,3,4]\n",
+ "liste_med_tall2 = [5,6,7,8]\n",
+ "\n",
+ "liste2 = liste_med_tall + liste_med_tall2\n",
+ "print(liste2)\n",
+ "\n",
+ "liste3 = liste_med_tall * 10\n",
+ "print(liste3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Ndarray"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Datatypen `ndarray` kommer fra det eksterne biblioteket `numpy` og er en type liste. `ndarray` blir ofte omtalt som \"Numpy array\" eller bare \"array\". For å opprette et array må vi først _importere_ Numpy biblioteket. Det betyr i praksis at vi henter kode som er skrevet av noen eksterne, slik at vi kan bruke den. Deretter bruker vi funksjonen `array()` i biblioteket for å opprette arrayet vårt.\n",
+ "\n",
+ "I eksempelet nedenfor importeres Numpy, og vi kaller importen for `np`. Deretter oppretter vi arrayet med `np.array([])`. Klammeparantesene inne i de vanlige parantesene her er en helt vanlig liste, som definert over. Denne må være med - vi oppretter arrayet utifra en liste. Eksempelet under oppretter bare et tomt array."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr = np.array([])\n",
+ "print(arr)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "For å opprette et array med verdier legger vi bare en liste med verdier som argument inn i `array()`-funksjonen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr = np.array([1, 2, 3, 4])\n",
+ "print(arr)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "La du merke til at kommaene i arrayet ikke er med i output? Dette karakteriserer et array.\n",
+ "\n",
+ "I motsetning til vanlige lister kan ikke arrays inneholde flere forskjellige datatyper. Datatypen arrayet inneholder blir bestemt av det første elementet i listen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr = np.array(['Jeg er en streng', 1, 2, True, False])\n",
+ "print(arr)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I output ser du at _alle_ elementene har fnutter rundt seg, som viser at de nå er strenger, selvom vi la de inn som `int`s og `bool`s. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Arrays skiller seg også fra lister når det kommer til aritmetiske operasjoner. I motsetning til lister hvor for eksempel, elementene i listen blir replikert X når vi ganger listen med et tall, vil den aritmetiske operasjonen bli utført _på_ elementene i et array:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr = np.array([1, 2, 3, 4, 5])\n",
+ "print(arr + 2) # Legger til 2 på alle elementene i arrayet\n",
+ "print(arr - 2) # Trekker fra 2 fra alle elementene i arrayet\n",
+ "print(arr * 2) # Ganger alle elementer i arrayet med 2\n",
+ "print(arr / 2) # Deler alle elementer i arrayet med 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Med arrayer kan vi tilogmed legge sammen/gange sammen/trekke fra eller dele forskjellige arrayer. En viktig ting når vi gjør dette er at alle array som inngår i operasjonene har like lengde:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr1 = np.array([1, 2, 3, 4, 5, 6])\n",
+ "arr2 = np.array([6, 5, 4, 3, 2, 1])\n",
+ "\n",
+ "print(arr1 + arr2)\n",
+ "print(arr1 - arr2)\n",
+ "print(arr1 / arr2)\n",
+ "print(arr1 * arr2)\n",
+ "\n",
+ "arr3 = np.array([1, 2, 3])\n",
+ "print(arr1 + arr3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Siste `print()` i kodeblokken over gir en feilmelding. Klarer du å se hvorfor? Og klarer du rette opp i det?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial: Konvertering mellom datatyper"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Vi kan ha ulike typer data, som tekststrenger (f.eks. `\"Python\"`), heltall (f.eks. `42`), flyttall (f.eks. `9.80`) og sannhetsverdier (`True`, `False`). Ofte kommer vi i situasjoner hvor vi har data av en viss type, men vi trenger samme data bare med en annen type. Da må vi konvertere dataene. Noen vanlige konverteringsfunksjoner:\n",
+ "\n",
+ "**`int()`** - konverterer til heltall.\n",
+ "- `int('423')` gir 423 (dvs. tekststrengen blir konvertert til et tall). Virker kun hvis tekststrengen faktisk inneholder et heltall.\n",
+ "- `int(5.69)` gir 5 (dvs. for flyttall blir desimaldelen fjernet)\n",
+ "\n",
+ "**`float()`** - konverterer til flyttall\n",
+ "- `float('5.69')` gir 5.69 (tekststreng konvertert til tall)\n",
+ "- `float('5')` gir 5.0, dvs. float() virker på tekststrenger enten de inneholder flyttall eller heltall (men ikke på strenger som er noe annet enn tall)\n",
+ "- `float(5)` gir 5.0\n",
+ "\n",
+ "**`str()`** - konverterer til tekststreng\n",
+ "- `str(42)` gir '42'\n",
+ "- `str(5.69)` gir '5.69'\n",
+ "Koden under feiler fordi vi har glemt å konvertere. Kjør den og se hva som skjer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "alder = '13'\n",
+ "alder_mor = '37'\n",
+ "sum_alder = alder + alder_mor\n",
+ "\n",
+ "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n",
+ "\n",
+ "sum_alder = int(alder) + int(alder_mor)\n",
+ "\n",
+ "print('Gratulerer, til sammen er dere ' + sum_alder + ' år!')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Den første feilen viser seg i linjen \"Gratulerer...\" Summen skulle ha blitt 50 år. Men vi har de to alderne fortsatt bare lagret som tekststrenger. Da betyr `+` å hekte sammen strengene, ikke å gjøre noen addisjon. Altså får vi `'13' + '37'` som blir `'1337'` heller enn `13 + 37` som blir `50`. Her måtte vi ha konvertert fra tekst til tall før vi gjorde addisjonen.\n",
+ "\n",
+ "Den andre feilen oppstår i den siste print-setningen. Vi har på linjen over kalkulert rett alder, ved å konvertere `alder` og `alder_mor` til `int`. Problemet nå ligger i at vi prøver å legge sammen en `string` og en `int`. Som feilmeldingen sier; \"can only concatenate str (not \"int\") to str\". En mulig løsning er å konvertere `sum_alder` tilbake til `string` nå, slik av vi kan plusse sammen to strenger, eller bruke f-strings. Mulige løsninger vises under:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "alder = '13'\n",
+ "alder_mor = '37'\n",
+ "sum_alder = alder + alder_mor\n",
+ "\n",
+ "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n",
+ "\n",
+ "sum_alder = int(alder) + int(alder_mor)\n",
+ "\n",
+ "print('Gratulerer, til sammen er dere ' + str(sum_alder) + ' år!')\n",
+ "print(f'Gratulerer, til sammen er dere {sum_alder} år!')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Altså: bruker `int()` i linje 7, dette gjør at vi får heltall i variablene `alder` og `alder_mor` så vi blir i stand til å regne med dem. Bruker deretter `str()` i linje 9 så denne opplysningen kan settes sammen med annen tekst og brukes i `print()`. Dette eksemplet viser dermed både et tilfelle hvor vi har tekst men trenger tall, og ett hvor vi har et tall men trenger tekst. Hvis det er vi trenger et desimaltall på alder (f.eks. `13.5`) vil imidlertid koden over ikke funke. Da måtte vi ha brukt funksjonen `float()` der vi nå har brukt `int()`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "I koden under er det noe feil. Finn feilene og rett opp i de"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Rett utskrift skal være:\n",
+ "\n",
+ "```python\n",
+ "25\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:24:13.550825Z",
+ "start_time": "2019-07-01T11:24:13.542723Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def legg_sammen_to_tall(a, b):\n",
+ " return str(a) + str(b)\n",
+ "\n",
+ "legg_sammen_to_tall(10, 15)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `legg_til_landskode(telefonnummer, landskode)` som tar inn `telefonnummer` (`int`) og `landskode` (`int`) som parametere og returnerer telefonnummetet prefixet med \"+\", landskode og et mellomrom.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken udner***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har gjort alt rett, skal kodeblokken under gi ut:\n",
+ "\n",
+ "```python\n",
+ "+47 12345678\n",
+ "+46 87654321\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "telefonnummer1 = 12345678\n",
+ "landskode1 = 47\n",
+ "\n",
+ "telefonnummer2 = 87654321\n",
+ "landskode2 = 46\n",
+ "\n",
+ "print(legg_til_landskode(telefonnummer1, landskode1))\n",
+ "print(legg_til_landskode(telefonnummer2, landskode2))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Kodeblokken nedenfor innheholder noen variabler. Konverter alle til `int`. **Merk**: Det lurer seg kanskje noen feil i koden!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = '1'\n",
+ "b = True\n",
+ "c = False\n",
+ "d = '1.5'\n",
+ "e = '2,45'\n",
+ "\n",
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har gjort alt rett, skal kodeblokken under skrive ut:\n",
+ "\n",
+ "```python\n",
+ "a er nå 1\n",
+ "b er nå 1\n",
+ "c er nå 0\n",
+ "d er nå 1\n",
+ "e er nå 2\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f'a er nå {a}')\n",
+ "print(f'b er nå {b}')\n",
+ "print(f'c er nå {c}')\n",
+ "print(f'd er nå {d}')\n",
+ "print(f'e er nå {e}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Lag en funksjon `mult_list_with_x(l, x)` som tar inn en liste `l` og skalar `x` som parametere og returnerer en _liste_ hvor alle elementene er multiplisert med `x`.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken nedenfor***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis funksjonen din er skrevet rett, skal kodeblokken nedenfor gi output:\n",
+ "\n",
+ "```python\n",
+ "[2.0, 3.0, 4.0, 5.0, 6.0]\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "liste = [1, 1.5, 2, 2.5, 3]\n",
+ "skalar = 2\n",
+ "\n",
+ "mult_list_with_x(liste, skalar)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Her må du bruke **numpy** og `np.array()`. For å gjøre om fra et array til en liste kan du bruke `list()`. Husk også å importere **numpy** med `import numpy as np`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 2: avrunding av flyttall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ofte har man flyttall, men trenger heltall, f.eks. hvis man skal bruke innebygde Python-funksjoner som krever heltall som argument, eller skal bruke tallet som indeks til en streng eller liste (som vi vil se senere i pensum). Flyttall kan konverteres til heltall med funksjoner som `int()` eller `round()`. Kodeblokka under viser litt forskjell på hvordan disse virker."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"int() bare kutter desimalene, uansett hvor stor eller liten desimaldelen er:\")\n",
+ "print(\"int(2.25) er\", int(2.25))\n",
+ "print(\"int(2.5) er\", int(2.5))\n",
+ "print(\"int(2.99) er\", int(2.99))\n",
+ "print(\"round() runder av til nærmeste heltall, f.eks.\")\n",
+ "print(\"round(2.25) er\", round(2.25))\n",
+ "print(\"round(2.51) er\", round(2.51))\n",
+ "print(\"Hva hvis tallet er midt mellom to heltall?\")\n",
+ "print(\"round(2.5) er\", round(2.5))\n",
+ "print(\"round(3.5) er\", round(3.5))\n",
+ "print(\"round() bruker en IEEE standard som velger partallet for midt-imellom-situasjoner.\")\n",
+ "print(\"Mens int() alltid gir heltall kan round() brukes for antall desimaler:\")\n",
+ "print(\"round(2.5488, 1) blir\", round(2.5488, 1))\n",
+ "print(\"round(2.5488, 3) blir\", round(2.5488, 3))\n",
+ "print(\"Med negativt antall desimaler kan vi få round() til å runde større enn heltall:\")\n",
+ "print(\"round(12345.67, -3) blir\", round(12345.67, -3))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser i eksemplet, blir 2.5 rundet av til 2 mens 3.5 blir rundet til 4. Dette kan virke litt uvant, i dagliglivet er man mest kjent med såkalt \"kjøpmannsavrunding\", hvor det alltid rundes opp hvis man er midt mellom (dvs., 2.5 skulle i så fall ha blitt rundet til 3). Konsekvent runding oppover når man er midt mellom har imidlertid en uheldig side, nemlig at man pådrar seg en systematisk feil hvis man har mange data som avrundes. Tenk f.eks. temperaturmålinger for lange perioder, hvor man deretter skal regne ut et snitt for hele perioden. Hvis alle temperaturer som er midt når det gjelder siste brukte siffer, rundes opp, vil snittet for perioden alltid bli litt for høyt. Hvis man i stedet går i partallsretning i alle slike midt mellom situasjoner, vil man runde opp cirka halvparten av gangene og ned cirka halvparten av gangene og dermed unngå slike systematiske feil. Men for kjøpmannen er systematisk runding oppover selvsagt bedre med tanke på å få inn mest mulig penger."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "I tillegg til `int()` og `round()` kan f-strenger \"innebygd\" runde av flyttall:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f'1.2345 avrundet til 2 desimaler er: {1.2345:.2f}')\n",
+ "print(f'5.4321 avrundet til 0 desimaler er: {5.4321:.0f}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Det som skjer her inne i krøllparentesene her er; `1.2345` er tallet vi ønsker runde av, `:` sier \"rund av det som står til venstre til det som står til høyre\", `.2` sier \"gi meg 2 desimaler\" og `f` sier at typen skal være `float`. Det som er verdt å merke seg er at denne måten å runde av tall på gir deg ikke muligheten til å bruke tallet videre. Tallet er da inkorporert i strengen. Med `round()` og `int()` kan vi bruke det avrundede tallet videre."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## e)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `rund_av(tall, desimaler)` som tar inn et tall `tall` som skal avrundes og `desimaler` antall desimaler tallet skal avrundes til som parametere og returnerer det avrundede tallet.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis funksjonen din er skrevet rett, skal kodeblokken under gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "1.23\n",
+ "1000.0\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(rund_av(1.23456, 2))\n",
+ "print(rund_av(1234.5432, -3))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## f) (frivillig og vanskelig)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du trenger **ikke** gjøre denne oppgaven for å få øvingen godkjent\n",
+ "\n",
+ "Lag en funksjon `negativt_eller_positivt(tall)` som tar inn et `tall` og returnerer `-1` om tallet er negativt, `0` hvis tallet er `0` eller `0.0` og `1` hvis tallet er positivt, _uten_ å bruke `if`-setninger.\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvis du har skrevet funksjonen rett, skal kodeblokken under gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "-1\n",
+ "0\n",
+ "0\n",
+ "1\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(negativt_eller_positivt(-100))\n",
+ "print(negativt_eller_positivt(0))\n",
+ "print(negativt_eller_positivt(0.0))\n",
+ "print(negativt_eller_positivt(100))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "**Hint 1:** `bool(int)` gir `True` om tallet som gis inn er forskjellig fra `0`, og `False` om tallet er `0`. \n",
+ "\n",
+ "**Hint 2:** Husk at vi kan gjøre aritmetiske operasjoner med booleans. F.eks kan man tenke seg at `True = 1`, slik at `True + 1` gir `2`, og `False * x` gir `0`. \n",
+ "\n",
+ "**Hint 3:** `abs(int)` gir absoluttverdien til et tall. F.eks blir `abs(-100)` lik `100`"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Tetraeder.ipynb b/Ovinger/Oving1/Tetraeder.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..df1d2731fed97920166aa82a3adfafed0c8285a0
--- /dev/null
+++ b/Ovinger/Oving1/Tetraeder.ipynb
@@ -0,0 +1,275 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li class = \"active\"><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Tetraeder \n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Funksjoner\n",
+ "* Aritmetiske operasjoner\n",
+ "\n",
+ "\n",
+ "\n",
+ "<br><br>I denne oppgaven skal du finne overflateareal og volum til regulære tetraedere (også kjent som trekantede pyramider). Et regulært tetraeder er et geometrisk objekt bestående av fire likesidede trekanter.\n",
+ "\n",
+ "* **Overflatearealet til et tetraeder er A=$\\sqrt{3}a^{2}$** \n",
+ "* **Volumet til et tetraeder er V=$\\frac{\\sqrt{2}a^{3}}{12}$ hvor a=$\\frac{3}{\\sqrt{6}}h$** "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv funksjonen `areal(h)` som beregner overflatearealet til et tetraeder, basert på høyden `h` til tetraederet. Test at programmet skriver ut 23.383 som resultat når høyden, h, er 3 (det gjør ikke noe om svaret får flere siffer).\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Har du skrevet funksjonen rett, vil kodeblokken under gi følgende output:\n",
+ " \n",
+ "```python\n",
+ "Et tetraeder med høyde 3 har areal 23.383\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "h = 3\n",
+ "A = areal(h)\n",
+ "\n",
+ "print(f'Et tetraeder med høyde {h} har areal {A}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kvadratrot kan regnes ut enten ved å opphøye et tall i 1/2, f.eks. `x ** 0.5`, eller ved `numpy as np` og `np.sqrt` for å regne ut røttene. Det kan være lurt å lagre verdiene i variabler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag nå en funksjon `volum(h)` som kalkulerer volumet til et tetraeder. Test at programmet skriver 5.846 når høyden (h) er 3 (det gjør ikke noe om svaret får flere siffer). Du kan skrive i samme kodeblokk som i oppgave **a)**.\n",
+ "\n",
+ "Kjør kodeblokken under for å teste at funksjonen din gir rett output:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Et tetraeder med høyde 3 har volum 5.846\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "h = 3\n",
+ "V = volum(h)\n",
+ "\n",
+ "print(f'Et tetraeder med høyde {h} har volum {volum(h)}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "La du merke til at du i oppgave **a)** og **b)** måtte skrive samme kode for å finne verdien til `a`? Dette er en fin kode vi kan abstrahere ut av funksjonen.\n",
+ "\n",
+ "Lag funksjonen `calculate_a(h)`, som tar inn høyden `h` til et tetraeder, og kalkulerer $a = \\frac{3}{\\sqrt{6}}h$. Endre så funksjonene `areal` og `volum` til å bruke denne nye funksjonen. Du kan skrive den nye koden og endre funksjonene i samme boks som i oppgave **a)** og **b)**.\n",
+ "\n",
+ "Sjekk at funksjonene dine fortsatt fungerer med kodeblokken under. Hvis alt er gjort rett skal output bli:\n",
+ "\n",
+ "```python\n",
+ "Et tetraeder med høyde 3 har areal 23.382\n",
+ "Et tetraeder med høyde 3 har volum 5.845\n",
+ "```\n",
+ "\n",
+ "Det gjør ingenting om output har flere desimaler."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "h = 3\n",
+ "A = areal(h)\n",
+ "V = volum(h)\n",
+ "\n",
+ "print(f'Et tetraeder med høyde {h} har areal {A}')\n",
+ "print(f'Et tetraeder med høyde {h} har volum {volum(h)}')"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Variable.ipynb b/Ovinger/Oving1/Variable.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..be2e5108d6215d1c36738fb63250ec677c68abb7
--- /dev/null
+++ b/Ovinger/Oving1/Variable.ipynb
@@ -0,0 +1,581 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li class=\"active\"><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "\n",
+ "\n",
+ "# Variable\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Enkel bruk av variable\n",
+ "\n",
+ "* Korrekt navngivning av variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 1: variable - grunnleggende intro"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvorfor trenger vi variable? Poenget med variable er å **huske data underveis** i utførelsen av et program.\n",
+ "\n",
+ "Variable er derfor et sentralt konsept i programmering, ikke bare i Python men uansett hva slags språk man programmerer i.\n",
+ "\n",
+ "Uten variable støter vi fort på en rekke problemer fordi programmet vårt ikke kan huske noe, f.eks. at\n",
+ "\n",
+ "* vi må be brukeren gi inn opplysninger på nytt som brukeren har gitt tidligere\n",
+ "* vi må regne ut på nytt data vi allerede har regnet ut tidligere\n",
+ "\n",
+ "Dette sløser tid og strøm og vil i mange tilfeller gjøre programmet fullstendig ubrukelig.\n",
+ "\n",
+ "I det lille eksempelprogrammet under, klarer vi oss uten noen variabel, fordi navnet som skrives utkun blir benyttet én gang.\n",
+ "\n",
+ " \n",
+ "```python \n",
+ "print('Pi, med seks desimaler er 3.141592') \n",
+ "```\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Pi, med seks desimaler er 3.141592\n",
+ ">>>>\n",
+ "```\n",
+ "\n",
+ "Men ofte skal samme data brukes flere ganger, og etter at vi har gjort andre ting i mellomtiden. Da må data huskes i variable. Anta at vi ønsker en bare litt mer avansert dialog.\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Pi, med seks desimaler er 3.141592 \n",
+ "3.141592 er pi, avrundet til seks desimaler.\n",
+ ">>>>\n",
+ "```\n",
+ "\n",
+ "Her vil vi bruke verdien til pi i to påfølgende print-setninger. Hvis vi prøver samme triks som tidligere med å sette tallet direkte i print-setning, får vi koden:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "print('Pi, med seks desimaler er 3.141592')\n",
+ "print('3.141592 er pi, avrundet til seks desimaler.') \n",
+ "```\n",
+ "\n",
+ "\n",
+ "```\n",
+ "Pi, med seks desimaler er 3.141592\n",
+ "3.141592 er Pi, avrundet til seks desimaler.\n",
+ "```\n",
+ "\n",
+ "Ikke noe katastrofalt problem her, men tenk deg et program hvor samme opplysning skal brukes 100 ganger eller mer i en kritisk arbeidsoppgave som haster. Da kan det bli tungvindt å for eksempel skrive 3.141592 100 ganger.\n",
+ "\n",
+ "Kan vi løse det på en bedre måte? JA - med en variabel for å huske navnet. Koden blir da"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "pi = 3.141592\n",
+ "print(f'Pi, med seks desimaler er {pi}')\n",
+ "print(f'{pi} er pi, avrundet til seks desimaler')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dette programmet kan forklares som følger:\n",
+ "\n",
+ "* linje 1, til høyre for `=` : verdien vi ønsker å lagre (3.141592)\n",
+ "* linje 1, til venstre for `=`: oppretter en variabel som heter `pi`.\n",
+ "* linje 1, tegnet `=`. Dette er **tilordningsoperatoren**. Betyr at verdien av uttrykket på høyre side, verdien 3.141592, blir husket i variabelen kalt `pi`.\n",
+ "* linje 2, variabelen `pi` brukes sist i f-strengen i print-setningen. Merk at variabelnavnet **ikke** skal ha fnutter rundt seg. Med fnuttter ville ikke akkurat dette programmet kjørt. Ordet pi som står som det tredje ordet i setningen \"{pi} er pi, avrundet til seks desimaler\" er ikke variabelen, her er ordet navn bare del av en tekststreng.\n",
+ "* linje 3, variabelen `pi` brukes fremst i print-setningen. Igjen uten fnutter; det er ikke ordet pi vi ønsker å skrive, men den verdien som variabelen `pi` inneholder (f.eks. 3.141592)\n",
+ "\n",
+ "Ved hjelp av variabelen som her ble kalt pi, unngår vi å måtte skrive ut verdien to ganger. Vi skriver den bare én gang, i starten av programmet, og husker da opplysningen ved å putte den inn i en variabel.\n",
+ "\n",
+ "Videre i programmet kan vi benytte denne variabelen hver gang vi trenger verdien - enten det som her var bare to ganger, eller om det hadde vært flere.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "### Rask intro til f-strenger"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "F-strenger, som brukt i print-setningenge ovenfor, er lett å gjenkjenne ved at strengen starter med en \"f\" før fnuttene. F-en står for \"format\". F-strings gjør det veldig lett for oss å formatere strengene våre. Som du ser i eksempelet over inneholder strengen noen krøllparenteser (`{}`). Innimellom disse krøllparentesene er vi ikke lenger inne i strengen, og at vi skriver inne i disse er \"vanlig\" Python kode. I eksempelet over settes variabelen `pi` inn i disse krøllparentesene. Dette gjøres slik at verdien variabelen `pi` inneholder kan bli satt inn i strengen. Som sagt er det \"vanlig\" Python kode som skrives inne i disse krøllparentesene. Vi kan for eksempel gjøre matteoperasjoner i de:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(f'1 + 1 = {1 + 1}')\n",
+ "print(f'2 * 2 = {2 * 5}') # Her er det noe feil. Kan du fikse opp?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a) Huske verdier i variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kjør koden under for å se hvordan den virker. Som du vil se, skriver den ut \"Ada\" to ganger, og \"ITGK\" to ganger.\n",
+ "\n",
+ "Forbedre koden ved å introdusere en variabel for navn og en annen variabel for favorittfag, slik at vi slipper å skrive \"Ada\" og \"ITGK\" mer enn én gang.\n",
+ "\n",
+ "Hvis du er i tvil om hvordan du skal angripe problemet, se lignende eksempel i tutorial like over."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print('Hei, Ada')\n",
+ "print('ITGK - interessant!')\n",
+ "print('Ha en fin dag, Ada')\n",
+ "print('- og lykke til med ITGK')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du får til å bruke de to variablene som tenkt, skal kjøringen av det forbedrede programmet se slik ut (men også funke om brukeren skriver inn noe annet enn Ada på spørsmålet Navn? og noe annet enn ITGK på Favorittfag?)\n",
+ "\n",
+ "```\n",
+ "Navn? Ada \n",
+ "Hei, Ada \n",
+ "Favorittfag? ITGK \n",
+ "ITGK - interessant! \n",
+ "Ha en fin dag, Ada \n",
+ "- og lykke til med ITGK\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 2 - bruk av variable i beregninger"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Variable brukes ikke bare i sammenheng med `input()`, men i alle mulige slags program. I matematiske beregninger skal resultatet av en beregning ofte brukes videre i nye beregninger. Da må disse tallene huskes i variable. \n",
+ "Koden under viser samme eksempel gjort på to måter, nemlig utregning av areal for en sirkel, samt volum for en sylinder som har denne sirkelen som grunnflate. Versjon 1 er gjort uten variable, mens Versjon 2 bruker variable.\n",
+ "\n",
+ "**Sirkel og sylinder**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import math\n",
+ " \n",
+ "# VERSJON 1, uten variable\n",
+ "print(\"Areal av sirkelen:\", math.pi * 5.4**2)\n",
+ "print(\"Volum av sylinderen:\", math.pi * 5.4**2 * 7.9)\n",
+ " \n",
+ "print()\n",
+ " \n",
+ "# VERSJON 2, med variable\n",
+ "r = 5.4 # radius for en sirkel\n",
+ "A_sirkel = math.pi * r**2\n",
+ "print(\"Areal av sirkelen:\", A_sirkel)\n",
+ "h = 7.9 # høyde sylinder hvor sirkelen er grunnflate\n",
+ "V_syl = A_sirkel * h\n",
+ "print(\"Volum av sylinderen:\", V_syl)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du kjører koden, vil du se at begge gir samme resultat. Hva er da forskjellen?\n",
+ "\n",
+ "* Versjon 2 er vesentlig lenger (6 kodelinjer, mot bare 2) fordi det brukes ekstra linjer på variable. Lenger kode er en mulig ulempe. MEN:\n",
+ "* Formlene i Versjon 2 er lettere å forstå fordi det er intuitive navn som `r`, `h`, `A_sirkel` heller enn bare tall direkte.\n",
+ "* Koden i V2 er mer fleksibel for å kjapt endre verdier. Hvis radius skal byttes fra 5.4 til 6.2 må dette tallet bare endres ett sted i V2, mens flere i V1.\n",
+ "* Versjon 1 utfører **5 operasjoner** av type `*` og `**`, mens Versjon 2 bare utfører ***3***. Dette fordi Versjon 2 husker arealet i A_sirkel og deretter kan bruke dette, mens Versjon 1 må regne ut `math.pi * 5.4**2` på nytt.\n",
+ "**Med færre multiplikasjoner vil VERSJON 2 spare både strøm og tid i forhold til VERSJON 1, dvs. koden utfører mindre jobb og går raskere selv om det er flere kodelinjer.**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b) Bruke variable i beregninger "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Nedenfor står et program hvor vi regner ut omkrets og areal for en sirkel etter de velkjente formlene $O=2\\pi{r}$ og $A = \\pi r^2$. Bortsett fra **numpy** konstanten `np.pi` og den innebygde konstanten `math.tau` (=2π) bruker vi ingen variable. Dette gjør at når vi skal regne ut arealet av en sylinder hvor sirkelen er grunnflate, må vi gjøre om igjen flere beregninger som vi allerede har gjort tidligere.\n",
+ "\n",
+ "Arealet av sylinderen med høyde h vil være `Omkrets_sirkel * h + 2 * Areal_sirkel`, hvor det første leddet er arealet av sylinderveggen og det siste leddet er topp- og bunnlokket.\n",
+ "\n",
+ "***Oppgave: Endre koden ved å tilordne og deretter bruke variable for radiusen, høyden, sirkelens omkrets og areal, slik at programmet unngår å gjøre på nytt beregninger som allerede er gjort før.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T10:54:16.358742Z",
+ "start_time": "2019-07-01T10:54:16.351684Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import math\n",
+ " \n",
+ "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
+ "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
+ "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
+ "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Resultatet av kjøring av koden skal være uendret, dvs utskrift skal bli som vist nedenfor (men hvis du vil, kan du gjerne i tillegg avrunde svarene til én desimal).\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n",
+ "Omkrets av sirkelen: 33.929200658769766\n",
+ "Areal av sirkelen: 91.60884177867838\n",
+ "Areal av sylinderen: 451.25836876163794\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 3: Navngiving av variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "En variabel er et navn som representerer en verdi som lagres i datamaskinens minne. Den vanligste måten å opprette en variabel på er ved en tilordningssetning:\n",
+ "\n",
+ "`variable = expression`\n",
+ "\n",
+ "I dette tilfellet er variable navnet til variabelen, mens expression er verdien. Noen regler for slike tilordningssetninger:\n",
+ "\n",
+ "* variabelen som opprettes skal alltid stå på venstre side av uttrykket, og venstre side skal kun inneholde denne variabelen, ikke noe annet\n",
+ "* høyde side kan alt fra en enkelt verdi (f.eks. et tall) eller en enkelt variabel, til mer sammensatte uttrykk som må beregnes. Hvis høyre side inneholder variable, må dette være variable som allerede er opprettet tidligere i koden.\n",
+ "* variabelnavnet må tilfredsstille følgende regler:\n",
+ " * ord som er reserverte ord i Python, f.eks. `if`, `def`, eller som er navn på standardfunksjoner som `print`, `min`, `max`, ... bør unngås som varibelnavn\n",
+ " * variabelnavn må begynne med en bokstav eller tegnet _ (understrek)\n",
+ " * kan ellers inneholde bokstaver, tall og understrek, dvs. kan f.eks. ikke inneholde blanke tegn.\n",
+ "* Python skiller mellom små og store bokstaver, så `Areal` og `areal` vil være to ulike variable.\n",
+ "\n",
+ "Det anbefales å lage variabelnavn som er intuitivt forståelige, f.eks. er `areal` et bedre navn enn `x` på en variabel som inneholder et areal. Sammensatte variabelnavn skrives typisk som pukkelord (eng.: camelCase) eller med understrek for å vise hvor ett ord slutter og det neste begynner, f.eks. `startTime`, `pricePerLiter` eller `start_time`, `price_per_liter`, siden direkte sammensetning uten noe som helst skille vil gi lange variabelnavn som blir vanskelige å lese.\n",
+ "\n",
+ "Kodeblokka under viser eksempler på variable som funker og ikke funker:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Eksempel på tilordningssetninger som funker\n",
+ "pokemon_name = \"Tyranitar\"\n",
+ "MaxCP = 3670\n",
+ "antall = 3\n",
+ "antall = antall + 1 # høyre side regnes ut som 3+1, så 4 blir ny verdi i variabelen antall\n",
+ "resists_fighting = False\n",
+ "level42 = \"to be done\" # tall er OK i variabelnavn unntatt helt fremst\n",
+ " \n",
+ "# Eksempel på tilordninger som IKKE funker\n",
+ "1 = antall # variabelen må stå på venstre side\n",
+ "antall + 1 = antall # og v.s. kan KUN inneholde et variabelnavn, ikke et større uttrykk\n",
+ "10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\n",
+ "antall = 3 # denne er OK, men se neste linje\n",
+ "antall = Antall + 1 # Python skiller mellom store og små bokstaver, Antall vil være en annen\n",
+ " # variabel og gir NameError her fordi den ikke er opprettet i en tidligere setning\n",
+ "happy hour = 20 # navn kan ikke inneholde mellomrom, burde vært happy_hour eller happyHour\n",
+ "alkohol% = 4.5 # % kan ikke brukes i variabelnavn (betyr modulo). Samme gjelder andre spesialtegn,\n",
+ " # hold deg til vanlige bokstaver og tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c) Variabelnavn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Prøv å kjør koden under. Som du vil se, funker den ikke pga. diverse feil med variabelnavn og tilordningssetninger. Fiks feilene så programmet kjører som det skal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "4navn = \"Per\"\n",
+ "ideal alder = 42\n",
+ "37 = kundensAlder\n",
+ "differanse = ideal alder - kundensAlder\n",
+ "print(f'{4navn} er {Differanse} år unna idealalderen')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d) Variabel-program"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program i kodeblokka under som først lagrer navnet ditt i en variabel og alderen din i en annen variabel, for så å printe det ut med `print()`-funksjonen.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```\n",
+ "Jeg heter Bob Bernt, og er 46 år.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/Vitenskapelig notasjon.ipynb b/Ovinger/Oving1/Vitenskapelig notasjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..06ee60eaf21a02a41daa1a827ad645915f8b97d0
--- /dev/null
+++ b/Ovinger/Oving1/Vitenskapelig notasjon.ipynb
@@ -0,0 +1,318 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20kalkulasjoner.ipynb\">Funksjoner og kalkulasjoner</a></li>\n",
+ " <li><a href=\"Plotting.ipynb\">Plotting</a></li>\n",
+ " <li><a href=\"Tall-%20og%20Typekonvertering.ipynb\">Tall- og Typekonvertering</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Variable.ipynb\">Variable</a></li>\n",
+ " <li><a href=\"Priser%20med%20og%20uten%20moms.ipynb\">Priser med og uten moms</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20subtraksjon.ipynb\">Avrundingsfeil - subtraksjon</a></li>\n",
+ " <li><a href=\"Avrundingsfeil%20-%20summering.ipynb\">Avrundingsfeil - summering</a></li>\n",
+ " <li class = \"active\"><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Vitenskapelig notasjon\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Vitenskapelig notasjon for spesielt små og spesielt store flyttall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Nyttig info om formatering av store (og små) tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Når vi skriver flyttall i Python, er det enkleste ofte å skrive tallet rett frem, for eksempel 9.80665 eller 0.0002. Hvis tallet blir veldig stort (~$10^{6}$) eller lite (~$10^{-6}$), er det derimot tidkrevende å skrive tallet fullt ut, samtidig som at det lett dukker opp slurvefeil. Da vil resultatet av en beregning bli helt feil. Derfor er det vanlig å bruke vitenskapelig notasjon for store og små tall.\n",
+ "\n",
+ "I Python kan vi skrive tallene 3.0 × 10 $^{9}$ og 3.19 × 10$^{-10}$ ved bruk av multiplikasjon(`*`) og potensregning(`**`) slik: `3.0*10**9` og `3.19*10 **(-10)`. Det vil gi riktig resultat, men kaster bort tid og strøm på å gjøre helt unyttige beregninger, først en potensering, så en multiplikasjon, for å finne fram til et tall vi egentlig allerede vet hva er. Det er derfor bedre å bruke notasjonen `3.0e9` og `3.19e-10`, hvor tallet bak `e` viser tierpotensen for å uttrykke store og små tall. \n",
+ "\n",
+ "Notasjonen med `e` (som her ikke har noe med konstanten e å gjøre) lar oss legge tallet rett inn i variabelen uten noe regning. Eksemplet under viser bruk av denne notasjonen i linje 3.\n",
+ "\n",
+ "Eksempel på kode (**Prøv å kjør koden!**)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T12:28:51.461020Z",
+ "start_time": "2019-07-01T12:28:46.220125Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "tid_60m = 20\n",
+ "m_sek = 60/tid\n",
+ "lysfart = 3.0e8\n",
+ "x = lysfart / m_sek\n",
+ "print('Bra! Men for å nå igjen lyset...')\n",
+ "print(f'...må du løpe {x} ganger fortere')\n",
+ "print(f'som også kan skrives {format(x, \".1e\")} ganger fortere.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "`.1e` i format viser at det er ønskelig med én desimal i den vitenskapelige notasjonen. `.2e` ville gitt `1.00e+08`. I tillegg til å bruke `format()`-funksjonen, kan f-strings \"innebygd\" formatere strenger:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "lysfart = 3.0e8\n",
+ "x = 1/lysfart\n",
+ "print(f'Uten formatering er x = {x}')\n",
+ "print(f'Med formaterting er x = {x:.3e}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Hvor `x:` sier \"la oss formatere stringen `x`\", og `.3e` sier at vi skal ha tre desimaler og vitenskapelig notasjon, slik som i eksempelet over."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Plancks konstant, $6.626*10^{-34} J/s$, karakteriserer et _kvant_, den minste enheten av energi. Einstein viste, ved hjelp av Plancks konstant, at et _foton_ med frekvens $\\nu$ har energi $E = h\\nu$, hvor $h$ er _Plancks konstant_.\n",
+ "\n",
+ "I denne oppgaven skal du lage en funksjon `E(v)` som tar inn en frekvens $\\nu$ og gir ut energien til fotonet. Bruk vitenskapelig notasjon for Plancks konstant.\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Har du skrevet funksjonen rett, skal kodeblokken under gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "Rødt lys, som har frekvens 4.29e+14Hz, har en energi på 2.84e-19J\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "v = 4.29e+14\n",
+ "print(f'Rødt lys, som har frekvens {v:.2e}Hz, har en energi på {E(v):.2e}J')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Avogadros konstant 6.022 × 10<sup>23</sup> sier hvor mange molekyler av et stoff som fins i ett mol av stoffet. Lag en funksjon `molekyler_av_stoff(g, molvekt)` som bruker Avogadros konstant for å finne antall molekyler av et stoff, gitt antall `gram` man har av stoffet og `molvekt`en til stoffet.\n",
+ " \n",
+ "***Skriv koden din i kodeblokken under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Skriv koden din her"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Har du skrevet funksjonen rett, vil kodeblokken under gi følgende output:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Du har 1.7e+25 mokelyker vann\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "stoff = \"vann\"\n",
+ "g = 500\n",
+ "molvekt = 18\n",
+ "\n",
+ "molekyler = molekyler_av_stoff(g, molvekt)\n",
+ "\n",
+ "print(f'Du har {molekyler:.1e} mokelyker {stoff}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Regn først ut antall mol ved å ta hvor mye stoff du har i antall gram og dele på molvekten. Deretter multipliserer du antall mol med avogadros tall."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Ovinger/Oving1/_Oving1.ipynb b/Ovinger/Oving1/_Oving1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..aac02b37a3bc0f6bf7ab89b04752bf0295eaefd4
--- /dev/null
+++ b/Ovinger/Oving1/_Oving1.ipynb
@@ -0,0 +1,91 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Øving 1\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Kunne bruke vanlige regneoperatorer i Python: addisjon + , subtraksjon – , multiplikasjon * , divisjon / , heltallsdivisjon '// , modulo % og potens **\n",
+ "* Forstå forskjellen på de fire elementære datatypene: heltall (int), flyttall (float), tekststrenger (str) og sannhetsverdier (boolean)\n",
+ "* Skjønne hvordan regneoperatorene virker for de ulike datatypene\n",
+ "* Kunne bruke vitenskapelig notasjon for spesielt små og spesielt store flyttall\n",
+ "* Forstå at kode må være uten feil for å kjøre, og kunne rette enkle syntaksfeil\n",
+ "* Forstå hvorfor og hvordan vi bruker variable i programmering, og at variabeltilordning ikke er det samme som matematisk likhet\n",
+ "* Kunne skrive ut til skjerm og lese inn data fra brukeren via tastaturet med standardfunksjonene print() og input()\n",
+ "* Kunne utføre enkel konvertering mellom datatyper med standardfunksjoner som int() og float()\n",
+ "\n",
+ "**Starting Out with Python**\n",
+ "\n",
+ "* Kap. 2: Input, Processing, and Output\n",
+ "\n",
+ "\n",
+ " \n",
+ "\n",
+ "## Godkjenning:\n",
+ "\n",
+ "For å få godkjent øvingen må du gjøre [Intro til Jupyter](Intro%20til%20jupyter.ipynb) oppgaven, [Funksjoner og kalkulasjoner](Kalkulasjoner.ipynb) oppgaven, [Plotting](Plotting.ipynb) oppgaven og ***2*** av ***8*** andre oppgaver. \n",
+ "\n",
+ "Oppgaver som er litt ekstra vanskelig er markert med stjerne. Oppgaver som går forbi det som er blitt forelest er markert med to stjerner.\n",
+ "\n",
+ "Alle oppgavene skal demonstreres til en læringsassistent på sal. I oppgaver der du skriver programkode skal også denne vises fram. Lykke til!\n",
+ "\n",
+ "\n",
+ "Oppgave | Tema | Vanskelighetsgrad\n",
+ "--- | --- | ---\n",
+ "[Intro til Jupyter](Intro%20til%20jupyter.ipynb) | Jupyter notebooks | \n",
+ "[Funksjoner og kalkulasjoner](Funksjoner%20og%20kalkulasjoner.ipynb)|Funksjoner og matteoperasjoner|\n",
+ "[Plotting](Plotting.ipynb) | Plotting |\n",
+ "[Tall- og Typekonvertering](Tall-%20og%20Typekonvertering.ipynb)| Konvertering |\n",
+ "[Geometri](Geometri.ipynb)| Matematiske funksjoner |\n",
+ "[Variable](Variable.ipynb)|Variabler|\n",
+ "[Priser med og uten moms](Priser%20med%20og%20uten%20moms.ipynb)|Matteoperasjoner|\n",
+ "[Avrundingsfeil - subtaksjon](Avrundingsfeil%20-%20subtraksjon.ipynb)Â | Flyttallrepresenatsjon | \n",
+ "[Avrundingsfeil - summering](Avrundingsfeil%20-%20summering.ipynb)Â | Flyttallrepresenatsjon | \n",
+ "[Vitenskapelig notasjon](Vitenskapelig%20notasjon.ipynb)|Konvertering|\n",
+ "[Tetraeder](Tetraeder.ipynb)| Matematiske funksjoner |"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "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/Resources/Images/Innebygde_strengfunksjoner.png b/Resources/Images/Innebygde_strengfunksjoner.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea54af38ecdd4f19b4c54de433b77eb72362c88e
Binary files /dev/null and b/Resources/Images/Innebygde_strengfunksjoner.png differ
diff --git a/Resources/Images/Set-eksempel.png b/Resources/Images/Set-eksempel.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba4c9106c311df2330678abaa40829dbd1f3987a
Binary files /dev/null and b/Resources/Images/Set-eksempel.png differ
diff --git a/Resources/Images/Tetrahedron.jpg b/Resources/Images/Tetrahedron.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e7a6084a4a5e320fb9e198a7f648d08a38dd227b
Binary files /dev/null and b/Resources/Images/Tetrahedron.jpg differ
diff --git a/Resources/Images/chessboard.png b/Resources/Images/chessboard.png
new file mode 100644
index 0000000000000000000000000000000000000000..c3597a820e5a0ff0bea8ecc4d3cf94281daeff6b
Binary files /dev/null and b/Resources/Images/chessboard.png differ
diff --git a/Resources/Images/den_store_sporreundersokelsen.png b/Resources/Images/den_store_sporreundersokelsen.png
new file mode 100644
index 0000000000000000000000000000000000000000..38198babe96bd875b89fd24114e4bca894cefdf6
Binary files /dev/null and b/Resources/Images/den_store_sporreundersokelsen.png differ
diff --git a/Resources/Images/dictionary_eksempel.png b/Resources/Images/dictionary_eksempel.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d4a97d03e42f4a01639024f88e1fe4cda225a59
Binary files /dev/null and b/Resources/Images/dictionary_eksempel.png differ
diff --git a/Resources/Images/fixing_problems.webp b/Resources/Images/fixing_problems.webp
new file mode 100644
index 0000000000000000000000000000000000000000..a095b1babebfe7a61ace5e79e325f2b8ca0e35e2
Binary files /dev/null and b/Resources/Images/fixing_problems.webp differ
diff --git a/Resources/Images/flere-innebygde-strengfunksjoner.png b/Resources/Images/flere-innebygde-strengfunksjoner.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b7172b125ee68ca45b82c59c84242d86fcf8503
Binary files /dev/null and b/Resources/Images/flere-innebygde-strengfunksjoner.png differ
diff --git a/Resources/Images/if-setninger.jpg b/Resources/Images/if-setninger.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8fc4ebd4321055c93af00b06874aaf827d0a6a0c
Binary files /dev/null and b/Resources/Images/if-setninger.jpg differ
diff --git a/Resources/Images/indexing.png b/Resources/Images/indexing.png
new file mode 100644
index 0000000000000000000000000000000000000000..004cf50192e75e78995f6ffd5d3c7c9eea37495b
Binary files /dev/null and b/Resources/Images/indexing.png differ
diff --git a/Resources/Images/kjeglevolum.PNG b/Resources/Images/kjeglevolum.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..8254157ddcbefc73a81d04eee413493db96c878f
Binary files /dev/null and b/Resources/Images/kjeglevolum.PNG differ
diff --git a/Resources/Images/kvintsirkelen-m-kryssogb.png b/Resources/Images/kvintsirkelen-m-kryssogb.png
new file mode 100644
index 0000000000000000000000000000000000000000..e8d29444eecf3ca315ea7333e0d3a0f55cafffd2
Binary files /dev/null and b/Resources/Images/kvintsirkelen-m-kryssogb.png differ
diff --git a/Resources/Images/liste-funksjoner.jpg b/Resources/Images/liste-funksjoner.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..221a8a08d1fed0ea9e32286600ef18b0a0ffcd06
Binary files /dev/null and b/Resources/Images/liste-funksjoner.jpg differ
diff --git a/Resources/Images/litt-sjakk.png b/Resources/Images/litt-sjakk.png
new file mode 100644
index 0000000000000000000000000000000000000000..8012a452406427bab744c4512e60614a004f993e
Binary files /dev/null and b/Resources/Images/litt-sjakk.png differ
diff --git a/Resources/Images/o1_geometri.png b/Resources/Images/o1_geometri.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1d9fd00f148c098731a45873d1d72c289cf2310
Binary files /dev/null and b/Resources/Images/o1_geometri.png differ
diff --git a/Resources/Images/o1_plot.png b/Resources/Images/o1_plot.png
new file mode 100644
index 0000000000000000000000000000000000000000..af51a6d32c0aa5a6e37e40f3aef0cf0a0f39cdc9
Binary files /dev/null and b/Resources/Images/o1_plot.png differ
diff --git a/Resources/Images/o1_plotting_deloppgave_c.png b/Resources/Images/o1_plotting_deloppgave_c.png
new file mode 100644
index 0000000000000000000000000000000000000000..6c0fd406d15ef376e053f911ed5f7630caaf281e
Binary files /dev/null and b/Resources/Images/o1_plotting_deloppgave_c.png differ
diff --git a/Resources/Images/regnestykker.jpg b/Resources/Images/regnestykker.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f9909584e1e7612014b89f785fb13559b8127e64
Binary files /dev/null and b/Resources/Images/regnestykker.jpg differ
diff --git a/Resources/Images/star_yellow.svg b/Resources/Images/star_yellow.svg
new file mode 100644
index 0000000000000000000000000000000000000000..6045540dc12a3a3c72cb35dfaa9a41bf37135bef
--- /dev/null
+++ b/Resources/Images/star_yellow.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg"><path d="M8.001 13.408l-3.785 2.433c-.753.484-1.714-.19-1.516-1.063l1.048-4.613L.332 7.091c-.65-.586-.287-1.667.586-1.74l4.436-.372L7.07.632c.334-.843 1.527-.843 1.86 0L10.65 4.98l4.436.372c.873.073 1.236 1.154.585 1.74l-3.415 3.074 1.048 4.613c.198.874-.763 1.547-1.516 1.063l-3.786-2.433z" fill="#FFC400" fill-rule="nonzero"/></svg>
\ No newline at end of file
diff --git a/Resources/Images/streng-eksempel.png b/Resources/Images/streng-eksempel.png
new file mode 100644
index 0000000000000000000000000000000000000000..1b959ed2d01cab6cffa68e05f2fff5fab31316ce
Binary files /dev/null and b/Resources/Images/streng-eksempel.png differ
diff --git a/Resources/Images/sylinder.png b/Resources/Images/sylinder.png
new file mode 100644
index 0000000000000000000000000000000000000000..7daea825d4920402b1b58b20ce15a4932d914300
Binary files /dev/null and b/Resources/Images/sylinder.png differ