9.3 Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse

Hva skriver programmet ut? Skriv utskriften nøyaktig, med mellomrom og linjeskift slik terminalen viser den.

ord_liste = ['tre', 'is', 'sand']
sum_lengde = 0
for i in range(len(ord_liste)):
    for j in range(i+1):
        sum_lengde += len(ord_liste[j])
    print(i, sum_lengde, end='; ')
print()

a) 0 3; 1 8; 2 17;
b) 0 3; 1 5; 2 9;
c) 0 3; 1 8; 2 12;
d) 0 3; 1 8; 2 17;

Hva skriver programmet ut?

class Logg:
    def __init__(self):
        self.data = {}

    def __call__(self, navn, verdi):
        if navn not in self.data:
            self.data[navn] = []
        self.data[navn].append(verdi)
        return len(self.data[navn])

logg = Logg()
print(logg('vest', 3), logg('aust', 5), logg('vest', 7))
print(logg.data)

a) 1 2 3 og {'vest': [3, 7], 'aust': [5]}
b) 1 1 2 og {'vest': [7], 'aust': [5]}
c) 1 1 2 og {'vest': [3, 7], 'aust': [5]}
d) 3 5 7 og {'vest': [3, 7], 'aust': [5]}

Par hver løkke med utfallet. Alle variabler er satt rett før løkka.

Filen andel.py inneholder:

import sys

verdier = {'a': ['12', '4'], 'b': ['12', '0'], 'c': ['tolv', '4']}
nokkel = sys.argv[1]
par = verdier[nokkel]
x = int(par[0])
y = int(par[1])
print(100*x/y)

Par hver kommandolinje med det som skjer.

Hva skriver programmet ut?

import numpy as np

a = [2, 4]
b = np.array([2, 4])
print(a + a)
print(b + b)
print(a * 2, b * 2)

a) [4, 8], [4 8], [4, 8] [4 8]
b) [2, 4, 2, 4], [2 4 2 4], [2, 4, 2, 4] [2 4 2 4]
c) [4, 8], [4 8], [2, 4, 2, 4] [4 8]
d) [2, 4, 2, 4], [4 8], [2, 4, 2, 4] [4 8]

Programmet skal lage en tabell over $N+1$ jevnt fordelte punkter fra start til stop, uten å bruke np.linspace. Det har tre feil.

import numpy as np

def tabell(start, stop, N):
    x = np.zeros(N)
    dx = (stop - start)/(N+1)
    for i in range(N):
        x[i] = start + i*dx
    return x

a) Nevn de tre feilene og si hva hver av dem fører til. (3 poeng)

b) Skriv den rettede koden og vis at tabell(0, 4, 4) gir de fem punktene 0, 1, 2, 3, 4. (2 poeng)

Laguerre-polynomene brukes i modeller for elektronets bane rundt en atomkjerne, og oppfyller

$$L_0(x) = 1, \qquad L_1(x) = 1 - x, \qquad L_{n+1}(x) = \frac{(2n+1-x)L_n(x) - nL_{n-1}(x)}{n+1}$$

a) Skriv laguerre(n, x) med en løkke. (4 poeng)

b) Skriv en testfunksjon som sjekker mot de kjente formlene $\displaystyle L_2(x) = \frac{x^2-4x+2}{2}$ og $\displaystyle L_3(x) = \frac{-x^3+9x^2-18x+6}{6}$ for $x = 0{,}5$. (2 poeng)

En laboratoriemåling skal tabelleres for $y = \sqrt{x}$ med 9 punkter i intervallet $[1, 9]$.

a) Skriv koden med løkke og lister. (2 poeng)

b) Skriv den samme tabellen vektorisert med NumPy, uten løkke. (2 poeng)

c) Vis at de to versjonene gir like mange punkter og samme siste verdi. (1 poeng)

Skriv nøyaktig hva programmet skriver ut, med mellomrom og desimaler slik terminalen viser det.

maalinger = {'N1': 4.25, 'N2': 11.5, 'N3': 0.75}
total = 0.0
for navn in maalinger:
    total += maalinger[navn]
    print(f'{navn:>5s}{maalinger[navn]:8.2f}{total:9.3f}')

Et legemiddel doseres etter en plan som endrer seg over tid. Doseraten i milligram per time er

$$d(t) = \begin{cases} 0 & t < 1 \\ 2{,}5 & 1 \le t < 6 \\ 1{,}0 & 6 \le t < 12 \\ 0 & t \ge 12 \end{cases}$$

der $t$ er timer etter innleggelse.

a) (7 p) Skriv en klasse Doserate der __init__ tar en liste a med funksjonsverdiene og en liste b med grensene, og der __call__(self, t) returnerer riktig verdi. Klassen skal virke for et hvilket som helst antall nivåer, ikke bare fire.

b) (3 p) Utvid klassen med __str__ som gir en lesbar beskrivelse, lag instansen for planen over, og skriv ut doseraten ved $t = 0$, $0{,}5$, $1$, $3$, $6$, $11{,}9$, $12$ og $20$.

En nervecelle beskrives av membranpotensialet $v$ og en tilbakestillingsvariabel $w$:

$$v' = v - \frac{v^3}{3} - w + I, \qquad w' = \frac{v + a - bw}{\tau}$$

med $a = 0{,}7$, $b = 0{,}8$, $\tau = 12{,}5$ og den ytre strømmen $I = 0{,}6$. Ved $t = 0$ er $v = -1{,}2$ og $w = -0{,}6$. Du har ODESolver-modulen med ForwardEuler og RungeKutta4 tilgjengelig.

a) (5 p) Skriv høyresiden som en klasse Nervecelle med __init__ som lagrer de fire parametrene og __call__(self, t, u) som returnerer de to deriverte. Forklar i én setning hvorfor parametrene ikke kan sendes som argumenter til høyresiden.

b) (3 p) Løs systemet fra $t = 0$ til $t = 300$ med 6000 skritt og RungeKutta4. Skriv ut formen på u og ytterverdiene for begge komponentene.

c) (2 p) Skriv plottekoden for begge kurvene mot tid, med forklaring, og beskriv figuren.

To former av et enzym veksler: den ene veien går svært raskt, den andre langsomt.

$$x' = -100x + 4y, \qquad y' = 100x - 4y$$

med $x(0) = 1$ og $y(0) = 0$. Systemet er stivt, og en eksplisitt metode trenger urimelig små skritt.

a) (5 p) Skriv subklassen BaklengsEuler(ODESolver) med kun advance. Hvert skritt skal løse likningen $v - u_n - \Delta t\,f(t_{n+1}, v) = 0$ med root fra scipy.optimize.

b) (2 p) Løs på $[0, 3]$ med 30 skritt, og sammenlign med ForwardEuler på samme antall skritt.

c) (1 p) Regn ut likevekten for hånd og sjekk mot resultatet.

Denne oppgaven bruker Doserate fra oppgave 10 og laguerre fra oppgave 7. Du kan løse den selv om du ikke fikk dem til å virke: du vet hva de skal gjøre.

a) (4 p) Skriv test_doserate() som sjekker klassen i seks punkter, inkludert begge grensetilfellene $t = 1$ og $t = 12$.

b) (3 p) Skriv test_laguerre_null() som utnytter at $L_n(0) = 1$ for alle $n$, og sjekker det for $n = 0, 1, 2, 3, 4$.

a) (3 p) Bruk Doserate fra oppgave 10. Lag en tabell over doseraten for 121 punkter i $[0, 24]$ timer, vektorisert der det er mulig, og skriv plottekoden. Beskriv figuren.

b) (2 p) Forklar hvorfor doseratefunksjonen ikke kan evalueres på et helt NumPy-array på én gang, slik np.sqrt kan.

c) (1 p) I oppgave 12 sprakk ForwardEuler mens BaklengsEuler ga et fornuftig svar. Var det en programmeringsfeil? Begrunn.