Lab3

Smiley

I filen smiley.py ligger det en funksjon for å tegne et smilefjes. Last ned filen (vi trenger ikke endre på den for denne oppgaven, men les litt i den og forstå hva den gjør).

I tillegg kan du opprette filen smiley_grid.py i samme mappe. Begynn med å kopiere inn dette programmet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# smiley_grid.py
from smiley import draw_smiley

def draw_smiley_line():
    for x in [0, 50, 100]:
        draw_smiley(canvas, x, 0, 100)

if __name__ == '__main__':
    from uib_inf100_graphics.simple import canvas, display
    draw_smiley_line()
    display(canvas)

Når du kjører filen smiley_grid.py skal du se tre smilefjes delvis oppå hverandre.

Del A

Akkurat nå ligger smilefjesene oppå hverandre. Det hadde vært bedre om det var nok plass slik at smilefjesene ikke kommer oppå hverandre, men i stedet ligger inntil hverandre. Endre x -verdiene i listen på linje 5 slik at at smilefjesene ikke kommer oppå hverandre, men ligger helt inntil hverandre.

Del B

Vi ønsker å kunne enkelt justere hvor store smilefjesene er.

• Legg til size som en parameter i draw_smiley_line -funksjonen.
• Benytt size som argument når du gjør kallet til draw_smiley -funksjonen på linje 6.
• I funksjonskallet på linje 10, benytt 60 som et argument for size

Når du kjører programmet nå, skal det se slik ut:

Del C

Å nei! Smiley’ene ligger ikke inntil hverandre lengre! Vi må visst regne ut x-posisjonene basert på størrelsen.

• Uten å fjerne for-løkken: endre verdiene i listen av x-verdier slik de regnes ut på bakgrunn av størrelsen i stedet for å være helt faste verdier. Første x-verdi er 0, andre x-verdi er forskjøvet med like mye som størrelsen og så videre.

[0 * size, 1 * size, 2 * size]

Når du er ferdig skal funksjonkall med ulike verdier for størrelsen gi rader med smilefjes som ligger kant-i-kant uansett. Illustrasjonen under viser kjøringer av programmet der det eneste som er endret er størrelsesverdien vi gir som argument på linje 10.

Del D

Vi ønsker nå justere hvor mange smilefjes vi skal tegne.

• Legg til n som et andre parameter i draw_smiley_line -funksjonen slik at parametrene nå er både størrelse og antall.
• I stedet for at for-løkken går over en fast liste med verdier, la den gå gjennom et range-objekt range(n). Antall iterasjoner løkken utfører blir da bestemt av n.
• Endre navnet på iteranden fra x til i, siden iteranden nå ikke lengre representerer en x-verdi, men snarere en «indeks» som forteller hvilken iterasjon løkken har kommet til.
• På en egen linje inne i løkken, opprett variabelen x og regn ut en passende verdi for den.
• I funksjonskallet til draw_smiley_line må du legge til et argument for antall fjes som skal tegnes, for eksempel 4.

x = i * size

Når du er ferdig skal funksjonskall med ulike verdier for n tegne en rad med n smilefjes som ligger kant-i-kant. Illustrasjonen under viser kjøringer av programmet der det eneste som er endret er argumentet for n (viser verdiene 0, 1, 2, 3, 4, 5).

Del E

Vi ønsker nå å justere hvor smilefjesene tegnes på y-aksen

• Legg til y som den første parameteren i draw_smiley_line -funksjonen, slik at parametrene nå er (y, size, n).
• Benytt denne parameteren når du kaller på draw_smiley

Når du er ferdig, kan du bytte ut hele if __name__ == '__main__' -blokken i programmet ditt med denne:

if __name__ == '__main__':
    from uib_inf100_graphics.simple import canvas, display

    draw_smiley_line(0, 60, 5)
    draw_smiley_line(60, 100, 3)
    draw_smiley_line(160, 60, 5)

    display(canvas)

Kjør programmet ditt og se følgende bilde:

Del F

I filen smiley_grid.py, opprett en funksjon draw_smiley_grid med parametre size og n. Funksjonen skal tegne et rutenett med smilefjes, der size er størrelsen til ett smilefjes, og n er antall smiljefjes i begge retninger.

Når du er ferdig, kan du bytte ut hele if __name__ == '__main__' -blokken i programmet ditt med denne:

if __name__ == '__main__':
    from uib_inf100_graphics.simple import canvas, display
    draw_smiley_grid(70, 5)
    display(canvas)

Om du har gjort alt riktig kan du kjøre programmet ditt og se følgende bilde:

Oppdelt linjestykke

Del A: Finn endepunkter for et enkelt segment

Et linjestykke langs x-aksen begynner i et punkt \(x_{\text{lo}}\) og slutter i et punkt \(x_{\text{hi}}\). Vi ønsker å klippe opp linjestykket i \(n\) like store biter. Til slutt vil vi vite hvor bit nummer \(i\) begynner og slutter.

For eksempel, hvis

• \(x_{\text{lo}} = 50\)
• \(x_{\text{hi}} = 150\)
• \(n = 4\)
• \(i = 1\)

da er svaret vi leter etter \((75, 100)\). Se illustrasjon:

I filen split_line.py lag en funksjon get_endpoints. Denne funksjonen skal ha fire parametere: i, n, x_lo og x_hi. Parametrene x_lo og x_hi er flyttall og definerer linjestykket som nevnt ovenfor. Parametrene i og n er begge heltall. Funksjonen skal returnere start- og sluttpunktet for segmentet med indeks i når vi deler hele linjen i n like store deler. For eksempel: get_endpoints(1, 4, 50.0, 150.0) skal returnere 75.0, 100.0, og get_endpoints(3, 4, 50.0, 150.0) skal returnere 125.0, 150.0.

def foo(bar):
    a = 2 * bar
    b = 3 * bar
    return a, b

x, y = foo(5)

print(x) # 10
print(y) # 15

Test deg selv:

def almost_equals(a, b):
    return abs(a - b) < 0.0000000001

print('Testing get_endpoints... ', end='')
start, end = get_endpoints(1, 4, 50.0, 150.0)
assert almost_equals(75, start)
assert almost_equals(100, end)

start, end = get_endpoints(3, 4, 50.0, 150.0)
assert almost_equals(125, start)
assert almost_equals(150, end)

start, end = get_endpoints(0, 3, -30, 60)
assert almost_equals(-30, start)
assert almost_equals(0, end)
print('OK')

Del B: Lag et interaktivt program

I samme fil (split_line.py) utvid koden med en if __name__ == '__main__' -blokk slik at når du kjører programmet så blir brukeren bedt om å:

• oppgi \(x_{\text{lo}}\)
• oppgi \(x_{\text{hi}}\)
• oppgi tallet \(n\); antall biter linjestykket skal deles opp i.

Deretter skriver programmet ditt ut n linjer, der hver linje består av to tall som representerer et linjestykke. Benytt funksjonen fra del A for å finne punktene (du skal altså ikke gjøre alt på nytt, men i stedet kalle på funksjonen vi allerede har skrevet).

Eksempelkøringer skal se sånn ut:

x_lo = 1.0  
x_hi = 7.0
n = 3
1.0 3.0
3.0 5.0
5.0 7.0

x_lo = 0.0  
x_hi = 1.0
n = 4
0.0 0.25
0.25 0.5
0.5 0.75
0.75 1.0

Fargetog

I denne oppgaven skal vi lage en funksjon som tegner et tog med fargede vogner på et uib_inf100_graphics.simple canvas.

PS: Vi er klar over at resultatet ikke egentlig ligner på et tog, men det er gøyere å kalle det et tog enn en rekke med fargede rektangler.

Kun oppgaven under Del A er obligatorisk, men vi anbefaler at du prøver resten også

Forberedelser: Repeter hvordan du går gjennom alle elementene i en samling med strenger: For-løkker over range

Når du leverer denne oppgaven på CodeGrade, vil et skjermbilde av programmet ditt automatisk lastes opp til galleriet, hvor du også kan se dine medstudenter sine besvarelser.

Del A: Tegn et tog med fargede vogner

Vi begynner med den enkleste versjonen av denne oppgaven. I filen color_train.py, lag en funksjon color_train_A(). Denne funksjonen tar inn 4 parametere: canvas, x, y, colors. Funksjonen skal tegne fargede ruter (eller vogner) med en fast størrelse på 15 x 10px (bredde x høyde) etter hverdandre på canvaset. Rekken av vogner skal starte på \((x, y)\) og gå fra venstre til høyre. Fargene er gitt i listen colors.

For eksempel, hvis rekken av farger er ["white", "black", "white"] så skal første vognen (fra venstre) være hvit, andre vognen skal være svart og tredje vognen hvit.

Merk: Du skal ikke kalle på display-funksjonen i samme fil som du skriver funksjonene. For å teste koden, opprett en separat fil color_train_test.py i samme mappe som color_train.py og kopier inn koden du finner under (i Testing-boksen):

from uib_inf100_graphics.simple import canvas, display
from color_train import color_train_A#, color_train_B, color_train_C

colors1 = ['violet', 'indigo', 'blue', 'green', 'yellow', 'orange', 'red']
colors2 = ['black', 'white', 'black', 'white', 'black', 'white']
colors3 = ['#800080', '#8B008B', '#9400D3', 
           '#9932CC', '#8A2BE2', '#9370DB', 
           '#7B68EE', '#6A5ACD', '#483D8B', 
           '#0000FF', '#0000CD', '#00008B', 
           '#000080', '#191970', '#00008B']

color_train_A(canvas, 10, 10, colors1)
color_train_A(canvas, 10, 20, colors2)
color_train_A(canvas, 10, 40, colors3)

display(canvas)

Når du kjører color_train_test.py, skal det tegnes 3 tog på skjermen som vist under:

Del B: Tegn et fargetog med oppgitt høyde og bredde

I denne delen skal vi lage en alternativ funksjon som tegner et tog med en gitt høyde og bredde.

I color_train.py, skriv en funksjon color_train_B() som tar inn 6 parametere: canvas, x, y, width, height og colors. Som color_train_A() skal funksjonen tegne fargede rektangler etter hverandre, men nå skal den totale bredden på toget være width og høyden skal være height. Det betyr at du må regne ut bredden til hver enkelt vogn fra dette.

For å teste koden, i color_train_test.py (fra Del A) legg til disse funksjonskallene rett før display(canvas):

color_train_B(canvas, 50, 195, 300, 10, colors1)
color_train_B(canvas, 50, 150, 150, 30, colors2)
color_train_B(canvas, 50, 180, 50, 15, colors3)

Pass på at du flytter på kommentaren i toppen av test-filen slik at bare color_train_C er kommentert ut. Den må forbli kommentert ut fram til du gjør Del C.

Når du kjører color_train_test.py, skal det tegnes 3 nye tog på skjermen som vist under:

Del C: Tegn et fargetog bare med koordinater

I denne delen skal vi lage enda en ny funksjon color_train_C() som tar inn 6 parametere: canvas, x1, y1, x2, y2 og colors. Funksjonen skal gjøre det samme som i B, men tar nå utgangspunkt i to punkter: \((x_1, y_1)\) og \((x_2, y_2)\). Disse to punktene skal være øvre venstre hjørne og nedre høyre hjørne til det ferdige toget.

For å teste koden, i color_train_test.py (fra Del A) legg til disse funksjonskallene rett før display(canvas):

color_train_C(canvas, 200, 380, 350, 400, colors1)
color_train_C(canvas, 80, 360, 350, 380, colors2)
color_train_C(canvas, 80, 380, 200, 400, colors3)

Hint

Hvis du regner høyde og bredde fra punktene, kan du gjenbruke color_train_B() her.

Når du kjører color_train_test.py, skal det tegnes 3 nye tog på skjermen som vist under:

Befolkningsvekst

I denne oppgaven skal du skrive et program som beregner befolkningsvekst. Programmet skal lese inn tre tall. Først den opprinnelige størrelsen av en populasjon som et heltall, så den årlige veksten som flyttall, også antall år som skal beregnes som et heltall. For hvert år skal programmet skrive ut estimatet av de nye befolkningstørrelsen, rundet ned til nærmeste heltall. Til slutt skal programmet skrive ut totalveksten av startbefolkningen i prosent med to desimalers nøyaktighet (det er ikke nødvendig å skrive ut avsluttende nullere (trailing zeros), man kan med andre ord bruke round() funksjonen).

Kort oppsummert, i filen population_growth.py skriv et program som:

• Ber brukeren om nåværende befolkning, en spesifikk vekstrate og antall år som skal beregnes (se eksempelkøringene for nøyaktig ordlyd).
• Skriver ut én linje per år som beregnes, med antatt befolkning gitt oppgitt vekstrate.
• Skriver ut en linje på slutten som oppgir den totale veksten etter oppgitt antall år i prosent.

For å forenkle testingen, spesifiserer vi her at du alltid skal representere folkemengden som et heltall, selv i mellomregninger. Vi kan jo ikke bare ha et halvt menneske. For å få dette til kan du kalle int() med det utregnede flyttalet som argument. I første eksempelet under er folkemengden etter 1 år: $$1000 + 1000 \times 0.0248 = 1024.8$$ Men vi runder ned til 1024. Det er også 1024 som brukes videre for å beregne neste år, altså: $$1024 + 1024 \times 0.0248 = 1049.4$$ og vi runder ned til 1049.

Eksempelkøringer:

Befolkning: 1000  
Årlig vekstrate (i prosent): 2.48
Antall år: 5
Befolkningen etter 1 år er 1024
Befolkningen etter 2 år er 1049
Befolkningen etter 3 år er 1075
Befolkningen etter 4 år er 1101
Befolkningen etter 5 år er 1128
Total vekst etter 5 år er (i prosent) 12.8

Befolkning: 797510515  
Årlig vekstrate (i prosent): 0.83
Antall år: 3
Befolkningen etter 1 år er 804129852
Befolkningen etter 2 år er 810804129
Befolkningen etter 3 år er 817533803
Total vekst etter 3 år er (i prosent) 2.51

Tegn π

Opprette en fil draw_pi.py og kopier inn dette programmet:

from uib_inf100_graphics.simple import canvas, display
import random

def draw_dot(canvas, x, y):
    canvas.create_oval(x-5, y-5, x+5, y+5, fill='orange')

# Draw a circle in the window
canvas.create_oval(0, 0, 400, 400)

# Highlight a random point on 400x400 canvas
x = random.random() * 400
y = random.random() * 400
draw_dot(canvas, x, y)

display(canvas)

Kjør programmet et par ganger. Sjekk at programmet tegner en liten prikk et tilfeldig sted hver gang programmet kjøres, i tillegg til å tegne en stor sirkel med radius 200 og sentrum i punktet (200, 200).

Del A: tegn mange tilfeldige prikker

Endre koden slik at det ikke bare er én prikk som tegnes, men 1000 tilfeldige prikker. Når du er ferdig skal en kjøring av programmet se omtrent slik ut:

n = 1000
for _ in range(n):
    # Kode for å generere ett tilfeldig punkt og tegne det legges her
    ...

Del B: fargelegg prikkene som er innenfor sirkelen

Endre programmet slik at prikkene som er innenfor sirkelen får en annen farge enn prikkene som er utenfor. Vi sier at en prikk er innenfor sirkelen dersom avstanden fra prikkens sentrum til sirkelens sentrum er mindre enn sirkelens radius, nemlig 200. Sirkelen har sentrum i punktet (200, 200). Når du er ferdig, skal en kjøring av programmet se omtrent slik ut:

• Legg til en parameter for farge i funksjonen som tegner en prikk.
• Bruk en if/else-setning for tegne prikken med enten den ene eller den andre fargen. Betingelsen er at avstanden til sirkelens sentrum (200, 200) er mindre enn 200.
• For å regne ut avstanden mellom to punkter: du kan gjenbruke funksjonen for å beregne avstand fra en tidligere lab, eller du kan regne det ut på nytt.

Del C: tell hvor mange prikker som er innenfor sirkelen

Endre programmet slik at du skriver ut en melding på skjermen som forteller hvor mange av prikkene som er innenfor sirkelen og hvor mange som er utenfor.

# Eksempel som skriver ut tekst på toppen av en firkant
message = 'Carpe diem'
canvas.create_rectangle(100, 180, 300, 220, fill='white')
canvas.create_text(200, 200, text=message, fill='blue')

Del D: finn \(\pi\)

\(\pi\) er definert som en sirkels omkrets delt på sin diameter. Uten å vite nøyaktig hvilken verdi \(\pi\) har, kan matematikere bevise at denne verdien, om vi en vakker dag skulle få vite hva den er, kan brukes for å regne ut en sirkel sitt areal:

$$ A_{\bigcirc} = \pi \cdot r^2 $$

Den beste tilnærmingen vi har til \(\pi\) i skrivende stund inneholder over \(10^{12}\) siffer. I Python har vi en tilnærmingen gitt ved math.pi begrenset til de første 15 siffrene. Det finnes andre moduler som gir oss en bedre tilnærming, men da må vi slutte å bruke float og heller bruke en annen datatype som er i stand til å gi oss høyere presisjon.

Vi har i de forrige deloppgavene tegnet en sirkel med radius \(r = 200\) som befinner seg inne i et kvadratisk lerret med sidelengde \(s = 400\). Vi legger verdiene for r og s inn i formelene for areal av henholdsvis sirkler og kvadrat, og får følgende:

$$A_{\bigcirc} = \pi \cdot r^2 = \pi \cdot 200^2 = \pi \cdot 40\,000$$ $$A_{\square} = s^2 = 400^2 = 160\,000$$

Dersom vi velger et helt tilfeldig punkt inne i kvadratet, vil punktet med viss sannsynlighet \(p\) også havne inne i sirkelen. Fordi sirkelen er omsluttet av kvadratet på alle kanter, ser vi at \(p\) er gitt ved forholdet mellom arealet av sirkelen og kvadratet:

$$ p = \frac{A_{\bigcirc}}{A_{\square}} = \frac{\pi \cdot 40\,000}{160\,000} = \frac{\pi}{4}$$

Det følger at hvis vi klarer å finne ut hva \(p\) er for noe, trenger vi bare multiplisere tallet med 4 for å finne \(\pi\). Det leder oss til følgende algoritme:

1. Gjett et tilfeldig punkt mellom (0, 0) og (400, 400)
2. Sjekk om punktet er innenfor eller utenfor sirkelen
3. Gjenta steg 1-2 tilstrekkelig mange ganger, og tell opp hvor ofte det tilfeldige tallet havnet inne i eller utenfor sirkelen. Da bli forholdet mellom antall treff i sirkel og totalt antall genererte punkter tilnærmet lik \(p\). La oss kalle tilnærmingen \(\hat{p}\). $$\frac{\text{antall prikker i sirkel}}{\text{antall prikker totalt}} = \hat{p} \approx p$$
4. Gang opp \(\hat{p}\) med 4 for å finne en tilnærmet verdi for \(\pi\).

For å gjennomføre algoritmen, gjenstår det altså kun å regne ut \(\hat{p}\), multiplisere med fire og skrive ut estimatet på skjermen. Når du er ferdig, skal en kjøring av programmet se omtrent slik ut:

PS: For å få en bedre tilnærming av \(\pi\) kan du øke antall tilfeldige prikker, for eksempel er antallet prikker økt til \(10\,000\) i skjermbildet over. Når du leverer oppgaven på CodeGrade ber vi imidlertid om at du begrenser antall prikker til \(1\,000\) slik at maskinen ikke blir overbelastet.