====== Protokoll vom 20.11.2014 ======

  * Wiki überarbeitet
  * Literatursammlung
  * Lotka-Volterra Modell als Anhaltspunkt
  * Besprechung der groben Struktur und Vorangehensweise des Projekts

====== Protokoll vom 27.11.2014 ======

  * Code von http://wiki.scipy.org/Cookbook/LoktaVolterraTutorial als Vorlage genommen
  * Erste Versuche des Umschreibens
  * Experimente für bestimmte Werte für das Volterra-Modell
  * Einigung auf Speicherung der Daten auf der Wiki 

====== Protokoll vom 04.12.2014 ======

  * Lotka Volterra Fehlschlag beim Versuch auf 3 Tiere auszubauen
  * neuen Versuch mit selbsterstellten Code
<code pyhton>
def Vermehrung(n,m,limit):
    t= 0 #t=eine zeiteinheit
    while t<Limit:
        n=n*a-m*b #a=vermehrungsrate der Beute b=anzahl der gefressen tiere
        t=t+1
        if t== Limit:
            break
</code>
  * Versuch der graphischen Darstellung der momentanen Funktion
<code python>
from __future__ import division
import pylab as p
from numpy import *
import scipy

def Nahrungskette(X,limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        t=0
        while t<limit:
            X[0]=X[0]*a-X[1]*b
            X[1]=X[1]*c
            t=t+1
            return array([X[0],X[1]])
            if t==limit:
                break
from scipy import integrate

z=linspace(0,  15,  1000)

p.plot(z, X[0], 'r-', label='Hasen')
p.plot(z, X[1], 'v-', label='Fuechse')
p.grid()
p.legend(loc='best')
p.xlabel('Zeit')
p.ylabel('Population')
p.title('Entwicklung von Fuchs und Hase')
        
a=1.5    #Vermehrungsrate der Beute
b=0.5    #Anzahl der gefressenen Beute pro Jaeger
c=1.25   #Vermehrungsrate der Jaeger
X=array([50,10])
##################################################################

print Vermehrung_beute(5000,50,60)

#vernachlaessigt: 
#Sterberate
#Abiotische/biotische Faktoren
#Fresswahrscheinlichkeit
#von m,n abhaengige Faktoren a,c 
</code>

====== Protokoll vom 11.12.2014 ======
 
  * Probleme bei der Graphischen Darstellung
  * Ausarbeiten auf 4 Tiere
<code python>
def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        t=0
        while t<limit:
            X[0]=X[0]*a1-X[1]*b2-X[2]*c3-X[3]*d4
            X[1]=X[1]*b1-X[2]*c2-X[3]*d3
            X[2]=X[2]*c1-X[3]*d2
            X[3]=X[3]*d1
            t=t+1
            
            if t==limit:
                break
            print X[0]
           
            
            #Versuch der graphischen Darstellung mit pylab (fehlerhaft):  
            #z=np.linspace(0, t, 1000)
            p.plot(t, X[0] , 'r-', label='Tier 1')
            p.xlabel('Zeit')
            p.ylabel('Population')
            p.ylim(0.)
            p.show()
            
            
X=[50., 40., 30., 20.] 
           

a1=1.5    #Vermehrungsrate von Tier 0

b1=1.25   #Vermehrungsrate von Tier 1 
b2=0.15   #Fressrate Tier 1 -> Tier 0

c1=1.15   #Vermehrungsrate von Tier 2
c2=0.10   #Fressrate Tier 2 -> Tier 0
c3=0.125  #Fressrate Tier 2 -> Tier 1

d1=1.05   #Vermehrungsrate von Tier 3
d2=0.05   #Fressrate Tier 3 -> Tier 0
d3=0.075  #Fressrate Tier 3 -> Tier 1
d4=0.15   #Fressrate Tier 3 -> Tier 2
</code>
  - Vernachlässigt einiges (siehe pyhtoncode vom 11.12.2014)


====== Protokoll vom 18.12.2014 ======

  * Problem der graphischen Darstellung gelöst.
  * Graphen für alle vier Tiere erstellt mit Legende, Achsenbeschriftung, etc. 
  * Etappenziel für dieses Jahr erreicht!
  * Besprechung der weiteren Ziele für das nächste Jahr und die Vorlesungsfreie Zeit um Weihnachten.
  * Erster Versuch der Einführung einer Sterberate für die Tiere
  * Korrektur der Beschreibungsfehler in den Kommentaren für die Koeffizienten im Quelltext.
  * Quelltext:
<code python>
from __future__ import division
import pylab as p

def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]
        l1=[X[1]]
        l2=[X[2]]
        l3=[X[3]]
        t=0
        z=[t] 
        while t<limit:
            X[0]=X[0]*a0+X[0]*a1-X[1]*b2-X[2]*c3-X[3]*d4
            X[1]=X[1]*b0+X[1]*b1-X[2]*c2-X[3]*d3
            X[2]=X[2]*c0+X[2]*c1-X[3]*d2
            X[3]=X[3]*d0+X[3]*d1
            t=t+1
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
            if t==limit:
                break
            
            
        #Graphische Darstellung mit pylab:  
            
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'v-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
        
            
X=[50., 40., 20., 10.] 
           
a0=-0.2   #natürliche Absterbrate Tier 0
a1=1.5    #Vermehrungsrate von Tier 0

b0=-0.1   #natürliche Absterbrate Tier 1
b1=1.25   #Vermehrungsrate von Tier 1 
b2=0.18   #Fressrate Tier 1 -> Tier 0

c0=-0.05  #natürliche Absterbrate Tier 2
c1=1.15   #Vermehrungsrate von Tier 2
c2=0.15   #Fressrate Tier 2 -> Tier 1
c3=0.175  #Fressrate Tier 2 -> Tier 0

d0=-0.025 #natürliche Absterbrate Tier 3
d1=1.05   #Vermehrungsrate von Tier 3
d2=0.05   #Fressrate Tier 3 -> Tier 2
d3=0.075  #Fressrate Tier 3 -> Tier 1
d4=0.15   #Fressrate Tier 3 -> Tier 0

##################################################################

print Nahrungskette(30)


#vernachlaessigt: 
#Sterberate (ausbaufähig)
#Abiotische/biotische Faktoren
#Fresswahrscheinlichkeit
#von m,n abhaengige Faktoren a,c 
#Abhaengigkeit der Vermehrung von Anteil 
##an Maennchen und Weibchen in der Population
</code>

====== Protokoll vom 08.01.2015 ======
  * Beratung für die nächsten Wochen was gemacht wird
  * Vermehrung abhängig von der Anzahl der Beute gemacht
  * falls X[0]-X[3] kleiner 0 wird als 0 dargestellt
  * Auskommentierung der einzelnen Schritte im Quelltext zur besseren Veranschaulichung/Orientierung
  * Quelltext zum Ende
<code python>
from __future__ import division
import pylab as p

def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]
        l1=[X[1]]
        l2=[X[2]]
        l3=[X[3]]
        t=0
        z=[t]
        b1=1.25   #Vermehrungsrate von Tier 1
        c1=1.15   #Vermehrungsrate von Tier 2
        d1=1.05   #Vermehrungsrate von Tier 3
        
        while t<limit: #elif: falls X[n] == 0, Vermehrung = 0!
            
            #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            
            if X[0]<=0:
                X[0]==0
                
            if X[1]<=0:
                X[1]==0
                
            if X[2]<=0:
                X[2]==0
                
            if X[3]<=0:
                X[3]==0
            
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            
            if X[0]/X[1]>=1:
                b1=b1
            else:
                b1=X[0]/X[1]*b1
                
            if (X[0]+X[1])/X[2]>=1:
                c1=c1
            else:
                c1=(X[0]+X[1])/X[2]*c1
                
            if (X[0]+X[1]+X[2])/X[3]>=1:
                d1=d1
            else:
                d1=(X[0]+X[1]+X[2])/X[3]*d1
            
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
            
            X[0]=X[0]*s0+X[0]*a1-X[1]*b2-X[2]*c3-X[3]*d4
            X[1]=X[1]*s1+X[1]*b1-X[2]*c2-X[3]*d3
            X[2]=X[2]*s2+X[2]*c1-X[3]*d2
            X[3]=X[3]*s3+X[3]*d1
            
            t=t+1
            
            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
            
            if t==limit:
                break
            
            
        #Graphische Darstellung mit pylab:  
            
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'v-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
        
            
X=[50., 40., 20., 10.] 
           
s0=-0.2   #natuerliche Absterbrate Tier 0
s1=-0.1   #natuerliche Absterbrate Tier 1
s2=-0.05  #natuerliche Absterbrate Tier 2
s3=-0.025 #natuerliche Absterbrate Tier 3

a1=1.5    #Vermehrungsrate von Tier 0
          #Annahme: Tier 0 hat zu jedem Zeitpunkt genug 
          ##Nahrung zur Verfuegung.

 
b2=0.18   #Fressrate Tier 1 -> Tier 0


c2=0.15   #Fressrate Tier 2 -> Tier 1
c3=0.175  #Fressrate Tier 2 -> Tier 0


d2=0.05   #Fressrate Tier 3 -> Tier 2
d3=0.075  #Fressrate Tier 3 -> Tier 1
d4=0.15   #Fressrate Tier 3 -> Tier 0

##################################################################

print Nahrungskette(40)


#vernachlaessigt: 
#Sterberate (ausbaufaehig)
#Abiotische/biotische Faktoren
#Fresswahrscheinlichkeit
#von m,n abhaengige Faktoren a,c 
#Abhaengigkeit der Vermehrung von Anteil 
##an Maennchen und Weibchen in der Population
</code>

====== Protokoll vom 15.01.2015 ======
  * Zwecksmäßige Verschiebung der Grenzfunktion für 0 unterhalb der Berechnung anstatt oberhalb.
  * Einführung einer Katastrophensimulation mithilfe einer Zufallsfunktion, dabei Erweiterung der Variablenliste um die Zufallsvariablen.
  * Einführung einer Obergrenze für die jeweilige Populationenanzahl auf einen selbst wählbaren Wert (momentan auf 400000 Individuen).
  * Erste Versuche zu einer Benahrichtigung bei einem Aussterben einer Population. Ziel für nächste Woche: Genauen Zeitpunkt des Aussterbens ermitteln.
  * Einbauen der UTF8-Codierung für Python.
  * Aktualisierung der Liste "Vernachlässigt", Erstellen der Liste "Ausbaufähig"
  * Quellcode zum Ende:

<code python>
# -*- coding: utf-8 -*-
from __future__ import division
import pylab as p
import random

def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]
        l1=[X[1]]
        l2=[X[2]]
        l3=[X[3]]
        t=0
        z=[t]
        b1=1.25   #Vermehrungsrate von Tier 1
        c1=1.15   #Vermehrungsrate von Tier 2
        d1=1.05   #Vermehrungsrate von Tier 3
        
        while t<limit:
            if random.randint(1, float(K))==k:
                v=kt
            else:
                v=1
            
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            # Falls für das n-te Tier die n+1-te Population 0 ist, bleibt alles 
            ## wie gehabt, um eine Division durch 0 zu umgehen.
            
            if X[1]==0:
                pass
            elif X[0]/X[1]>=1:
                b1=b1
            else:
                b1=X[0]/X[1]*b1
                
            if X[2]==0:
                pass
            elif (X[0]+X[1])/X[2]>=1:
                c1=c1
            else:
                c1=(X[0]+X[1])/X[2]*c1
                
            if X[3]==0:
                pass
            elif (X[0]+X[1]+X[2])/X[3]>=1:
                d1=d1
            else:
                d1=(X[0]+X[1]+X[2])/X[3]*d1
            
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
            
            X[0]=(X[0]*s0+X[0]*a1-X[1]*b2-X[2]*c3-X[3]*d4)*v
            X[1]=(X[1]*s1+X[1]*b1-X[2]*c2-X[3]*d3)*v
            X[2]=(X[2]*s2+X[2]*c1-X[3]*d2)*v
            X[3]=(X[3]*s3+X[3]*d1)*v
            
            t=t+1
            
            #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            #Des Weiteren wird ein für alle Populationen gültiges Limit von 
            ##400000 gesetzt, um übermäßiges und unrealistisches 
            ##Populationenwachstum zu verhindern.
            
            if X[0]<=0:
                X[0]=0.
            elif X[0]>=400000:
                X[0]=400000.
                
            if X[1]<=0:
                X[1]=0.
            elif X[1]>=400000:
                X[1]=400000.
                
            if X[2]<=0:
                X[2]=0.
            elif X[2]>=400000:
                X[2]=400000.
                
            if X[3]<=0:
                X[3]=0.
            elif X[3]>=400000:
                X[3]=400000.
            #--> Zeitpunkt des Aussterbens wiedergeben.
                
            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
            
            if t==limit:
                break
        
        #Benachrichtigung, falls eine Population aussterben sollte.        
        
        if l0[-1]==0:
            print "Tier-0-Population ist ausgestorben."
        if l1[-1]==0:
            print "Tier-1-Population ist ausgestorben."
        if l2[-1]==0:
            print "Tier-2-Population ist ausgestorben."
        if l3[-1]==0:
            print "Tier-3-Population ist ausgestorben."
            
            
        #Graphische Darstellung mit pylab:  
            
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'v-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
        
            
X=[100., 70., 55., 30.] 
           
s0=-0.2   #natürliche Absterbrate Tier 0
s1=-0.1   #natürliche Absterbrate Tier 1
s2=-0.05  #natürliche Absterbrate Tier 2
s3=-0.025 #natürliche Absterbrate Tier 3

a1=1.5    #Vermehrungsrate von Tier 0
          #Annahme: Tier 0 hat zu jedem Zeitpunkt genug 
          ##Nahrung zur Verfügung.

 
b2=0.18   #Fressrate Tier 1 -> Tier 0


c2=0.15   #Fressrate Tier 2 -> Tier 1
c3=0.175  #Fressrate Tier 2 -> Tier 0


d2=0.05   #Fressrate Tier 3 -> Tier 2
d3=0.075  #Fressrate Tier 3 -> Tier 1
d4=0.15   #Fressrate Tier 3 -> Tier 0

K=100     #Wahrscheinlichkeit für das Eintreffen einer Naturkatastrophe
k=1       #Zufallsvarible
kt=1/3    #Faktor zur Verringerung der Populationenzahl 
          ##nach der Naturkatastrophe
##################################################################

print Nahrungskette(100)


####vernachlässigt#### 

##von m,n abhängige Faktoren a,c 
##Abhängigkeit der Vermehrung von Anteil 
###an Männchen und Weibchen in der Population

####ausbaufähig####
##Sterberate
##Fresswahrscheinlichkeit
##Abiotische/biotische Faktoren (Katastrophensimulation)
</code>

====== Protokoll vom 22.01.2015 ======
  * Korrektur der Vermehrungsrate falls ein Tier das andere nicht frisst
  * Wiedergabe nach wie vielen Jahren die Tiere aussterben
(hat länger gedauert als erwartet ca 1 Stunde und 10 Minuten für die Umsetzung)
  * Noch maliges Überarbeiten der Kommentare
  * Quellcode zum Ende:
<code python>
# -*- coding: utf-8 -*-

from __future__ import division
import pylab as p
import random
 
def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]   #l0-l4 sind Listen für die Tiere 0-4 eingegeben als float
        l1=[X[1]]   ## siehe X unten
        l2=[X[2]]
        l3=[X[3]]
        t=0         #anfangswert von t
        maxi=20000. #maximale Anzahl an ernährbaren Tieren(von allen) bitte als float Eingabe
        z=[t]
        z1=[t]      #z1-z4 ist für die Wiedergabe des Zeitpunkts des Absterbens
        z2=[t]      ##der Populationen wichtig
        z3=[t]
        z4=[t]
        b1=1.4      #Vermehrungsrate von Tier 1 
        c1=1.3      #Vermehrungsrate von Tier 2
        d1=1.1      #Vermehrungsrate von Tier 3

        
        while t<limit:
            if random.randint(1.,float(K))==k:
                v=kt
            else:
                v=1
                
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            # Falls für das n-te Tier die n+1-te Population 0 ist, bleibt alles 
            ## wie gehabt, um eine Division durch 0 zu umgehen.
            
            if X[1]==0:
                pass
            elif (b2*X[0])/(b2*X[1])>=1:
                 b1=b1
            else:
                 b1=((b2*X[0])/(b2*X[1]))*b1
                 
            if X[2]==0 :
                pass
            elif (c3*X[0]+c2*X[1])/((c3+c2)*X[2])>=1:
                 c1=c1
            else:
                 c1=((c3*X[0]+c2*X[1])/((c3+c2)*X[2]))*c1
                 
            if X[3]==0:
                pass
            elif (d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])>=1:
                 d1=d1
            else:
                 d1=((d4*X[0]+d3*X[1]+d2*X[2])/((d4+d3+d2)*X[3])*d1)
           
           
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
           
           
            X[0]=( X[0] * s0 + X[0] * a1 - X[1] * b2 - X[2] * c3 - X[3] * d4 ) * v
            X[1]=( X[1] * s1 + X[1] * b1 - X[2] * c2 - X[3] * d3 ) * v
            X[2]=( X[2] * s2 + X[2] * c1 - X[3] * d2 ) * v
            X[3]=( X[3] * s3 + X[3] * d1 ) * v
            
         
            #Annäherung von t an sein limit
            t=t+1
            
             #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            #Des Weiteren wird ein für alle Populationen gültiges Limit von 
            ##400000 gesetzt, um übermäßiges und unrealistisches 
            ##Populationenwachstum zu verhindern. 
            
            if X[0]<=0:
                X[0]=0.
            elif X[0]>=maxi:
                X[0]=maxi
                
            if X[1]<=0:
                X[1]=0.
            elif X[1]>=maxi:
                X[1]=maxi
                
            if X[2]<=0:
                X[2]=0. 
            elif X[2]>=maxi:
                X[2]=maxi 
                   
            if X[3]<=0:
                X[3]=0.
            elif X[3]>=maxi:
                X[3]=maxi 


            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
            
            #zur Zeitpunkt bestimmung des Austerbens
            z1.append(t)
            z2.append(t)
            z3.append(t)
            z4.append(t)
            
            #Falls t sein limit erreicht beendet es den Vorgang
            if t==limit:
                break
            
            #Benachrichtigung, falls eine Population aussterben sollte.
            # Rechnung in while-Schleife
            if l0[-1]==0:
                z1.extend(z)
                
            if l1[-1]==0:
                z2.extend(z)
                
            if l2[-1]==0:
                z3.extend(z)
               
            if l3[-1]==0:
                z4.extend(z)
 

        #Graphische Darstellung mit pylab:  
 
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'y-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
 
        #Ausgabe der Jahren, wann die Tiere aussterben
        print "Tier-0-Population ist ausgestorben. Seit so vielen Jahren:", z1.count(0)
        print "Tier-1-Population ist ausgestorben. Seit so vielen Jahren:", z2.count(0) 
        print "Tier-2-Population ist ausgestorben. Seit so vielen Jahren:", z3.count(0) 
        print "Tier-3-Population ist ausgestorben. Seit so vielen Jahren:", z4.count(0) 

X=[100., 80., 50., 20.] 
 
 
s0=-0.4    #natürliche Absterbrate Tier 0
s1=-0.25   #natürliche Absterbrate Tier 1
s2=-0.13   #natürliche Absterbrate Tier 2
s3=-0.025  #natürliche Absterbrate Tier 3

a1=1.8     #Vermehrungsrate von Tier 0(für Tier 0 wird
           ##Vorausgestezt das es genug Nahrung zur Vermehrung immer hat)


b2=0.18    #Fressrate Tier 1 -> Tier 0
 


c2=0.08   #Fressrate Tier 2 -> Tier 1
c3=0.4    #Fressrate Tier 2 -> Tier 0
 


d2=0.08   #Fressrate Tier 3 -> Tier 2
d3=0.06   #Fressrate Tier 3 -> Tier 1
d4=0.15   #Fressrate Tier 3 -> Tier 0

K=1000    #Wahrscheinlichkeit für ein Treffen einer Katastrophe mit 1:K
k=1       #belieber wert zwischen 1 und K
kt=1/3    #Prozent der Induvidien die Absterben(sollte kleiner 1 sein)
##################################################################
 
print Nahrungskette(30) 
 
####vernachlässigt#### 
 
##von m,n abhängige Faktoren a,c 
##Abhängigkeit der Vermehrung von Anteil 
###an Männchen und Weibchen in der Population
 
####ausbaufähig####
##Sterberate
##Fresswahrscheinlichkeit
##Abiotische/biotische Faktoren (Katastrophensimulation)
</code>

====== Protokoll vom 29.01.2015 ======
  * Überarbeitung der Anzeige vom Zeitpunkt des Aussterbens der jeweiligen Populationen im Porgramm.
  * Maximalfunktion für Tier 0 bearbeitet und verbessert, für die anderen Populationen Schranke entfernt
  * (, da unserer Ansicht nach diese biologische Schranke für die anderen Populationen nicht gegeben ist.)
  * Vermehrungsratenfunktion überarbeitet, falls die einzelnen Tiere aussterben (-> wird nächstes Mal fortgesetzt).
  * Vermehrungsraten geändert (experimentell).
  * Quellcode am Ende des Tages:

<code python>
# -*- coding: utf-8 -*-
 
from __future__ import division
import pylab as p
import random
 
def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]   #l0-l4 sind Listen für die Tiere 0-4 eingegeben als float
        l1=[X[1]]   ## siehe X unten
        l2=[X[2]]
        l3=[X[3]]
        t=0         #anfangswert von t
        maxi=500000.#maximale Anzahl an ernährbaren Tieren(von allen) bitte als float Eingabe
        z=[t]
        z1=[t]      #z1-z4 ist für die Wiedergabe des Zeitpunkts des Absterbens
        z2=[t]      ##der Populationen wichtig
        z3=[t]
        z4=[t]
        a1=4.       #Vermehrungsrate von Tier 0(für Tier 0 wird
        a2=a1       ##Vorausgestezt das es genug Nahrung zur Vermehrung immer hat)
        b1=2.5      #Vermehrungsrate von Tier 1 
        c1=2.       #Vermehrungsrate von Tier 2
        d1=1.5      #Vermehrungsrate von Tier 3
 
 
        while t<limit:
            if random.randint(1.,float(K))==k:
                v=kt
            else:
                v=1
 
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            # Falls für das n-te Tier die n+1-te Population 0 ist, bleibt alles 
            ## wie gehabt, um eine Division durch 0 zu umgehen.
 
            if X[1]==0:
                pass
            elif (b2*X[0])/(b2*X[1])>=1:
                 b1=b1
            else:
                 b1=((b2*X[0])/(b2*X[1]))*b1
                
            if X[2]==0 :
                pass
            elif (c3*X[0]+c2*X[1])/((c3+c2)*X[2])>=1:
                 c1=c1
            else:
                 c1=((c3*X[0]+c2*X[1])/((c3+c2)*X[2]))*c1
 
            if X[3]==0:
                pass
            elif (d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])>=1:
                 d1=d1
                 
            else:
                if X[0]<=0:
                 d1=((d3*X[1]+d2*X[2])/((d3+d2)*X[3])*d1)
                if X[1]<=0:
                 d1=((d4*X[0]+d2*X[2])/((d4+d2)*X[3])*d1)
                if X[2]<=0:
                 d1=((d4*X[0]+d3*X[1])/((d4+d3)*X[3])*d1)
                if X[0]<=0 and X[1]<=0:
                 d1=((d2*X[2])/((d2)*X[3])*d1)
                if X[0]<=0 and X[2]<=0:
                 d1=((d3*X[1])/((d3)*X[3])*d1)
                if X[1]<=0 and X[2] <=0:
                 d1=((d4*X[0])/((d4)*X[3])*d1)
 
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
 
 
            X[0]=( X[0] * s0 + X[0] * a1 - X[1] * b2 - X[2] * c3 - X[3] * d4 ) * v
            X[1]=( X[1] * s1 + X[1] * b1 - X[2] * c2 - X[3] * d3 ) * v
            X[2]=( X[2] * s2 + X[2] * c1 - X[3] * d2 ) * v
            X[3]=( X[3] * s3 + X[3] * d1 ) * v
 
 
            #Annäherung von t an sein limit
            t=t+1
 
             #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            #Des Weiteren wird ein für alle Populationen gültiges Limit von 
            ##400000 gesetzt, um übermäßiges und unrealistisches 
            ##Populationenwachstum zu verhindern. 
 
            if 0 <= X[0] <= maxi:
                X[0]=X[0]
                a1=a2
            elif X[0]>=maxi:
                X[0]=maxi
                a1=2
            elif X[0]<=0:
                X[0]=0
 
            if X[1]<=0:
                X[1]=0.
            #elif X[1]>=maxi:
            #    X[1]=maxi
            else:
                X[1]=X[1]
                
            if X[2]<=0:
                X[2]=0. 
            #elif X[2]>=maxi:
            #    X[2]=maxi 
            else:
                X[2]=X[2]
                
            if X[3]<=0:
                X[3]=0.
            #elif X[3]>=maxi:
            #    X[3]=maxi 
            else:
                X[3]=X[3]
 
            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
 
 
            #Falls t sein limit erreicht beendet es den Vorgang
            if t==limit:
                break
 
            #Benachrichtigung, falls eine Population aussterben sollte.
            # Rechnung in while-Schleife
            if l0[-1]==0:
                z1.extend(z)
 
            if l1[-1]==0:
                z2.extend(z)
 
            if l2[-1]==0:
                z3.extend(z)
 
            if l3[-1]==0:
                z4.extend(z)
 
 
        #Graphische Darstellung mit pylab:  
 
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'y-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
 
        #Ausgabe der Jahren, wann die Tiere aussterben
        if l0[-1]==0:
            print "Tier-0-Population ist nach",limit - z1.count(0),"Jahren ausgestorben."
        if l1[-1]==0:
            print "Tier-1-Population ist nach",limit - z2.count(0),"Jahren ausgestorben." 
        if l2[-1]==0:
            print "Tier-2-Population ist nach",limit - z3.count(0),"Jahren ausgestorben."
        if l3[-1]==0:
            print "Tier-3-Population ist nach",limit - z4.count(0),"Jahren ausgestorben."  
 
X=[200., 80., 50., 20.] 
 
 
s0=-0.4    #natürliche Absterbrate Tier 0
s1=-0.25   #natürliche Absterbrate Tier 1
s2=-0.13   #natürliche Absterbrate Tier 2
s3=-0.025  #natürliche Absterbrate Tier 3
 
 
 
b2=0.18    #Fressrate Tier 1 -> Tier 0
 
 
 
c2=0.08   #Fressrate Tier 2 -> Tier 1
c3=0.4    #Fressrate Tier 2 -> Tier 0
 
 
 
d2=0.08   #Fressrate Tier 3 -> Tier 2
d3=0.06   #Fressrate Tier 3 -> Tier 1
d4=0.8    #Fressrate Tier 3 -> Tier 0
 
K=1000    #Wahrscheinlichkeit für ein Treffen einer Katastrophe mit 1:K
k=1       #belieber wert zwischen 1 und K
kt=1/3    #Prozent der Induvidien die Absterben(sollte kleiner 1 sein)
##################################################################
 
print Nahrungskette(100) 


####vernachlässigt#### 
 
##von m,n abhängige Faktoren a,c 
##Abhängigkeit der Vermehrung von Anteil 
###an Männchen und Weibchen in der Population
 
####ausbaufähig####
##Sterberate
##Fresswahrscheinlichkeit
##Abiotische/biotische Faktoren (Katastrophensimulation)
</code>

====== Protokoll vom 05.02.2015 ======
  * Vermehrungsratenfunktion für den Fall, dass Populationen aussterben, fertig gestellt.
  * Variablen überarbeitet für bessere und realistischere Darstellung
  * Kommentare ergänzt/überarbeitet, wo es nötig war.
  * Erproben des Programms durch Durchspielen verschiedener Situationen mit verschiedenen Variablen
  * -> Ausmerzung der gefundenen Fehler

<code/python>
# -*- coding: utf-8 -*-
 
from __future__ import division
import pylab as p
import random
 
def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]   #l0-l4 sind Listen für die Tiere 0-4 eingegeben als float
        l1=[X[1]]   ## siehe X unten
        l2=[X[2]]
        l3=[X[3]]
        t=0         #anfangswert von t
        maxi=50000000.#maximale Anzahl an ernährbaren Tieren(von allen) bitte als float Eingabe
        z=[t]
        z1=[t]      #z1-z4 ist für die Wiedergabe des Zeitpunkts des Absterbens
        z2=[t]      ##der Populationen wichtig
        z3=[t]
        z4=[t]
        a1=4.       #Vermehrungsrate von Tier 0(für Tier 0 wird
        a2=a1       ##Vorausgestezt das es genug Nahrung zur Vermehrung immer hat)
        b1=2.5      #Vermehrungsrate von Tier 1 
        c1=2.       #Vermehrungsrate von Tier 2
        d1=1.5      #Vermehrungsrate von Tier 3
 
 
        while t<limit:
            if random.randint(1.,float(K))==k:
                v=kt
            else:
                v=1
 
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            # Falls für das n-te Tier die n+1-te Population 0 ist, bleibt alles 
            ## wie gehabt, um eine Division durch 0 zu umgehen.
            
            if X[1]==0:
                pass
            elif (b2*X[0])/(b2*X[1])>=1:
                 b1=b1
            else:
                 b1=((b2*X[0])/(b2*X[1]))*b1
                
            if X[2]==0 :
                pass
            elif (c3*X[0]+c2*X[1])/((c3+c2)*X[2])>=1:
                 c1=c1
            else:
                if X[0]<=0:
                 c1=(((c2+c3)*X[1])/((c3+c2)*X[2])*c1)
                if X[1]<=0:
                 c1=(((c2+c3)*X[0])/((c3+c2)*X[2])*c1)
                else:
                 c1=((c3*X[0]+c2*X[1])/((c3+c2)*X[2]))*c1
        
            if X[3]==0:
                pass
            elif (d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])>=1:
                 d1=d1
            else:
                if X[0]<=0:
                 d1=(((d3+(0.5*d4))*X[1]+(d2+(0.5*d4))*X[2])/((d4+d3+d2)*X[3])*d1)
                if X[1]<=0:
                 d1=(((d4+(0.5*d3))*X[0]+(d2+(0.5*d3))*X[2])/((d4+d3+d2)*X[3])*d1)
                if X[2]<=0:
                 d1=(((d4+(0.5*d2))*X[0]+(d3+(0.5*d2))*X[1])/((d4+d3+d2)*X[3])*d1)
                if X[0]<=0 and X[1]<=0:
                 d1=(((d2+d3+d4)*X[2])/((d2)*X[3])*d1)
                if X[0]<=0 and X[2]<=0:
                 d1=(((d2+d3+d4)*X[1])/((d3)*X[3])*d1)
                if X[1]<=0 and X[2] <=0:
                 d1=(((d2+d3+d4)*X[0])/((d4)*X[3])*d1) 
                else:
                 d1=((d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])*d1)
            
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
            
            if X[0]>=maxi:
                X[0]=maxi
 
            X[0]=( X[0] * s0 + X[0] * a1 - X[1] * b2 - X[2] * c3 - X[3] * d4 ) * v
            X[1]=( X[1] * s1 + X[1] * b1 - X[2] * c2 - X[3] * d3 ) * v
            X[2]=( X[2] * s2 + X[2] * c1 - X[3] * d2 ) * v
            X[3]=( X[3] * s3 + X[3] * d1 ) * v
            
 
 
            #Annäherung von t an sein limit
            t=t+1
 
             #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            #Des Weiteren wird ein für alle Populationen gültiges Limit von 
            ##400000 gesetzt, um übermäßiges und unrealistisches 
            ##Populationenwachstum zu verhindern. 
 
            if 1 <= X[0] <= maxi:
                X[0]=X[0]
                a1=a2
            elif X[0]>=maxi:
                X[0]=maxi
                a1=1
            elif X[0]<=1:
                X[0]=0
 
            if X[1]<=1:
                X[1]=0.
            
            else:
                X[1]=X[1]
                
            if X[2]<=1:
                X[2]=0. 
        
            else:
                X[2]=X[2]
                
            if X[3]<=1:
                X[3]=0.
            
            else:
                X[3]=X[3]
            
            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
 
 
            #Falls t sein limit erreicht beendet es den Vorgang
            if t==limit:
                break
 
            #Benachrichtigung, falls eine Population aussterben sollte.
            # Rechnung in while-Schleife
            if l0[-1]==0:
                z1.extend(z)
 
            if l1[-1]==0:
                z2.extend(z)
 
            if l2[-1]==0:
                z3.extend(z)
 
            if l3[-1]==0:
                z4.extend(z)
 
 
        #Graphische Darstellung mit pylab:  
 
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'y-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()
 
        #Ausgabe der Jahren, wann die Tiere aussterben
        if l0[-1]==0:
            print "Tier-0-Population ist nach",limit - z1.count(0) + 1,"Jahren ausgestorben."
        if l1[-1]==0:
            print "Tier-1-Population ist nach",limit - z2.count(0) + 1,"Jahren ausgestorben." 
        if l2[-1]==0:
            print "Tier-2-Population ist nach",limit - z3.count(0) + 1,"Jahren ausgestorben."
        if l3[-1]==0:
            print "Tier-3-Population ist nach",limit - z4.count(0) + 1,"Jahren ausgestorben."  
 
X=[400., 300., 200., 100.] 
 
 
s0=-0.400   #natürliche Absterbrate Tier 0
s1=-0.250   #natürliche Absterbrate Tier 1
s2=-0.130   #natürliche Absterbrate Tier 2
s3=-0.050   #natürliche Absterbrate Tier 3
 

 
b2=0.4  #Fressrate Tier 1 -> Tier 0
 
 
 
c2=0.75   #Fressrate Tier 2 -> Tier 1
c3=0.25   #Fressrate Tier 2 -> Tier 0
 
 
 
d2=0.67   #Fressrate Tier 3 -> Tier 2
d3=0.24   #Fressrate Tier 3 -> Tier 1
d4=0.09   #Fressrate Tier 3 -> Tier 0
 
K=50000   #Wahrscheinlichkeit für ein Treffen einer Katastrophe mit 1:K
k=1       #belieber wert zwischen 1 und K
kt=0.01   #multiplikativer Faktor der Induvidien die Überleben(sollte kleiner 1 sein)
##################################################################
 
print Nahrungskette(30) 


####vernachlässigt#### 
 
##von m,n abhängige Faktoren a,c 
##Abhängigkeit der Vermehrung von Anteil 
###an Männchen und Weibchen in der Population
 
####ausbaufähig####
##Sterberate
##Fresswahrscheinlichkeit
##Abiotische/biotische Faktoren (Katastrophensimulation)

</code>

====== Protokoll vom 12.02.2015 ======
  * ersetzen der Variablen durch Eingabe des raw_input-Befehls
  * Experimeteles herumspielen mit Werten um Fehler zu finden
  * ->gefundene Fehler ausgemerzt
  * Quellcode zum Ende:
 
<code/python>
# -*- coding: utf-8 -*-
from __future__ import division
import pylab as p
import random
 
def Nahrungskette(limit):
        ''' Gibt die Anzahl n der Beute-Population zu einer Zeit t an '''
        l0=[X[0]]   #l0-l4 sind Listen für die Tiere 0-4 eingegeben als float
        l1=[X[1]]   ## siehe X unten
        l2=[X[2]]
        l3=[X[3]]
        t=0         #Anfangswert von t
        maxi=float(raw_input("maximale Anzahl an ernährbaren Tieren(von Tier 1)(Bsp:500000)"))
        z=[t]
        z1=[t]      #z1-z4 ist für die Wiedergabe des Zeitpunkts des Absterbens
        z2=[t]      ##der Populationen wichtig
        z3=[t]
        z4=[t]
        a1=a2=float(raw_input("Geben Sie eine Vermehrungsrate für Tier 0 ein(Bsp:4)"))#(für Tier 0 wird Vorausgestezt das es genug Nahrung zur Vermehrung immer hat)
        b1=float(raw_input("Geben Sie eine Vermehrungsrate für Tier 1 ein(Bsp:2.5)"))         
        c1=float(raw_input("Geben Sie eine Vermehrungsrate für Tier 2 ein(Bsp:2)"))           
        d1=float(raw_input("Geben Sie eine Vermehrungsrate für Tier 3 ein(Bsp:1.5)"))         
 
 
        while t<limit:
            if random.randint(1.,float(K))==k:
                v=j
            else:
                v=1
 
            #Im Folgenden wird die jeweilige Vermehrungsrate abhängig von der
            ## Anzahl der Beutetiere im Verhältnis der Anzahl der Jäger gemacht.
            # Falls für das n-te Tier die n+1-te Population 0 ist, bleibt alles 
            ## wie gehabt, um eine Division durch 0 zu umgehen.
 
            if X[1]==0:
                pass
            elif (b2*X[0])/(b2*X[1])>=1:
                 b1=b1
            else:
                 b1=((b2*X[0])/(b2*X[1]))*b1
 
            if X[2]==0 :
                pass
            elif (c3*X[0]+c2*X[1])/((c3+c2)*X[2])>=1:
                 c1=c1
            else:
                if X[0]<=0:
                 c1=(((c2+c3)*X[1])/((c3+c2)*X[2])*c1)
                if X[1]<=0:
                 c1=(((c2+c3)*X[0])/((c3+c2)*X[2])*c1)
                else:
                 c1=((c3*X[0]+c2*X[1])/((c3+c2)*X[2]))*c1
 
            if X[3]==0:
                pass
            elif (d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])>=1:
                 d1=d1
            else:
                if X[0]<=0:
                    d1=(((d3+(0.5*d4))*X[1]+(d2+(0.5*d4))*X[2])/((d4+d3+d2)*X[3])*d1)
                if X[1]<=0:                   
                    d1=(((d4+(0.5*d3))*X[0]+(d2+(0.5*d3))*X[2])/((d4+d3+d2)*X[3])*d1)
                if X[2]<=0:
                    d1=(((d4+(0.5*d2))*X[0]+(d3+(0.5*d2))*X[1])/((d4+d3+d2)*X[3])*d1)
                if X[0]<=0 and X[1]<=0:
                    if d2==0. :
                        d1=1
                    else:
                        d1=(((d2+d3+d4)*X[2])/((d2)*X[3])*d1)
                if X[0]<=0 and X[2]<=0:
                    if d3==0. :
                        d1=1
                    else:
                        d1=(((d2+d3+d4)*X[1])/((d3)*X[3])*d1)
                if X[1]<=0 and X[2] <=0:
                    if d4==0. :
                        d1=1
                    else:
                        d1=(((d2+d3+d4)*X[0])/((d4)*X[3])*d1) 
                else:
                 d1=((d4*X[0]+d3*X[1]+d2*X[2])/((d2+d3+d4)*X[3])*d1)
 
            #Berechnung der Anzahl der Tiere zum Zeitpunkt t
 
            if X[0]>=maxi:
                X[0]=maxi
 
            X[0]=( X[0] * s0 + X[0] * a1 - X[1] * b2 - X[2] * c3 - X[3] * d4 ) * v
            X[1]=( X[1] * s1 + X[1] * b1 - X[2] * c2 - X[3] * d3 ) * v
            X[2]=( X[2] * s2 + X[2] * c1 - X[3] * d2 ) * v
            X[3]=( X[3] * s3 + X[3] * d1 ) * v
 
            #Annäherung von t an sein limit
            t=t+1
 
             #Im Folgenden wird der Fall behandelt, dass ein Tier den Wert 0
            ## oder kleiner 0 erreicht. Es wird verhindert, dass dieses Tier
            ## später wachsen kann oder generell die Anzahl negativ wird.
            #Des Weiteren wird ein für alle Populationen gültiges Limit von 
            ##400000 gesetzt, um übermäßiges und unrealistisches 
            ##Populationenwachstum zu verhindern. 
 
            if 1 <= X[0] <= maxi:
                X[0]=X[0]
                a1=a2
            elif X[0]>=maxi:
                X[0]=maxi
                a1=1
            elif X[0]<=1:
                X[0]=0
 
            if X[1]<=1:
                X[1]=0. 
            else:
                X[1]=X[1]
 
            if X[2]<=1:
                X[2]=0. 
            else:
                X[2]=X[2]
 
            if X[3]<=1:
                X[3]=0. 
            else:
                X[3]=X[3]
 
            #Ergänzung der Listen mit den Werten zum Zeitpunkt t 
            l0.append(X[0])
            l1.append(X[1])
            l2.append(X[2])
            l3.append(X[3])
            z.append(t)
 
 
            #Falls t sein limit erreicht beendet es den Vorgang
            if t==limit:
                break
 
            #Benachrichtigung, falls eine Population aussterben sollte.
            # Rechnung in while-Schleife
            if l0[-1]==0:
                z1.extend(z)
 
            if l1[-1]==0:
                z2.extend(z)
 
            if l2[-1]==0:
                z3.extend(z)
 
            if l3[-1]==0:
                z4.extend(z)
 
 
        #Graphische Darstellung mit pylab:  
 
        p.plot(z , l0 , 'r-', label='Tier 0')
        p.plot(z , l1 , 'b-', label='Tier 1')
        p.plot(z , l2 , 'g-', label='Tier 2')
        p.plot(z , l3 , 'y-', label='Tier 3')
        p.xlabel('Zeit')
        p.ylabel('Population')
        p.ylim(0.)
        p.legend(loc='best')
        p.show()

 
        #Ausgabe der Jahren, wann die Tiere aussterben
        if l0[-1]==0:
            print "Tier-0-Population ist nach",limit - z1.count(0) + 1,"Jahren ausgestorben."
        if l1[-1]==0:
            print "Tier-1-Population ist nach",limit - z2.count(0) + 1,"Jahren ausgestorben." 
        if l2[-1]==0:
            print "Tier-2-Population ist nach",limit - z3.count(0) + 1,"Jahren ausgestorben."
        if l3[-1]==0:
            print "Tier-3-Population ist nach",limit - z4.count(0) + 1,"Jahren ausgestorben."  

 
X=[float(raw_input("Anfangszahl von Tier O(Bsp:400)")),float(raw_input("Anfangszahl von Tier 1(Bsp:300)")),float(raw_input("Anfangszahl von Tier 2(Bsp:200)")),float(raw_input("Anfangszahl von Tier 3(Bsp:100)"))] 
 
 
s0=float(raw_input("natürliche Absterbrate Tier 0 (Bsp:-0.400)"))   
s1=float(raw_input("natürliche Absterbrate Tier 1 (Bsp:-0.250)"))   
s2=float(raw_input("natürliche Absterbrate Tier 2 (Bsp:-0.130)"))   
s3=float(raw_input("natürliche Absterbrate Tier 3 (Bsp:-0.050)"))   

 
b2=float(raw_input("Fressrate von Tier 1 zu Tier 0 (Bsp:1)"))  
 
c2=float(raw_input("Fressrate von Tier 2 zu Tier 1 (Bsp:0.75)"))   
c3=float(raw_input("Fressrate von Tier 2 zu Tier 0 (Bsp:0.25)"))   
 
d2=float(raw_input("Fressrate von Tier 3 zu Tier 2 (Bsp:0.67)"))   
d3=float(raw_input("Fressrate von Tier 3 zu Tier 1 (Bsp:0.24)"))   
d4=float(raw_input("Fressrate von Tier 3 zu Tier 0 (Bsp:0.09)"))   


K=int(raw_input("Wahrscheinlichkeit für ein Treffen einer Katastrophe im Verhältniss 1:K (Bsp:5000)"))   
k=int(raw_input("Belieber Wert zwischen 1 und K (Bsp:1)"))                                              
j=float(raw_input("multiplikativer Faktor der Induvidien die Überleben(sollte kleiner 1 sein damit sie Weniger werden)(Bsp:0.01)"))
##################################################################
 
print Nahrungskette(int(raw_input("Gebe die Anzahl der Jahre an die Berechnet werden sollten (Bsp:30)"))) 

 
####vernachlässigt#### 
 
##von m,n abhängige Faktoren a,c 
##Abhängigkeit der Vermehrung von Anteil 
###an Männchen und Weibchen in der Population
 
####ausbaufähig####
##Sterberate
##Fresswahrscheinlichkeit
##Abiotische/biotische Faktoren (Katastrophensimulation)
</code>

Das Programm weißt noch einige Fehler auf und ist nicht optimal gestalltet, aber für eine angemessene Zeitausschnitt kann es mit der Realität überein stimmten.