Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
__**Was wir geschafft haben:**__

Arbeit von Leroy und Hanna:
multiplik. mehrere zeitschritte. visuell dargestellt

Die Matrizenmultiplikation der Tripleeinheitsmatrix mit der M Matrix funktioniert. Jetzt kann man auch in unserem Programm einstellen, wie viele Zeitschritte es geben soll. Außerdem sind die einzelnen Zeitschritte visuell dargestellt, d.h. zu jeder Matrix wird ein Bild angezeigt. Der erste Code ist noch unsortiert. Der zweite Code wurde sortiert. Die Funktion stehen hintereinander und danach stehen die Variablen.

Arbeit von Mazal und Richard:
Wir haben uns ansatzweise in das Paket animation von matplotlib eingearbeitet.
Die Funktion matplotlib.animation.FuncAnimation() haben wir ausgewählt als beste Option um das Game Of Life zu visualisieren. Damit haben wir ein Beispielprogramm erstellt, dass eine gegebene Matrix als bunte Animation ausgibt.

 

Ziele Für nächstes Jahr:
 - Zusammenführen der Unterprojekte
 - weitere Spielereien und Verfeinerungen(Farben, evtl Interaktionen, evtl andere Ausgangskonfigurationen, etc.) des Game of Life




Unsortierter Code:
<code>


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

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

zeilen = 100
spalten = zeilen

# Die Matrix wird zufällig mit Nullen und Einsen gefüllt
M = np.zeros ((zeilen,spalten))
 
def Matrix_füllen(M,zeilen,spalten):
    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(M,zeilen,spalten)      
print (M)
plt.imshow(M)
plt.show()

D = np.zeros ((zeilen,spalten))
def Tripleeinheitsmatrix(D,zeilen,spalten):
    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(D,zeilen,spalten)    
#print(D)     

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



def Generationen(Matrix_füllen,Tripleeinheitsmatrix):    
    def Matrizenmultiplikation(D,M):
        z = np.dot(D,M)       
        k = np.dot(z,D)
        wandelmatrix = k- M
        
        return wandelmatrix
    
    wandelmatrix= Matrizenmultiplikation(D,M)
    Matrizenmultiplikation(D,M)
    #print (wandelmatrix)
    
    
    #Ursprungszelle Tod + genau 3 lebende Nachbarn = lebend
    #Ursprungszelle Lebend + genau 1 lebenden Nachbarn = tot
    #Ursprungszelle Lebend + 2 o. 3 Nachbarn = lebend
    #Ursprungszelle lebend + 4 oder mehr Nachbarn = tot
    
    
    def GameofLife(M,wandelmatrix):
        for i in range(0, zeilen):
            for j in range(0, spalten):
                if M[(i,j)] == 1 and (wandelmatrix[(i,j)]==2 or wandelmatrix[(i,j)]==3) :
                    M[(i,j)]=1
                elif M[(i,j)] == 1 and (wandelmatrix[(i,j)]==1 or wandelmatrix[(i,j)] in range(4,9)) :
                    M[(i,j)]=0
                elif M[(i,j)] == 0 and wandelmatrix[(i,j)]==3:
                    M[(i,j)]=1
                else:
                    M[(i,j)]=0
                    
        return M
    
    GameofLife(M,wandelmatrix)
    print(M)
    plt.imshow(M)
    plt.show()
                
t=3
for i in range(t):
    Generationen(Matrix_füllen,Tripleeinheitsmatrix)
    

</code>
Sortierter Code:
<code>
import random
import numpy as np
import matplotlib.pyplot as plt

# Größe der Matrix
# Die Matrix wird zufällig mit Nullen und Einsen gefüllt

 
def Matrix_füllen(M,zeilen,spalten):
    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  
        

def Tripleeinheitsmatrix(D,zeilen,spalten):
    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
                

def Generationen(Matrix_füllen,Tripleeinheitsmatrix):    
    def Matrizenmultiplikation(D,M):
        z = np.dot(D,M)       
        k = np.dot(z,D)
        wandelmatrix = k- M
        
        return wandelmatrix
    
    wandelmatrix= Matrizenmultiplikation(D,M)
    Matrizenmultiplikation(D,M)
    #print (wandelmatrix)
    
    
    #Ursprungszelle Tod + genau 3 lebende Nachbarn = lebend
    #Ursprungszelle Lebend + genau 1 lebenden Nachbarn = tot
    #Ursprungszelle Lebend + 2 o. 3 Nachbarn = lebend
    #Ursprungszelle lebend + 4 oder mehr Nachbarn = tot
    
    
    def GameofLife(M,wandelmatrix):
        for i in range(0, zeilen):
            for j in range(0, spalten):
                if M[(i,j)] == 1 and (wandelmatrix[(i,j)]==2 or wandelmatrix[(i,j)]==3) :
                    M[(i,j)]=1
                elif M[(i,j)] == 1 and (wandelmatrix[(i,j)]==1 or wandelmatrix[(i,j)] in range(4,9)) :
                    M[(i,j)]=0
                elif M[(i,j)] == 0 and wandelmatrix[(i,j)]==3:
                    M[(i,j)]=1
                else:
                    M[(i,j)]=0
                    
        return M
    
    GameofLife(M,wandelmatrix)
    print(M)
    plt.imshow(M)
    plt.show()
                
def Wiederholungen(t):
    for i in range(t):
        Generationen(Matrix_füllen,Tripleeinheitsmatrix)
    
t= int(input('Gib die Zeitschritte ein: '))
zeilen = int(input('Gib die Anzahl der Zeilen/Spalten ein: '))
spalten = zeilen

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

Matrix_füllen(M,zeilen,spalten) 
Tripleeinheitsmatrix(D,zeilen,spalten)   
Generationen(Matrix_füllen,Tripleeinheitsmatrix) 
Wiederholungen(t)   

</code>
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
