#Oppgave 1
#Riktig svar: 81

#Oppgave 2
a = range(100)
b = range(100)

c=0
for i in range(1, 100):
    c += b[i] - a[i-1]

print(c)

#Riktig svar: 99

#Oppgave 3
#Riktig svar: [4,1,2,3]

#Oppgave 4
x = {}
for k in range(-5, 6):
    x[k] = 2**k

print(x[-1] * x[1])

#Riktig svar: 1

#Oppgave 5
#Riktig svar: GCAACTG

#Oppgave 6
from math import exp
class FClass:
    def __init__(self, ksi):
        self.ksi = ksi

    def __call__(self, s):
        ksi = self.ksi
        if ksi!=0:
            ans = (1+ksi*s)**(ksi+1)
        else:
            ans = exp(-exp(-s))
        return ans

    def F(self, x):
        return x**2

F = FClass(1)
print(F(1))

#Riktig svar 4.0

#Oppgave 7
#Riktig svar: svaralternativ 1 og 4

#Oppgave 8
import numpy as np

def larger(f,g):
    x = np.linspace(0,1,1001)

    for x_ in x:
        if g(x_) > f(x_):
            return False

    return True


def f(x):
    return x**2

def g(x):
    return 0

print(larger(f,g))

#Oppgave 9
# Med f(x) = x+1 og g(x) = x er korrekt (expected)
# svar True, siden f(x) ¡Ý g(x) ?penbart holder for alle x
# Med f(x) = x-0.5 og g(x) = (x-0.5)**2 er korrekt
# (expected) svar False, siden f.eks. f(x) < g(x) for x=0.

def test_larger():
	f = lambda x: x+1
	g = lambda x: x
	expected = True
	computed = larger(f,g)
	assert expected==computed, 'Feil oppdaget!'

	f = lambda x: x -0.5
	g = lambda x: (x-0.5)**2
	expected = False
	computed = larger(f,g)
	assert expected==computed, 'Feil oppdaget!'

test_larger()

#Oppgave 10

def s(n):
    val = 0
    for k in range(2,n+1):
        val += (k-1)/k
    return val


print(s(2))


#Oppgave 11
# L?sningsforslag A:
def test_s():
	expected = [0, 1/2, 1/2 + 2/3]
	computed = [s(1), s(2), s(3)]

	for e in zip(expected, computed):
		assert e[0]==e[1], 'Feil oppdaget!'

# L?sningsforslag B:
def test_s():
    expected = 0.0
    computed = s(1)
    assert expected==computed, 'Feil oppdaget!'

    expected = 1/2
    computed = s(2)
    assert expected==computed, 'Feil oppdaget!'

    expected = 1/2 + 2/3
    computed = s(3)
    assert expected==computed, 'Feil oppdaget!'

#Oppgave 12
a = {1:2, 2:3, 3:4, 4:1}
b = {4:5, 5:6, 6:1}

print(b[a[3]] == 1)   #False
print((abs(len(b)-3)) == 0)  #True
print(a[3] == b[4])   #False
print([a[k] for k in a] == [2,3,4,1])  #True
#print(a[0] == 1:2)  #Gir feilmelding, dvs ikke True
print(a[1]+a[2] == b[4])   #True


#Oppgave 13
class PiecewiseConstant:
    def __init__(self, y, a):
        self.y = y
        self.a = a

    def __call__(self, x):
	    n = len(self.y); a = self.a; y = self.y
	    for i in range(n):
	        if a[i] <= x < a[i+1]:
	            return y[i]
	    if x == a[n]:
	        return y[n-1]

#Oppgave 14

#Alt 1, bruker formel i oppgaven direkte
def integrate(f,a,b,n):
    h = (b-a)/n
    integral = 0.5*h*(f(a)+f(b))

    for i in range(1,n):
        integral += h*f(a+i*h)

    return integral

#Alt 2, bruker numpy og linspace
def integrate_v2(f,a,b,n):
    x = np.linspace(a,b,n+1)
    h = (b-a)/n

    integral = 0.5*h*(f(a)+f(b))

    for i in range(1,n):
        integral += h*f(x[i])

    return integral

def f(x):
    return x**3

print(integrate(f,0,2,100))
print(integrate_v2(f,0,2,100))



#Oppgave 15
from math import sin, cos

class SinCos:
	def __init__(self, w):
		self.w = w

	def __call__(self, x):
		fval = sin(self.w*x) + cos(self.w*x)
		return fval

	def __str__(self):
		w = self.w
		s = 'sin(%g x) + cos(%g x)' % (w, w)
		return s

# Example of use:
g = SinCos(3.1415)
print('g(1, 3.1415) = %g' % g(3.1415))
print(g)


#Oppgave 16
#first create a file to read (not part of solution!):
outfile = open('hovedsteder.txt','w')
file_content ="""Norge		     Oslo
USA 		     Washington, D.C.
Frankrike	   Paris
Brunei	     Bandar Seri Begawan
Malaysia	   Kuala Lumpur
Chile	       Santiago
"""

outfile.write(file_content)
outfile.close()

#Here comes the solution:
def read_file(filename):
    infile = open(filename,'r')

    data = {}

    for line in infile:
        words = line.split()
        country = words[0]
        capital = ' '.join(words[1:])
        data[country] = capital

    return data


hovedsteder = read_file('hovedsteder.txt')

while True:
    land = input('Tast inn et land: ')
    if land == 'stopp':
        break
    if land in hovedsteder:
        print(hovedsteder[land])
    else:
        print('Vet ikke hovedstaden')


#remove the file we created (not part of solution):
import os
os.remove('hovedsteder.txt')

#Oppgave 17
import sys
from math import *
import matplotlib.pyplot as plt

# Solution for exam: get the expression from command line
#expression = sys.argv[1]

#Here we cheat to ensure the program runs:
expression = 'sin(x)+x**2'

# Convert expression to Python function
def f(x):
	val = eval(expression)
	return val

# Plot function for x in interval [0,1]
h = 1/100.0
xval = [i*h for i in range(101)]
yval = [f(x) for x in xval]
plt.plot(xval, yval, 'b-')
plt.show()

#Oppgave 18

import ODESolver
import numpy as np
import matplotlib.pyplot as plt

class ProblemSIR:
    def __init__(self, alpha, beta, gamma, S0, I0, R0, T):
        self.alpha = alpha
        self.beta = beta
        self.gamma = gamma
        self.S0 = S0
        self.I0 = I0
        self.R0 = R0
        self.T = T

    def __call__(self, u, t):
        alpha, beta, gamma = self.alpha, self.beta, self.gamma
        S, I, R = u
        dS = -alpha*S*I+beta*R
        dI = alpha*S*I-gamma*I
        dR = -beta*R+gamma*I
        return [dS,dI,dR]


class SolverSIR:
    def __init__(self, problem, dt):
        self.problem, self.dt = problem, dt

    def solve(self, method=ODESolver.RungeKutta4):
        self.solver = method(self.problem)
        ic = [self.problem.S0, self.problem.I0, self.problem.R0]
        self.solver.set_initial_condition(ic)
        n = int(round(self.problem.T/float(self.dt)))
        t = np.linspace(0, self.problem.T, n+1)
        u, self.t = self.solver.solve(t)
        self.S, self.I, self.R = u[:,0], u[:,1], u[:,2]

    def plot(self):
        t = self.t
        plt.plot(t,self.S,'b',t,self.I,'r',t,self.R,'g')

        #reduce alpha by 10%
        self.problem.alpha *= 0.9

        self.solve()
        plt.plot(t,self.S,'b--',t,self.I,'r--',t,self.R,'g--')

        #reset alpha to original value, then increase by 10%
        self.problem.alpha *= 1.1/0.9


        self.solve()
        plt.plot(t,self.S,'b--',t,self.I,'r--',t,self.R,'g--')

        plt.show()


problem = ProblemSIR(alpha=0.005, beta=1e-5, gamma=0.002, S0=100, I0=1, R0=0, T=50)
solver = SolverSIR(problem, dt=0.2)
solver.solve()
solver.plot()