Læringsmål

Oversikt over læringsmål dekket i IN1900 Introduksjon til programmering med vitenskapelige anvendelser

Kilde: Læringsmålene er utformet av Skolesaga på grunnlag av emnets eksamensoppgaver, sensorveiledninger og emnebeskrivelse. De er ikke institusjonens offisielle læringsutbyttebeskrivelser.

171 kompetansemål43 av 43 kapitler har kompetansemål

Alle kompetansemål

•kunne gjøre rede for hvordan emnet vurderes: to eksamener, vekting, varighet og poengsum
0.1Eksamenskartet — slik testes IN1900
•kunne peke ut hvilke temaer som har kommet i hvert eneste av de siste settene, og prioritere lesingen etter det
0.1Eksamenskartet — slik testes IN1900
•kunne forklare hva den som retter besvarelsen ser etter, og hvorfor delvis riktig kode gir uttelling
0.1Eksamenskartet — slik testes IN1900
•kunne sette opp en realistisk lese- og tidsplan fram mot begge eksamenene
0.1Eksamenskartet — slik testes IN1900
•kunne avgjøre hvilken datatype et uttrykk i Python gir, og hvordan heltall og desimaltall blandes
1.1Variabler, datatyper, uttrykk og operatorpresedens
•kunne regne ut hva et sammensatt aritmetisk uttrykk evaluerer til, med riktig rekkefølge på operatorene
1.1Variabler, datatyper, uttrykk og operatorpresedens
•kunne avgjøre om et logisk uttrykk er sant eller falskt, også når det er satt sammen av flere sammenligninger
1.1Variabler, datatyper, uttrykk og operatorpresedens
•kunne angi nøyaktig hva et lite program skriver ut, tegn for tegn
1.1Variabler, datatyper, uttrykk og operatorpresedens
•kunne hente ut et enkelt element og et utsnitt fra en liste, og si hvilken av dem som gir en ny liste
1.2Lister, indeksering og slicing
•kunne regne ut hva et sammensatt uttrykk med indeks inne i indeks gir, i en nøstet liste
1.2Lister, indeksering og slicing
•kunne skille å skjøte sammen to lister fra å legge dem sammen tall for tall
1.2Lister, indeksering og slicing
•kunne angi nøyaktig hva et program som skriver ut lister, gir på skjermen
1.2Lister, indeksering og slicing
•kunne telle nøyaktig hvor mange ganger en løkke kjører, og hvilke verdier tellevariabelen får
1.3Løkker — for, while, range og nøstede løkker
•kunne bygge opp en sum eller en teller i en løkke, med riktig startverdi
1.3Løkker — for, while, range og nøstede løkker
•kunne spore en løkke inne i en løkke der den indre grensen avhenger av den ytre
1.3Løkker — for, while, range og nøstede løkker
•kunne avgjøre om en betingelsesstyrt løkke stopper etter et endelig antall runder, eller aldri
1.3Løkker — for, while, range og nøstede løkker
•kunne dele opp og rydde en tekstlinje med de vanlige strengmetodene
1.4Strenger, f-strenger og formatert utskrift
•kunne skrive en formatert utskrift med fast bredde og fast antall desimaler
1.4Strenger, f-strenger og formatert utskrift
•kunne angi nøyaktig hva en utskrift blir, inkludert mellomrom og linjeskift
1.4Strenger, f-strenger og formatert utskrift
•kunne forklare hvorfor en tekst må gjøres om til tall før du kan regne med den
1.4Strenger, f-strenger og formatert utskrift
•kunne slå opp, sette inn og oppdatere verdier i en ordbok, og forklare hvorfor et oppslag noen ganger stopper programmet
1.5Dictionaries og nøstede dictionaries
•kunne gå gjennom en ordbok med løkke og angi nøyaktig hva den skriver ut
1.5Dictionaries og nøstede dictionaries
•kunne bygge en ordbok fra to lister, og telle opp verdier uten å vite nøklene på forhånd
1.5Dictionaries og nøstede dictionaries
•kunne bygge og lese en nøstet ordbok, og holde de to nivåene fra hverandre
1.5Dictionaries og nøstede dictionaries
•kunne skrive en funksjon med riktig signatur og riktig returverdi, og forklare forskjellen på å returnere og å skrive ut
1.6Funksjoner, scope og lambda
•kunne bruke standardverdier og navngitte argumenter, og avgjøre hvilken verdi hver parameter får i et gitt kall
1.6Funksjoner, scope og lambda
•kunne avgjøre om en variabel inne i en funksjon er den samme som den utenfor, og angi nøyaktig hva programmet skriver ut
1.6Funksjoner, scope og lambda
•kunne sende en funksjon inn som argument til en annen funksjon, og skrive den som en enlinjes funksjon der det passer
1.6Funksjoner, scope og lambda
•kunne føre en sporingstavle som viser variablenes verdier iterasjon for iterasjon
1.7DRILL — Kodesporing: «hva skrives ut?»
•kunne telle nøyaktig hvor mange runder en løkke går, også når den ligger inne i en annen løkke
1.7DRILL — Kodesporing: «hva skrives ut?»
•kunne skrive utskriften tegn for tegn, med riktige mellomrom, linjeskift og desimaler
1.7DRILL — Kodesporing: «hva skrives ut?»
•kunne avgjøre om en betingelsesstyrt løkke stopper eller går i det uendelige
1.7DRILL — Kodesporing: «hva skrives ut?»
•kunne spore et lite Python-program under tidspress og angi utskriften nøyaktig
1.PPrøver til del 1: Python-grunnlaget og kodesporing
•kunne regne ut indekserings- og utsnittsuttrykk i nøstede lister og pare dem med riktig verdi
1.PPrøver til del 1: Python-grunnlaget og kodesporing
•kunne avgjøre om en løkke stopper, og hvor mange runder den går
1.PPrøver til del 1: Python-grunnlaget og kodesporing
•kunne kjenne igjen hvilken felle et midtveisspørsmål sikter mot, og sjekke nettopp den
1.PPrøver til del 1: Python-grunnlaget og kodesporing
•kunne lese av hva `sys.argv` inneholder for et gitt kall på kommandolinjen, inkludert at element 0 er programnavnet
2.1Kommandolinje, brukerinput og eval
•kunne konvertere tekst fra kommandolinjen eller `input` til tall med `int` og `float`, og vite når konverteringen feiler
2.1Kommandolinje, brukerinput og eval
•kunne bruke `eval` til å regne ut et uttrykk brukeren har oppgitt som tekst
2.1Kommandolinje, brukerinput og eval
•kunne skrive et kort program som sjekker antall argumenter og avslutter ryddig med `sys.exit`
2.1Kommandolinje, brukerinput og eval
•kunne gå gjennom et kort program linje for linje og navngi den første feilen som utløses for et gitt kommandolinjekall
2.2DRILL — Feilhåndtering: hvilken exception utløses?
•kunne skille `ValueError`, `TypeError`, `IndexError`, `KeyError`, `ZeroDivisionError` og `AssertionError` fra hverandre
2.2DRILL — Feilhåndtering: hvilken exception utløses?
•kunne skrive `try`/`except`-blokker i riktig rekkefølge, med spesifikke feiltyper før generelle
2.2DRILL — Feilhåndtering: hvilken exception utløses?
•kunne bruke `assert` og `raise` til å avvise ugyldige verdier, og forutsi hvilken melding brukeren ser
2.2DRILL — Feilhåndtering: hvilken exception utløses?
•kunne spore et kommandolinje- eller input-program og angi utskriften nøyaktig under tidspress
2.PPrøver til del 2: Robuste programmer: input, kommandolinje og feilhåndtering
•kunne avgjøre hvilken exception som utløses først for et gitt kall, og matche den mot riktig alternativ
2.PPrøver til del 2: Robuste programmer: input, kommandolinje og feilhåndtering
•kunne skrive kort, idiomatisk `try`/`except`-kode som håndterer manglende, ubrukelige og ulovlige verdier
2.PPrøver til del 2: Robuste programmer: input, kommandolinje og feilhåndtering
•kunne finne og forklare de faste plantede feilene i et program med kommandolinje og feilhåndtering
2.PPrøver til del 2: Robuste programmer: input, kommandolinje og feilhåndtering
•kunne bruke en påstandssjekk i koden til å stoppe programmet med en presis beskjed når noe ikke stemmer
3.1Testfunksjoner og assert
•kunne forklare hvorfor to flyttall som matematisk er like sjelden er nøyaktig like i Python, og hva du gjør i stedet
3.1Testfunksjoner og assert
•kunne skrive en testfunksjon i den formen sensor forventer: fasit, beregnet verdi, toleranse og feilmelding
3.1Testfunksjoner og assert
•kunne velge en toleranse som passer til metodens nøyaktighet, og teste flere punkter i samme testfunksjon
3.1Testfunksjoner og assert
•kunne lese et summetegn som en oppskrift på en løkke, og oversette grensene riktig
3.2Rekker og summer: Taylor- og potensrekker
•kunne skrive en funksjon som summerer en endelig rekke, med akkumulator, riktig løkkegrense og retur på rett sted
3.2Rekker og summer: Taylor- og potensrekker
•kunne håndtere ledd som skifter fortegn og ledd som bare har oddetalls- eller partallspotenser
3.2Rekker og summer: Taylor- og potensrekker
•kunne løse en rekurrent rekke med løkke og to lagervariabler, og teste svaret mot en uavhengig fasit
3.2Rekker og summer: Taylor- og potensrekker
•kunne gjennomføre løsningsoppskriften for rekkeoppgaven på sju steg, uansett hvilken funksjon innpakningen bruker
3.3DRILL — Rekke-implementering med testfunksjon
•kunne skrive den tredelte eksamensbesvarelsen — summen, testfunksjonen og en kort begrunnelse for antall ledd og toleranse
3.3DRILL — Rekke-implementering med testfunksjon
•kunne kjenne igjen når oppgaven krever den rekurrente malen i stedet for summeringsmønsteret, og løse den med løkke
3.3DRILL — Rekke-implementering med testfunksjon
•kunne finne og rette de fire feilene som koster mest: løkkegrensen, plasseringen av akkumulator og retur, ulik indeksering og likhetstegn på flyttall
3.3DRILL — Rekke-implementering med testfunksjon
•kunne skrive en testfunksjon i sensors form under tidspress, med uavhengig fasit og begrunnet toleranse
3.PPrøver til del 3: Funksjoner, testing og rekker
•kunne implementere en endelig rekke fra formel til kode uten å kjøre den
3.PPrøver til del 3: Funksjoner, testing og rekker
•kunne kjenne igjen når en rekke er rekurrent, og løse den med løkke og to lagervariabler
3.PPrøver til del 3: Funksjoner, testing og rekker
•kunne løse en flerdelt eksamensoppgave der sum, test, bruk og tabell inngår
3.PPrøver til del 3: Funksjoner, testing og rekker
•kunne opprette en talltabell med nuller, ettere eller jevnt fordelte punkter, og forklare hvorfor N intervaller gir N+1 punkter
4.1NumPy-arrays: oppretting, vektorisering og 2D
•kunne regne elementvis på hele tabeller uten løkke, og skille dette fra hvordan lister skjøtes og gjentas
4.1NumPy-arrays: oppretting, vektorisering og 2D
•kunne bruke en funksjon du selv har skrevet på en hel tabell, og vite når du må bytte fra math-modulen til NumPy
4.1NumPy-arrays: oppretting, vektorisering og 2D
•kjenne til tabeller med to indekser: hente ut en rad, en kolonne og ett element
4.1NumPy-arrays: oppretting, vektorisering og 2D
•kunne skrive begge malene for en verditabell fra hukommelsen: med løkke og lister, og vektorisert uten løkke
4.2Lister vs. NumPy — «med løkke / uten løkke»
•kunne regne ut steglengden riktig og forklare hvorfor nevneren er antall intervaller
4.2Lister vs. NumPy — «med løkke / uten løkke»
•kunne avgjøre når oppgaveteksten krever vektorisering, og når en løkke er nødvendig
4.2Lister vs. NumPy — «med løkke / uten løkke»
•kunne kontrollere en ferdig punkttabell på antall punkter og siste verdi
4.2Lister vs. NumPy — «med løkke / uten løkke»
•kunne skrive plottemalen fra hukommelsen: én kurve per plottekall, navngitte akser, legende og visning til slutt
4.3Plotting med matplotlib
•kunne plotte flere kurver i samme figur, også når de kommer som kolonner i en løsningstabell
4.3Plotting med matplotlib
•kunne skille et tidsplott fra en fasekurve, og velge riktige aksenavn i begge
4.3Plotting med matplotlib
•kunne beskrive en figur i ord som selvkontroll når koden ikke kan kjøres
4.3Plotting med matplotlib
•kunne spore tabellkode og angi utskriften nøyaktig under tidspress
4.PPrøver til del 4: NumPy, vektorisering og plotting
•kunne skrive begge malene for en verditabell uten å kjøre koden
4.PPrøver til del 4: NumPy, vektorisering og plotting
•kunne skrive plottekode med legende og navngitte akser, og beskrive figuren i ord
4.PPrøver til del 4: NumPy, vektorisering og plotting
•kunne løse en flerdelt eksamensoppgave der tabell, vektorisering og plott inngår
4.PPrøver til del 4: NumPy, vektorisering og plotting
•kunne definere en klasse der konstruktøren tar imot parametrene og lagrer dem som attributter på instansen
5.1Klasser, `__init__` og `__call__`
•kunne gjøre en instans kallbar, slik at objektet kan brukes overalt der en funksjon av én variabel er ventet
5.1Klasser, `__init__` og `__call__`
•kunne avgjøre hva som hører i konstruktøren og hva som hører i kallmetoden, ut fra hva som er fast og hva som varierer
5.1Klasser, `__init__` og `__call__`
•kunne spore et program med klasser og angi hvilken metode hvert uttrykk utløser
5.1Klasser, `__init__` og `__call__`
•kunne gjøre et objekt utskrivbart ved å returnere en formatert tekst fra `__str__`
5.2Spesialmetoder: `__str__`, `__add__`, `__mul__`
•kunne implementere addisjon og multiplikasjon for egne objekter, og alltid returnere en ny instans av klassen
5.2Spesialmetoder: `__str__`, `__add__`, `__mul__`
•kunne begrunne når multiplikasjon skal gi et tall i stedet for et objekt, og skille de to tilfellene med `isinstance`
5.2Spesialmetoder: `__str__`, `__add__`, `__mul__`
•kunne legge sammen to objekter med ulikt antall tall, som polynomer av ulik grad, uten å endre operandene
5.2Spesialmetoder: `__str__`, `__add__`, `__mul__`
•kunne skrive en subklasse som arver metodene til en basisklasse, og bare fylle inn det som er nytt
5.3Arv og `super()`
•kunne kalle basisklassens konstruktør riktig, som første linje og uten å sende instansen selv
5.3Arv og `super()`
•kunne overstyre en arvet metode, og forklare hvorfor basisklassen er uendret av det
5.3Arv og `super()`
•kunne avgjøre om et objekt hører til en klasse eller en av dens subklasser
5.3Arv og `super()`
•kunne oversette en stykkvis definert funksjon fra klammeparentes til betinget logikk, med grensene på riktig side
5.4Stykkvise og diskontinuerlige funksjoner
•kunne skrive den generelle stykkvise klassen der funksjonsverdier og grenser gis som lister
5.4Stykkvise og diskontinuerlige funksjoner
•kunne kontrollere en stykkvis funksjon ved å regne ut verdien i nøyaktig grensepunktene
5.4Stykkvise og diskontinuerlige funksjoner
•kunne forklare hvorfor en betinget funksjon må kalles ett punkt av gangen, og hva det vektoriserte alternativet gjør
5.4Stykkvise og diskontinuerlige funksjoner
•kunne gå fra oppgavetekst til ferdig klasse ved å følge en fast oppskrift på sju steg
5.5DRILL — Klasser med spesialmetoder
•kunne avgjøre hvilken spesialmetode hvert krav i oppgaveteksten peker på, og skrive den i sensors korte stil
5.5DRILL — Klasser med spesialmetoder
•kunne skrive `__add__` og `__mul__` slik at de gir en ny instans, og begrunne når multiplikasjon i stedet skal gi et tall
5.5DRILL — Klasser med spesialmetoder
•kunne løse del b av oppgaven: instansiere klassen, kontrollere den med en testfunksjon og plotte den
5.5DRILL — Klasser med spesialmetoder
•kunne skrive en funksjonsklasse der konstruktøren tar det som er fast og kallmetoden det som varierer
5.PPrøver til del 5: Klasser med spesialmetoder
•kunne gi et objekt tekst og aritmetikk med spesialmetoder, og alltid returnere en ny instans fra en aritmetisk metode
5.PPrøver til del 5: Klasser med spesialmetoder
•kunne bygge en subklasse som regner om parametrene sine og sender dem videre til basisklassen
5.PPrøver til del 5: Klasser med spesialmetoder
•kunne løse en flerdelt klasseoppgave under tidspress, med testfunksjon og plott
5.PPrøver til del 5: Klasser med spesialmetoder
•kunne skrive den numeriske deriverte som funksjon med sentrert differanse og en fornuftig standard steglengde
6.1Numerisk derivasjon, integrasjon og nullpunkt
•kunne vise at en metode konvergerer, ved å regne feilen mot det eksakte svaret for flere steglengder og lese av faktoren mellom radene
6.1Numerisk derivasjon, integrasjon og nullpunkt
•kunne skrive trapesmetoden med riktige vekter på endepunktene og riktige summegrenser
6.1Numerisk derivasjon, integrasjon og nullpunkt
•kjenne til Newtons metode, sekantmetoden og biblioteksløseren, med stoppkriterium og riktig innpakning av funksjonen
6.1Numerisk derivasjon, integrasjon og nullpunkt
•kunne sette opp tabellene for en differenslikning, sette startverdien og fylle resten i løkke uten å bomme på antallet
6.2Differenslikninger
•kunne avgjøre hvilken av to koblede likninger som må oppdateres først, og begrunne det ut fra indeksene
6.2Differenslikninger
•kunne skrive simuleringsfunksjonen som returnerer begge tabellene, og plotte dem mot tid og mot hverandre
6.2Differenslikninger
•kunne kontrollere en simulering ved å regne ut likevekten for hånd eller halvere steglengden
6.2Differenslikninger
•kunne gjennomføre løsningsoppskriften for differenslikninger på sju steg, uansett hvilken innpakning modellen har
6.3DRILL — Differenslikninger
•kunne avgjøre på et blikk om oppdateringsrekkefølgen er kritisk, og begrunne svaret ut fra likningene
6.3DRILL — Differenslikninger
•kunne skrive plott-deloppgaven med tidsakse, forklaring og navngitte akser, og beskrive figuren i ord
6.3DRILL — Differenslikninger
•kunne bruke bevaringssjekk og likevektsregning som kontroll uten fasit
6.3DRILL — Differenslikninger
•kunne skrive forlengs og sentrert differanse, både som funksjon med default-steg og som kallbar klasse
6.PPrøver til del 6: Numeriske metoder som kodemønstre
•kunne avgjøre om oppdateringsrekkefølgen i et koblet system er kritisk, og begrunne svaret ut fra likningene
6.PPrøver til del 6: Numeriske metoder som kodemønstre
•kunne løse en likning numerisk med Newtons metode, sekantmetoden og et ferdig verktøy, og kontrollere svaret
6.PPrøver til del 6: Numeriske metoder som kodemønstre
•kunne løse en flerdelt eksamensoppgave der simulering, likevektsregning og plott inngår
6.PPrøver til del 6: Numeriske metoder som kodemønstre
•kunne skrive en løser for et initialverdiproblem som en funksjon som tar høyresiden, sluttiden, antall steg og startverdien, og returnerer tidspunktene og løsningen
7.1ODE-løser som funksjon: forward Euler
•kunne begrunne hvorfor N steg gir N+1 punkter, og plassere startverdien før løkka
7.1ODE-løser som funksjon: forward Euler
•kunne måle nøyaktigheten ved å halvere steglengden, og gjenkjenne at forlengs Euler har orden 1 og Heun orden 2
7.1ODE-løser som funksjon: forward Euler
•kunne bytte oppdateringsformel til baklengs Euler eller Heun uten å endre resten av mønsteret
7.1ODE-løser som funksjon: forward Euler
•kunne løse en skalar differensiallikning med det utleverte løser-hierarkiet i tre kall: instansiering, initialbetingelse og solve
7.2Det utleverte ODESolver-hierarkiet: bruke ForwardEuler og RungeKutta4
•kunne lese den utleverte modulen og peke ut argumentrekkefølgen i høyresiden, hva solve tar imot og hva den returnerer
7.2Det utleverte ODESolver-hierarkiet: bruke ForwardEuler og RungeKutta4
•kunne begrunne valget mellom en metode av orden 1 og en av orden 4 ut fra målt feil og antall funksjonskall
7.2Det utleverte ODESolver-hierarkiet: bruke ForwardEuler og RungeKutta4
•kunne kjenne igjen den eldre varianten av grensesnittet og skrive om et program fra den til den nye
7.2Det utleverte ODESolver-hierarkiet: bruke ForwardEuler og RungeKutta4
•kunne skrive høyresiden for et ODE-system: pakke ut tilstandsvektoren, regne ut hver derivert og returnere dem som en liste i samme rekkefølge
7.3ODE-systemer: pakke ut u og plotte komponentene
•kunne hente ut komponentene av løsningen som kolonner og forklare forskjellen på en kurve og et øyeblikk
7.3ODE-systemer: pakke ut u og plotte komponentene
•kunne lagre modellparametre i en klasse med `__call__` og skrive om en andreordens likning til et system
7.3ODE-systemer: pakke ut u og plotte komponentene
•kunne plotte komponentene med navn og legende, og beskrive figuren presist i ord
7.3ODE-systemer: pakke ut u og plotte komponentene
•kunne utvide et ferdig løser-hierarki med en ny metode ved å arve alt og skrive bare den ene metoden som gjør ett tidssteg
7.4Subklasse av ODESolver: skriv `advance`
•kunne bruke løserens egne verdier for høyreside, løsning, tid, stegnummer og steglengde inne i den metoden
7.4Subklasse av ODESolver: skriv `advance`
•kunne gi en subklasse egne parametre uten å miste oppsettet fra klassen den arver fra
7.4Subklasse av ODESolver: skriv `advance`
•kunne implementere en implisitt metode der hvert tidssteg løser en likning numerisk
7.4Subklasse av ODESolver: skriv `advance`
•kunne oversette en modell med flere størrelser til en høyreside med utpakking og returliste, uansett hvilken innpakning oppgaven bruker
7.5DRILL — ODE-oppgaver med roterende innpakning
•kunne sette opp og kjøre det utleverte løserhierarkiet, og pakke ut komponentene riktig før plottet
7.5DRILL — ODE-oppgaver med roterende innpakning
•kunne skrive en egen løser som funksjon og en ny metode som subklasse, inkludert den implisitte varianten med nullpunktsløser
7.5DRILL — ODE-oppgaver med roterende innpakning
•kunne finne og rette de fem feilene som koster mest, og bruke fornuftssjekker når det ikke finnes noen fasit
7.5DRILL — ODE-oppgaver med roterende innpakning
•kunne skrive en ODE-løser som funksjon fra bunnen, med riktig telling av skritt og punkter
7.PPrøver til del 7: ODE-løsere og ODESolver-hierarkiet
•kunne bruke det utleverte hierarkiet på en skalar likning og på et system, og pakke ut komponentene riktig
7.PPrøver til del 7: ODE-løsere og ODESolver-hierarkiet
•kunne løse en tipoengsoppgave med høyreside, løsning, plott og fornuftssjekk under tidspress
7.PPrøver til del 7: ODE-løsere og ODESolver-hierarkiet
•kunne implementere en ny ODE-metode som subklasse, både eksplisitt og implisitt med nullpunktsløser
7.PPrøver til del 7: ODE-løsere og ODESolver-hierarkiet
•kunne lese en tekstfil linje for linje med `with open` og dele hver linje i felt med riktig separator
8.1Fillesing til nøstet dictionary
•kunne bygge en nøstet ordbok fra fila, med typekonvertering og med den indre ordboken opprettet før innsetting
8.1Fillesing til nøstet dictionary
•kunne hoppe over en header-linje med `readline()` og bruke kolonnenavnene som feltnavn
8.1Fillesing til nøstet dictionary
•kunne begrunne hvorfor en ordbok slår en liste når data skal slås opp på navn eller ID
8.1Fillesing til nøstet dictionary
•kunne skrive en nøstet ordbok til fil med riktig separator, valgfri header-linje og linjeskift på hver linje
8.2Filskriving, filtrering og fast-bredde-felt
•kunne filtrere en ordbok ved å bygge og returnere en ny, uten å endre argumentet
8.2Filskriving, filtrering og fast-bredde-felt
•kunne forklare hva aliasing er, og hvorfor `ny = data` ikke er en kopi
8.2Filskriving, filtrering og fast-bredde-felt
•kjenne til fast-bredde-lesing med posisjonsskiving, og hva sensor faktisk gir uttelling for der
8.2Filskriving, filtrering og fast-bredde-felt
•kunne gjennomføre løsningsoppskriften for fillesingsoppgaven på seks steg, uansett hvilken innpakning dataene har
8.3DRILL — Fillesing til nøstet dict med filtrering
•kunne skrive den tredelte eksamensbesvarelsen — les til nøstet ordbok, skriv struktur til fil, filtrer og returner en ny ordbok
8.3DRILL — Fillesing til nøstet dict med filtrering
•kunne aggregere per ytre nøkkel og gruppere flere rader i en liste, med akkumulatoren nullstilt på rett sted
8.3DRILL — Fillesing til nøstet dict med filtrering
•kunne finne og rette de fire feilene som koster mest: separator, header, mutasjon av argumentet og manglende linjeskift
8.3DRILL — Fillesing til nøstet dict med filtrering
•kunne lese en tekstfil til en nøstet ordbok med riktig separator, rensing og typekonvertering
8.PPrøver til del 8: Fillesing og datastrukturer
•kunne hente feltnavnene fra en header-linje, og kjenne igjen feilmeldingen som kommer når linja ikke ble hoppet over
8.PPrøver til del 8: Fillesing og datastrukturer
•kunne skrive en datastruktur tilbake til fil og filtrere den uten å endre det som ble sendt inn
8.PPrøver til del 8: Fillesing og datastrukturer
•kunne løse en flerdelt fillesingsoppgave der gruppering, aggregering, filtrering og skriving inngår
8.PPrøver til del 8: Fillesing og datastrukturer
•kunne gjennomføre en komplett midtveisprøve på tid: 20 flervalgsspørsmål i 120 minutter, uten å kjøre koden
9.1Midtveis-simulering: 20 flervalg
•kunne spore et Python-program mekanisk og skrive utskriften tegn for tegn, med riktige løkkegrenser, indekser og utskriftsdetaljer
9.1Midtveis-simulering: 20 flervalg
•kunne avgjøre hvilken feil et program utløser først, og om en løkke terminerer eller går uendelig
9.1Midtveis-simulering: 20 flervalg
•kunne bruke poengsummen som et kart over hvilke kapitler du bør lese om igjen
9.1Midtveis-simulering: 20 flervalg
•kunne disponere et firetimers eksamenssett: 16 poeng flervalg på en halvtime, og 59 poeng kodeskriving på resten
9.2Avsluttende øvingseksamen 1 — epidemi-innpakning
•kunne skrive de fem kjernemønstrene fra bunnen uten å kjøre koden — rekke med testfunksjon, klasse med spesialmetoder, differenslikning, ODE-system med det utleverte hierarkiet, og fillesing til nøstet dictionary
9.2Avsluttende øvingseksamen 1 — epidemi-innpakning
•kunne vurdere egen besvarelse mot poenglistene og se hva som gir uttelling selv når koden ikke er helt riktig
9.2Avsluttende øvingseksamen 1 — epidemi-innpakning9.3Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse
•kunne gjengi de faste mekaniske detaljene ved eksamenen, blant annet at siste oppgave er sensors poengfelt og ikke skal besvares
9.2Avsluttende øvingseksamen 1 — epidemi-innpakning
•kunne disponere et firetimers eksamenssett: 14 poeng flervalg på en halvtime, og 61 poeng kodeskriving på resten
9.3Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse
•kunne skrive de tyngste mønstrene fra bunnen uten å kjøre koden — stykkvis klasse med spesialmetoder, rekurrent rekke med testfunksjon, ODE-system med parametere, og en ny løsermetode som subklasse
9.3Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse
•kunne skille mellom en programmeringsfeil og en egenskap ved metoden eller modellen, og begrunne skillet
9.3Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse

Kapitler med kompetansemål

0Eksamenskart

0.1Eksamenskartet — slik testes IN1900
  • kunne gjøre rede for hvordan emnet vurderes: to eksamener, vekting, varighet og poengsum
  • kunne peke ut hvilke temaer som har kommet i hvert eneste av de siste settene, og prioritere lesingen etter det
  • kunne forklare hva den som retter besvarelsen ser etter, og hvorfor delvis riktig kode gir uttelling
  • kunne sette opp en realistisk lese- og tidsplan fram mot begge eksamenene

1Python-grunnlaget og kodesporing

1.1Variabler, datatyper, uttrykk og operatorpresedens
  • kunne avgjøre hvilken datatype et uttrykk i Python gir, og hvordan heltall og desimaltall blandes
  • kunne regne ut hva et sammensatt aritmetisk uttrykk evaluerer til, med riktig rekkefølge på operatorene
  • kunne avgjøre om et logisk uttrykk er sant eller falskt, også når det er satt sammen av flere sammenligninger
  • kunne angi nøyaktig hva et lite program skriver ut, tegn for tegn
1.2Lister, indeksering og slicing
  • kunne hente ut et enkelt element og et utsnitt fra en liste, og si hvilken av dem som gir en ny liste
  • kunne regne ut hva et sammensatt uttrykk med indeks inne i indeks gir, i en nøstet liste
  • kunne skille å skjøte sammen to lister fra å legge dem sammen tall for tall
  • kunne angi nøyaktig hva et program som skriver ut lister, gir på skjermen
1.3Løkker — for, while, range og nøstede løkker
  • kunne telle nøyaktig hvor mange ganger en løkke kjører, og hvilke verdier tellevariabelen får
  • kunne bygge opp en sum eller en teller i en løkke, med riktig startverdi
  • kunne spore en løkke inne i en løkke der den indre grensen avhenger av den ytre
  • kunne avgjøre om en betingelsesstyrt løkke stopper etter et endelig antall runder, eller aldri
1.4Strenger, f-strenger og formatert utskrift
  • kunne dele opp og rydde en tekstlinje med de vanlige strengmetodene
  • kunne skrive en formatert utskrift med fast bredde og fast antall desimaler
  • kunne angi nøyaktig hva en utskrift blir, inkludert mellomrom og linjeskift
  • kunne forklare hvorfor en tekst må gjøres om til tall før du kan regne med den
1.5Dictionaries og nøstede dictionaries
  • kunne slå opp, sette inn og oppdatere verdier i en ordbok, og forklare hvorfor et oppslag noen ganger stopper programmet
  • kunne gå gjennom en ordbok med løkke og angi nøyaktig hva den skriver ut
  • kunne bygge en ordbok fra to lister, og telle opp verdier uten å vite nøklene på forhånd
  • kunne bygge og lese en nøstet ordbok, og holde de to nivåene fra hverandre
1.6Funksjoner, scope og lambda
  • kunne skrive en funksjon med riktig signatur og riktig returverdi, og forklare forskjellen på å returnere og å skrive ut
  • kunne bruke standardverdier og navngitte argumenter, og avgjøre hvilken verdi hver parameter får i et gitt kall
  • kunne avgjøre om en variabel inne i en funksjon er den samme som den utenfor, og angi nøyaktig hva programmet skriver ut
  • kunne sende en funksjon inn som argument til en annen funksjon, og skrive den som en enlinjes funksjon der det passer
1.7DRILL — Kodesporing: «hva skrives ut?»
  • kunne føre en sporingstavle som viser variablenes verdier iterasjon for iterasjon
  • kunne telle nøyaktig hvor mange runder en løkke går, også når den ligger inne i en annen løkke
  • kunne skrive utskriften tegn for tegn, med riktige mellomrom, linjeskift og desimaler
  • kunne avgjøre om en betingelsesstyrt løkke stopper eller går i det uendelige
1.PPrøver til del 1: Python-grunnlaget og kodesporing
  • kunne spore et lite Python-program under tidspress og angi utskriften nøyaktig
  • kunne regne ut indekserings- og utsnittsuttrykk i nøstede lister og pare dem med riktig verdi
  • kunne avgjøre om en løkke stopper, og hvor mange runder den går
  • kunne kjenne igjen hvilken felle et midtveisspørsmål sikter mot, og sjekke nettopp den

2Robuste programmer: input, kommandolinje og feilhåndtering

2.1Kommandolinje, brukerinput og eval
  • kunne lese av hva `sys.argv` inneholder for et gitt kall på kommandolinjen, inkludert at element 0 er programnavnet
  • kunne konvertere tekst fra kommandolinjen eller `input` til tall med `int` og `float`, og vite når konverteringen feiler
  • kunne bruke `eval` til å regne ut et uttrykk brukeren har oppgitt som tekst
  • kunne skrive et kort program som sjekker antall argumenter og avslutter ryddig med `sys.exit`
2.2DRILL — Feilhåndtering: hvilken exception utløses?
  • kunne gå gjennom et kort program linje for linje og navngi den første feilen som utløses for et gitt kommandolinjekall
  • kunne skille `ValueError`, `TypeError`, `IndexError`, `KeyError`, `ZeroDivisionError` og `AssertionError` fra hverandre
  • kunne skrive `try`/`except`-blokker i riktig rekkefølge, med spesifikke feiltyper før generelle
  • kunne bruke `assert` og `raise` til å avvise ugyldige verdier, og forutsi hvilken melding brukeren ser
2.PPrøver til del 2: Robuste programmer: input, kommandolinje og feilhåndtering
  • kunne spore et kommandolinje- eller input-program og angi utskriften nøyaktig under tidspress
  • kunne avgjøre hvilken exception som utløses først for et gitt kall, og matche den mot riktig alternativ
  • kunne skrive kort, idiomatisk `try`/`except`-kode som håndterer manglende, ubrukelige og ulovlige verdier
  • kunne finne og forklare de faste plantede feilene i et program med kommandolinje og feilhåndtering

3Funksjoner, testing og rekker

3.1Testfunksjoner og assert
  • kunne bruke en påstandssjekk i koden til å stoppe programmet med en presis beskjed når noe ikke stemmer
  • kunne forklare hvorfor to flyttall som matematisk er like sjelden er nøyaktig like i Python, og hva du gjør i stedet
  • kunne skrive en testfunksjon i den formen sensor forventer: fasit, beregnet verdi, toleranse og feilmelding
  • kunne velge en toleranse som passer til metodens nøyaktighet, og teste flere punkter i samme testfunksjon
3.2Rekker og summer: Taylor- og potensrekker
  • kunne lese et summetegn som en oppskrift på en løkke, og oversette grensene riktig
  • kunne skrive en funksjon som summerer en endelig rekke, med akkumulator, riktig løkkegrense og retur på rett sted
  • kunne håndtere ledd som skifter fortegn og ledd som bare har oddetalls- eller partallspotenser
  • kunne løse en rekurrent rekke med løkke og to lagervariabler, og teste svaret mot en uavhengig fasit
3.3DRILL — Rekke-implementering med testfunksjon
  • kunne gjennomføre løsningsoppskriften for rekkeoppgaven på sju steg, uansett hvilken funksjon innpakningen bruker
  • kunne skrive den tredelte eksamensbesvarelsen — summen, testfunksjonen og en kort begrunnelse for antall ledd og toleranse
  • kunne kjenne igjen når oppgaven krever den rekurrente malen i stedet for summeringsmønsteret, og løse den med løkke
  • kunne finne og rette de fire feilene som koster mest: løkkegrensen, plasseringen av akkumulator og retur, ulik indeksering og likhetstegn på flyttall
3.PPrøver til del 3: Funksjoner, testing og rekker
  • kunne skrive en testfunksjon i sensors form under tidspress, med uavhengig fasit og begrunnet toleranse
  • kunne implementere en endelig rekke fra formel til kode uten å kjøre den
  • kunne kjenne igjen når en rekke er rekurrent, og løse den med løkke og to lagervariabler
  • kunne løse en flerdelt eksamensoppgave der sum, test, bruk og tabell inngår

4NumPy, vektorisering og plotting

4.1NumPy-arrays: oppretting, vektorisering og 2D
  • kunne opprette en talltabell med nuller, ettere eller jevnt fordelte punkter, og forklare hvorfor N intervaller gir N+1 punkter
  • kunne regne elementvis på hele tabeller uten løkke, og skille dette fra hvordan lister skjøtes og gjentas
  • kunne bruke en funksjon du selv har skrevet på en hel tabell, og vite når du må bytte fra math-modulen til NumPy
  • kjenne til tabeller med to indekser: hente ut en rad, en kolonne og ett element
4.2Lister vs. NumPy — «med løkke / uten løkke»
  • kunne skrive begge malene for en verditabell fra hukommelsen: med løkke og lister, og vektorisert uten løkke
  • kunne regne ut steglengden riktig og forklare hvorfor nevneren er antall intervaller
  • kunne avgjøre når oppgaveteksten krever vektorisering, og når en løkke er nødvendig
  • kunne kontrollere en ferdig punkttabell på antall punkter og siste verdi
4.3Plotting med matplotlib
  • kunne skrive plottemalen fra hukommelsen: én kurve per plottekall, navngitte akser, legende og visning til slutt
  • kunne plotte flere kurver i samme figur, også når de kommer som kolonner i en løsningstabell
  • kunne skille et tidsplott fra en fasekurve, og velge riktige aksenavn i begge
  • kunne beskrive en figur i ord som selvkontroll når koden ikke kan kjøres
4.PPrøver til del 4: NumPy, vektorisering og plotting
  • kunne spore tabellkode og angi utskriften nøyaktig under tidspress
  • kunne skrive begge malene for en verditabell uten å kjøre koden
  • kunne skrive plottekode med legende og navngitte akser, og beskrive figuren i ord
  • kunne løse en flerdelt eksamensoppgave der tabell, vektorisering og plott inngår

5Klasser med spesialmetoder

5.1Klasser, `__init__` og `__call__`
  • kunne definere en klasse der konstruktøren tar imot parametrene og lagrer dem som attributter på instansen
  • kunne gjøre en instans kallbar, slik at objektet kan brukes overalt der en funksjon av én variabel er ventet
  • kunne avgjøre hva som hører i konstruktøren og hva som hører i kallmetoden, ut fra hva som er fast og hva som varierer
  • kunne spore et program med klasser og angi hvilken metode hvert uttrykk utløser
5.2Spesialmetoder: `__str__`, `__add__`, `__mul__`
  • kunne gjøre et objekt utskrivbart ved å returnere en formatert tekst fra `__str__`
  • kunne implementere addisjon og multiplikasjon for egne objekter, og alltid returnere en ny instans av klassen
  • kunne begrunne når multiplikasjon skal gi et tall i stedet for et objekt, og skille de to tilfellene med `isinstance`
  • kunne legge sammen to objekter med ulikt antall tall, som polynomer av ulik grad, uten å endre operandene
5.3Arv og `super()`
  • kunne skrive en subklasse som arver metodene til en basisklasse, og bare fylle inn det som er nytt
  • kunne kalle basisklassens konstruktør riktig, som første linje og uten å sende instansen selv
  • kunne overstyre en arvet metode, og forklare hvorfor basisklassen er uendret av det
  • kunne avgjøre om et objekt hører til en klasse eller en av dens subklasser
5.4Stykkvise og diskontinuerlige funksjoner
  • kunne oversette en stykkvis definert funksjon fra klammeparentes til betinget logikk, med grensene på riktig side
  • kunne skrive den generelle stykkvise klassen der funksjonsverdier og grenser gis som lister
  • kunne kontrollere en stykkvis funksjon ved å regne ut verdien i nøyaktig grensepunktene
  • kunne forklare hvorfor en betinget funksjon må kalles ett punkt av gangen, og hva det vektoriserte alternativet gjør
5.5DRILL — Klasser med spesialmetoder
  • kunne gå fra oppgavetekst til ferdig klasse ved å følge en fast oppskrift på sju steg
  • kunne avgjøre hvilken spesialmetode hvert krav i oppgaveteksten peker på, og skrive den i sensors korte stil
  • kunne skrive `__add__` og `__mul__` slik at de gir en ny instans, og begrunne når multiplikasjon i stedet skal gi et tall
  • kunne løse del b av oppgaven: instansiere klassen, kontrollere den med en testfunksjon og plotte den
5.PPrøver til del 5: Klasser med spesialmetoder
  • kunne skrive en funksjonsklasse der konstruktøren tar det som er fast og kallmetoden det som varierer
  • kunne gi et objekt tekst og aritmetikk med spesialmetoder, og alltid returnere en ny instans fra en aritmetisk metode
  • kunne bygge en subklasse som regner om parametrene sine og sender dem videre til basisklassen
  • kunne løse en flerdelt klasseoppgave under tidspress, med testfunksjon og plott

6Numeriske metoder som kodemønstre

6.1Numerisk derivasjon, integrasjon og nullpunkt
  • kunne skrive den numeriske deriverte som funksjon med sentrert differanse og en fornuftig standard steglengde
  • kunne vise at en metode konvergerer, ved å regne feilen mot det eksakte svaret for flere steglengder og lese av faktoren mellom radene
  • kunne skrive trapesmetoden med riktige vekter på endepunktene og riktige summegrenser
  • kjenne til Newtons metode, sekantmetoden og biblioteksløseren, med stoppkriterium og riktig innpakning av funksjonen
6.2Differenslikninger
  • kunne sette opp tabellene for en differenslikning, sette startverdien og fylle resten i løkke uten å bomme på antallet
  • kunne avgjøre hvilken av to koblede likninger som må oppdateres først, og begrunne det ut fra indeksene
  • kunne skrive simuleringsfunksjonen som returnerer begge tabellene, og plotte dem mot tid og mot hverandre
  • kunne kontrollere en simulering ved å regne ut likevekten for hånd eller halvere steglengden
6.3DRILL — Differenslikninger
  • kunne gjennomføre løsningsoppskriften for differenslikninger på sju steg, uansett hvilken innpakning modellen har
  • kunne avgjøre på et blikk om oppdateringsrekkefølgen er kritisk, og begrunne svaret ut fra likningene
  • kunne skrive plott-deloppgaven med tidsakse, forklaring og navngitte akser, og beskrive figuren i ord
  • kunne bruke bevaringssjekk og likevektsregning som kontroll uten fasit
6.PPrøver til del 6: Numeriske metoder som kodemønstre
  • kunne skrive forlengs og sentrert differanse, både som funksjon med default-steg og som kallbar klasse
  • kunne avgjøre om oppdateringsrekkefølgen i et koblet system er kritisk, og begrunne svaret ut fra likningene
  • kunne løse en likning numerisk med Newtons metode, sekantmetoden og et ferdig verktøy, og kontrollere svaret
  • kunne løse en flerdelt eksamensoppgave der simulering, likevektsregning og plott inngår

7ODE-løsere og ODESolver-hierarkiet

7.1ODE-løser som funksjon: forward Euler
  • kunne skrive en løser for et initialverdiproblem som en funksjon som tar høyresiden, sluttiden, antall steg og startverdien, og returnerer tidspunktene og løsningen
  • kunne begrunne hvorfor N steg gir N+1 punkter, og plassere startverdien før løkka
  • kunne måle nøyaktigheten ved å halvere steglengden, og gjenkjenne at forlengs Euler har orden 1 og Heun orden 2
  • kunne bytte oppdateringsformel til baklengs Euler eller Heun uten å endre resten av mønsteret
7.2Det utleverte ODESolver-hierarkiet: bruke ForwardEuler og RungeKutta4
  • kunne løse en skalar differensiallikning med det utleverte løser-hierarkiet i tre kall: instansiering, initialbetingelse og solve
  • kunne lese den utleverte modulen og peke ut argumentrekkefølgen i høyresiden, hva solve tar imot og hva den returnerer
  • kunne begrunne valget mellom en metode av orden 1 og en av orden 4 ut fra målt feil og antall funksjonskall
  • kunne kjenne igjen den eldre varianten av grensesnittet og skrive om et program fra den til den nye
7.3ODE-systemer: pakke ut u og plotte komponentene
  • kunne skrive høyresiden for et ODE-system: pakke ut tilstandsvektoren, regne ut hver derivert og returnere dem som en liste i samme rekkefølge
  • kunne hente ut komponentene av løsningen som kolonner og forklare forskjellen på en kurve og et øyeblikk
  • kunne lagre modellparametre i en klasse med `__call__` og skrive om en andreordens likning til et system
  • kunne plotte komponentene med navn og legende, og beskrive figuren presist i ord
7.4Subklasse av ODESolver: skriv `advance`
  • kunne utvide et ferdig løser-hierarki med en ny metode ved å arve alt og skrive bare den ene metoden som gjør ett tidssteg
  • kunne bruke løserens egne verdier for høyreside, løsning, tid, stegnummer og steglengde inne i den metoden
  • kunne gi en subklasse egne parametre uten å miste oppsettet fra klassen den arver fra
  • kunne implementere en implisitt metode der hvert tidssteg løser en likning numerisk
7.5DRILL — ODE-oppgaver med roterende innpakning
  • kunne oversette en modell med flere størrelser til en høyreside med utpakking og returliste, uansett hvilken innpakning oppgaven bruker
  • kunne sette opp og kjøre det utleverte løserhierarkiet, og pakke ut komponentene riktig før plottet
  • kunne skrive en egen løser som funksjon og en ny metode som subklasse, inkludert den implisitte varianten med nullpunktsløser
  • kunne finne og rette de fem feilene som koster mest, og bruke fornuftssjekker når det ikke finnes noen fasit
7.PPrøver til del 7: ODE-løsere og ODESolver-hierarkiet
  • kunne skrive en ODE-løser som funksjon fra bunnen, med riktig telling av skritt og punkter
  • kunne bruke det utleverte hierarkiet på en skalar likning og på et system, og pakke ut komponentene riktig
  • kunne løse en tipoengsoppgave med høyreside, løsning, plott og fornuftssjekk under tidspress
  • kunne implementere en ny ODE-metode som subklasse, både eksplisitt og implisitt med nullpunktsløser

8Fillesing og datastrukturer

8.1Fillesing til nøstet dictionary
  • kunne lese en tekstfil linje for linje med `with open` og dele hver linje i felt med riktig separator
  • kunne bygge en nøstet ordbok fra fila, med typekonvertering og med den indre ordboken opprettet før innsetting
  • kunne hoppe over en header-linje med `readline()` og bruke kolonnenavnene som feltnavn
  • kunne begrunne hvorfor en ordbok slår en liste når data skal slås opp på navn eller ID
8.2Filskriving, filtrering og fast-bredde-felt
  • kunne skrive en nøstet ordbok til fil med riktig separator, valgfri header-linje og linjeskift på hver linje
  • kunne filtrere en ordbok ved å bygge og returnere en ny, uten å endre argumentet
  • kunne forklare hva aliasing er, og hvorfor `ny = data` ikke er en kopi
  • kjenne til fast-bredde-lesing med posisjonsskiving, og hva sensor faktisk gir uttelling for der
8.3DRILL — Fillesing til nøstet dict med filtrering
  • kunne gjennomføre løsningsoppskriften for fillesingsoppgaven på seks steg, uansett hvilken innpakning dataene har
  • kunne skrive den tredelte eksamensbesvarelsen — les til nøstet ordbok, skriv struktur til fil, filtrer og returner en ny ordbok
  • kunne aggregere per ytre nøkkel og gruppere flere rader i en liste, med akkumulatoren nullstilt på rett sted
  • kunne finne og rette de fire feilene som koster mest: separator, header, mutasjon av argumentet og manglende linjeskift
8.PPrøver til del 8: Fillesing og datastrukturer
  • kunne lese en tekstfil til en nøstet ordbok med riktig separator, rensing og typekonvertering
  • kunne hente feltnavnene fra en header-linje, og kjenne igjen feilmeldingen som kommer når linja ikke ble hoppet over
  • kunne skrive en datastruktur tilbake til fil og filtrere den uten å endre det som ble sendt inn
  • kunne løse en flerdelt fillesingsoppgave der gruppering, aggregering, filtrering og skriving inngår

9Eksamenstrening

9.1Midtveis-simulering: 20 flervalg
  • kunne gjennomføre en komplett midtveisprøve på tid: 20 flervalgsspørsmål i 120 minutter, uten å kjøre koden
  • kunne spore et Python-program mekanisk og skrive utskriften tegn for tegn, med riktige løkkegrenser, indekser og utskriftsdetaljer
  • kunne avgjøre hvilken feil et program utløser først, og om en løkke terminerer eller går uendelig
  • kunne bruke poengsummen som et kart over hvilke kapitler du bør lese om igjen
9.2Avsluttende øvingseksamen 1 — epidemi-innpakning
  • kunne disponere et firetimers eksamenssett: 16 poeng flervalg på en halvtime, og 59 poeng kodeskriving på resten
  • kunne skrive de fem kjernemønstrene fra bunnen uten å kjøre koden — rekke med testfunksjon, klasse med spesialmetoder, differenslikning, ODE-system med det utleverte hierarkiet, og fillesing til nøstet dictionary
  • kunne vurdere egen besvarelse mot poenglistene og se hva som gir uttelling selv når koden ikke er helt riktig
  • kunne gjengi de faste mekaniske detaljene ved eksamenen, blant annet at siste oppgave er sensors poengfelt og ikke skal besvares
9.3Avsluttende øvingseksamen 2 — mekanikk/nervecelle-innpakning med subklasse
  • kunne disponere et firetimers eksamenssett: 14 poeng flervalg på en halvtime, og 61 poeng kodeskriving på resten
  • kunne skrive de tyngste mønstrene fra bunnen uten å kjøre koden — stykkvis klasse med spesialmetoder, rekurrent rekke med testfunksjon, ODE-system med parametere, og en ny løsermetode som subklasse
  • kunne skille mellom en programmeringsfeil og en egenskap ved metoden eller modellen, og begrunne skillet
  • kunne vurdere egen besvarelse mot poenglistene og se hva som gir uttelling selv når koden ikke er helt riktig
Tilbake til IN1900 Introduksjon til programmering med vitenskapelige anvendelser