#######grunnleggende programmering:

#kopier inn linje for linje i et interaktivt python-vindu

#2 globale og lokale variable
def akselrasjon_fra_Newton2(F):
    global masse
    masse += 10
    a = F/masse
    F += 5.
    return a


masse = 100. #kg
F = 10. #N
print(masse,akselrasjon_fra_Newton2(F),masse)

print(a)

print(F) #hvorfor blir ikke F=15 her??? --> global vs local


#3

lst = []
lst.append(5)
print(lst)
lst.append([10,11])
print(lst)

lst = []
lst.append(5)
print(lst)
lst += [10,11]
print(lst)


#4

for i in range(5): #siste tallet blir ikke med
    print(i)

for i in range(4,10,2): #siste tallet blir ikke med
    print(i)

lst = [3,8,10]
for i in lst:
    print(i)

for i in [10,12,14]:
    print(i)

#5
# if og while, pass p? rekkef?lge av logiske operasjoner med paranteser

x, y, z, step = -2, 3, 3, 110

if ((x <= 0 and y>=2 and y<=4 and z>=2 and z<=4) or (x >= 0 and y>=0 and y<=2 and z>=0 and z<=2)) and (step > 100):
    print('passed test')

while(((x <= 0 and y>=2 and y<=4 and z>=2 and z<=4) or (x >= 0 and y>=0 and y<=2 and z>=0 and z<=2)) and (step > 100)):
    x += 0.1
    print(x)





###########numpy

import numpy as np

np.sqrt(5.)

vect = np.array([2,3,4])
np.linalg.norm(vect) #bruk 1-dim array som en matematisk vektor
vect2 = np.array([0,2.5,3])

np.dot(vect,vect2) #bruk 1-dim arrays som matematiske vektorer, dot-produkt


fgrav = vect
ffric = vect2
mass = 100.
akselrasjon = (fgrav+ffric)/mass #adder vektorer som i matematikk
akselrasjon


rvec =  np.array([10,20,5])
e_r = ??? #enhetsvekor med samme retning som rvec men lengde 1
(e_r = rvec/np.linalg.norm(vect))

##arrays:

arr = np.zeros(10)
arr

arr = np.ones([3,4])
arr

np.arange(4,10,2) #som range() men lag numpy array

np.linspace(0,10,20) # numpy array med 20 elementer, f?rste 0, siste 10, like stor avstand


longvect = np.array([3,5,8,23,33,11,77,5,33,2]) #liste --> numpy array
longvect[4]
longvect[0:3] #frem til siste, men UTEN den siste
longvect[5:] #fra og med 5 og utover

np.where(longvect == 5) #en tuppel med en numpy-array som f?rste element

np.where(longvect == 5)[0] #tar ut f?rste element = numpy array med alle treff

np.where(longvect == 5)[0][0] #tar ut f?rste element av array-en, dvs. f?rste treff

np.where(longvect == 5)[0][1] #tar ut andre element av array-en, dvs. andre treff

longvect.min(), longvect.max() # minste og st?rste verdier i array

longvect.argmin(), longvect.argmax() # indeksen til minste og st?rste verdier i array


##flere dim
arr = np.zeros([4,4]) ## 2-dim array = som matematisk matrise
# hvis du er usikker p? rad/kolonne, gj?r f?lgende test:
arr[0,:] = 1.
arr[1,:] = 4.
arr[2,:] = np.arange(0,4)
arr[3,:] = arr[:,1] # fjerde rad  = andre kolonne

arr[0:2,0:2] = 2.

np.where(arr == 2)




####vektorisering

xpos = np.array([12.,9.,44.,23.,3.,8.,10.,49.,32.,44.])
vx = np.array([0.2,0.9,0.3,1.8,2.8,0.1,0.7,1.2,0.3,2.1])
dt = 1.

##
for i in range(np.size(xpos)): #loop over hele arrayen (size gir deg st?rrelsen)
    xpos[i] += vx[i]*dt #oppdater hvert enkelt element

xpos += vx*dt # dette er helt tilsvarende loopen, men MYE raskere, likningen utf?res for alle elementer separat akkurat som i for-loopen. Merk at dette er en matematisk vektor-likning. Du kan skrive vektorlikninger som i matematikk

xpos

xpos + 1. #her adderes 1 til alle elementene i vektoren

4*xpos # ALLE elementene i vektoren ganges med 4 (som n?r du skriver 4*vektor i matematikk)

xpos**2

np.sqrt(xpos) #roten taes av alle elementene i vektoren (dette er ikke lov i matematikk)

dt = np.arange(0,10)*0.1 #forskjellige tidssteg for forskjellige partikler
xpos += vx*dt #her ganges elementene en for en

#akkurat det samme gjelder for matriser og arrayer av enhver dimensjon. Alle operasjoner som utf?res p? arrayen blir utf?rt separat p? hvert element.
arr = np.zeros([4,4])
arr[0,:] = 1.
arr[1,:] = 4.
arr[2,:] = np.arange(0,4)
arr[3,:] = arr[1,:]

arr
arr**2


##
for i in range(np.size(xpos)):
    if xpos[i] >= 25.:
        vx[i] = -vx[i]

#disse to linjene gj?r det samme som loopen men mye raskere:
ii = np.where(xpos >= 25.)[0] #lag en array av alle relevante indekser
vx[ii] = -vx[ii] # utf?r vektoroperasjonen kun p? indekser lagret i arrayen ii


xpos >= 25 #array av true og false

np.where(xpos >= 25.) #tuple

np.where(xpos >= 25.)[0] #hent ut arrayen fra tuple

xpos[ii]

mass = 10.
np.sum(0.5*mass*vx**2)  #meget kraftig summering, np.sum summerer sammen alle elementene i vektoren (f?rst blir alle elementene i vx kvadrert hver for seg, s? blir alle elementene ganget med 0.5*mass, og til slutt blir alle elementene summert sammen)






#KLASSER???? Ikke viktig i dette kurset. Hvis du kan programmere med klasser og lage pene koder der det er relevant s? gir det noe ekstrapoeng for fin kode. Men ikke brukt tid p? dette!

#HUSK ? kommentere kodene!

# Nevn
# Numerisk kompendium p? semesterside
# NUMBA?? Se numerisk kompendium men ogs? eget Jupiter-NB p? semesterside for prosjekt



Tilbakemeldinger, kun for dere som var fysisk p? kurset:
https://nettskjema.no/a/213937