Mathesis Wiki

Hallöle wir haben heute erstmal das Nagel-Schreckenberg-Modell grafisch dargestellt mit Matpotlib und dann uns in Matplotlib animations angefangen reinzuarbeiten.

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

p=0.25
t=20




#fahrtrichtung rechts
#naechstes mal zeitliche implementierung





def kreisverkehr():
    a=np.array([0,0,0,0,3,0,0,0,2,4,0,0,1,2,0,0,0,0,5])
    return a


def update (a,p,t):
    
#erster zwischenschritt: 
    for i in range(len(a)):
        if a[i]>0 and a[i]<5:
            b[i]=np.copy(a[i])+1


#zweiter zwischenschritt:
    #plan für jede stelle
    #zahl mit differenz vergleichen
    #falls differenz kleiner als zahl 
    #zahl=differenz

    for i in range(len(a)):
        if b[i]>=1 and b[(i+1)%len(a)]==0:
            #differenzmessen
            d=1
            while b[(i+d)%len(a)]==0:
                d=d+1

            if b[i]>=d:
                c[i]=d-1
            else:
                c[i]=np.copy(b[i])
                
        elif b[i]>=1 and b[(i+1)%len(a)]!=0:
            c[i]=1  


#dritter zwischenschritt: 

    for i in range(len(a)):
        if c[i]<=1:
            g[i]=np.copy(c[i])
        else:
            if random.random() < p:
                g[i]=np.copy(c[i])-1
            else:
                g[i]=np.copy(c[i])
                

#vierter zwischenschritt: 
    e=np.zeros(len(a))
    
    for i in range(len(a)):
        if g[i]>0:
            #e[i]=0
            e[(i+int(g[i]))%len(a)]=g[i]
    
    return e
    
 
    


a=kreisverkehr()
e=np.copy(a)
b=np.copy(a)
c=np.copy(a)
g=np.copy(a)

print(a)


#M=np.array([a,a])
#M = np.array([ [3.4, 8.7, 9.9], 
#               [1.1, -7.8, -0.7],
 #              [4.1, 12.3, 4.8]])
 
M = np.zeros((t,len(a)))
M[0]=a 
    
for k in range(1,t):

    
    
    a=np.copy(e)
    b=np.copy(e)
    c=np.copy(e)
    g=np.copy(e)
    
    e=update(a,p,t)

    M[k]=e    
        
    
    #print(a,'a')
    #print(b,'b')
    #print(c,'c')
    #print(g,'g')


    #M=np.append(M,e,axis=1)
print(M)

plt.imshow(M)
plt.legend()



#print(M)

Arbeit von Leroy und Hanna: Wir haben angefangen mit dem Game of Life. Um die Regeln vom Game of Life umzusetzen, brauchen wir die Matrizenmultiplikation. Der Code generiert eine random-Matrix(quadratisch) mit vorheriger angegebener Zeilen-/Spaltenanzahl. Die zweite Matrix ist eine Tripleeinheitsmatrix mit der selben Zeilen-/Spaltenanzahl wie die erste Matrix. Im dritten Schritt sollen die Matrizen multipliziert werden. Dieser Schritt funktioniert noch nicht.

Ziel für die nächste Woche: Matrizenmultiplikation soll funktionieren. Weiter an den Regel vom Game of Life arbeiten.

import random
import numpy as np


# Größe der Matrix
#zeilen = int(input('Gib eine Zahl ein: '))
#spalten = zeilen

zeilen = 10
spalten = zeilen

# Die Matrix wird zufällig mit Nullen und Einsen gefüllt
M = np.zeros ((zeilen,spalten))
 
def Matrix_füllen():
    for i in range(0, zeilen):
        for j in range(0, spalten):
            if random.random() < 0.5:
                M[(i,j)]= 1
            else:
                M[(i,j)]= 0
    return M        


Matrix_füllen()      
print (M)

D = np.zeros ((zeilen,spalten))
def Tripleeinheitsmatrix():
    for i in range(0, zeilen):
        for j in range(0, spalten):
            if i==j:
                D[(i,j)] = 1
            else:
                D[(i,j)] = 0
                
    for i in range(0, zeilen):
        for j in range(0, spalten):
            if i==(j+1):
                D[(i,j)] = 1
    for i in range(0, zeilen):
        for j in range(0, spalten):
            if j==(i+1):
                D[(i,j)] = 1
                
    D[0,D.shape[1]-1] = 1
    D[D.shape[1]-1,0] = 1
           
    return D
                
Tripleeinheitsmatrix()    
print(D)     

wandelmatrix = np.zeros ((zeilen,spalten))

def Matrizenmultiplikation():
    z = np.linalg.solve(D,M)       
    wandelmatrix = np.linalg.solve(z,D) 
    
    return wandelmatrix

Matrizenmultiplikation()

print (wandelmatrix)