.fi schoen
                              von Helmut
  Schluderbacher
           

Diese Beitra zeig di Mglichkeite de numerische Integratio 
vo Differentialgleichunge a Han zweie berlebensmodell vo 
Populationen Hie folg ein kurz bersich be Verfahre zu 
numerische Integratio vo Differentialgleichungen di f di 
Funktionsweis de vorgestellte Programm wesentlic sind E sin 
dre Verfahre blich:

1. Euler-Verfahren
Da Euler-Verfahre geh vo eine bestimmte Anfangswer de 
unabhngige Variable x un de zugehrige Funktionswer y au 
un erhh di unabhngig Variabl  u eine Betra d au de 
Wer x un berechne au Grun de Tangent durc x0,y de 
Funktionswer y a diese Stelle Da wir f all andere Punkt 
s fortgesetzt Natrlic wir be jede Schritt j nac Gr de 
Schrittweit ei kleine Fehle entstehen de sic au di folgen
de Punkt auswirkt 

2. Verbessertes Euler-Verfahren (Verfahren von Heun)
Da verbessert Euler-Verfahre leg zunchs durc de erste Punk 
x0,y di Tangent wi bei einfache Euler-Verfahren Durc de 
darau ermittelte nchste Punk x1H,y1Ƞ (de spte zugunste 
eine ne konstruierte Punkte verworfe wird  wir abe wiede 
ein Tangent gelegt Dan wir di Winkelsymmetral au de beide 
Tangente gebilde un dies Winkelsymmetral durc de erste Punk 
x0,y parallelverschoben Dies Richtun wir al hypothetisch 
Verbindungslini zu nchste Punk gelegt De Schnittpunk mi de 
nchste Sttzgerade durc x is dan de nchst Funktionswer 
y1 x1H,y1H wird verworfen.

3. Runge-Kutta-Verfahren
Da Runge-Kutta-Verfahre knnt ma al verbesserte 'verbesserte 
Euler-Verfahren bezeichnen E wir durc de Punk x0,y di 
Tangent wi bei verbesserte Euler-Verfahre gelegt dan durc 
de nchste s bestimmte Punk x1,y di Tangente un durc dies 
beide Punkt un dere Tangente ei Polyno dritte Grades da 
mi de bernchste Sttzstell x zu Schnittpunk gebrach wird 
Diese Punk x is de nchst berechnet Funktionswert De Punk 
x1,y de durc da verbessert Eulerverfahre gewonne wurde wir 
verworfen.













Weiter Verbesserun de genannte Verfahre kan ma erreichen 
wen ma di Schrittweit zu nchste Interval nich konstan 
lt sonder vo de Steilhei de Funktio abhngi macht 
.pa
Dynami vo homogene Populatione vo Organisme                 
-------------------------------------------------

1. Gau-Model f di Konkurren zwische zwe Spezies
2. Das Lotka-Volterra Raubwesen-Modell


1. Gau-Model f di Konkurren zwische zwe Spezies
   ----------------------------------------------------

Di Modelle di di Konkurren zwische zwe Spezie behandeln 
basiere i allgemeine au  logische Gleichungen di zuers vo 
Lotk un Volterr vorgeschlage wurden un di dan endglti i 
de klassische Aufzeichnun vo Gau un Wit (1935 entwickel 
wurden Di dari enthaltene grundlegende Differentialgleichunge 
sind:

d N1
---- = r1*N1 - r1*sqr(N1)/K1 - r1*alpha*N1*N2/K1       (1)  und
 dt

d N2
---- = r2*N2 - r2*sqr(N2)/K2 - r2*beta*N1*N2/K2        (2)
 dt

wobe N un N di Populationsdichte vo Spezie  bz  darstel
len r un r sin di konstante Wachstumsrate f  Spezies K 
un K sin di tragende Kapazitte de Umgebun f jed Spezie 
wen ein einzel anwchst alph is ein Konstant bezglic de 
Auswirkun vo Specie  au Specie 2 Grundstzlic sage dies 
Differentialgleichunge aus da de Anstie de Populationsdicht 
gleic de unlimitierte Wachstumsrat abzglic de Wachstumseffek
te un de Effekte de Spezies-Wechselwirkun ist E is nu 
dies letzte Punkt welche dies Gleichun vo de einfache 
logische Wachstumsgleichunge unterscheidet Auerde mu bemerk 
werden da de Ausdruc N1*N ein ander Anwendun de Gesetze 
de Massensverhalten be Populatione vo Organisme darstellt 

Di Konstant alph drck de Effek eine Einzelwesen vo Spezie 
 unte de tragende Kapazit vo Spezie  aus z.B wen alph  
0, dan is ei Einzelwese vo Spezie  gleic 0, Einzelwese 
vo Spezie 1 Bet drck de gleiche Effek vo eine Einzelwese 
vo Spezie  unte de tragende Kapazit vo Spezie  aus Wert 
gre al  zeige an da di kmpfend Spezie de Plat vo meh 
al  Einzelwese de andere Spezie einnimmt Negativ Wert habe 
de Effek de Additio z de tragende Leistun de andere Spe
zies s wi e be Jagd-Organisme de Fal ist.

U di Ergebniss eine durchgefhrte Experimente z analysieren 
is e ntzlic de Wer N au de x-Achs un N au de y-Achs 
darzustellen u ei Phasen-Raum-Diagram z produzieren.

Manch  typische simulierte Phasen-Raum-Diagramm entstehe durc 
di Darstellun vo Populationsdichte vo Spezie N al ein 
Funktio vo Spezie N1.

F ein vollstndig Diskussio de Ergebniss un Bedeutunge 
diese Ar de Simulatio schlag be Gau un Wit (1935 ode 
Pielo (1977 nach.
.pa
Di folgende Paramete knne verwende werden u da Verhale 
diese Modell z demonstrieren:

 N     N  5   r     r     K  30   K  30 
 alph  0.  bet  0.  T-en  2  

.fi elite
(*****************************************************************************)
program leben-ko    {Konkurrenz-modell};
(*****************************************************************************)

const dim                     = 3840;
{ Mit 8087  dim = 3840  ohne dim = 5120 }

type aa                       = array [1..2,1..dim] of real;
     bb                       = string[2];
     ee                       = record
                                  a,b,h,k1,k2,n1,n2,r1,r2   : real;
                                  tmax                    : integer;
                                end;

var  ar                                        : aa;
     b                                         : boolean;
     c                                         : char;
     e                                         : ee;
     i,j,k,l,lmax,tmax                         : integer;
     d1,d2,dn1,dn2,h,k1,k2                     : real;
     max1,max2,min1,min2,n1,n2                 : real;
     inf1,inf2,sup1,sup2,seite                 : integer;

(*$I LEBEN.INC *) 

procedure int;

begin
    dn1:=e.r1*n1*(1-n1/e.k1-e.a*n2/e.k1);
    dn2:=e.r2*n2*(1-n2/e.k2-e.b*n1/e.k2);
    n1:=n1+h*dn1;
    n2:=n2+h*dn2;
    if n1 < 0 then
      n1:=0;
    if n2 < 0 then
      n2:=0;
end;
.fi schoen
.pa
.fi elite
procedure ein;

  procedure werte;

  begin
    window(1,5,30,17);
    clrscr;
    writeln('SCHRITTWEITE = ',h:1:4);
    writeln('T-END        = ',tmax:4);
    if b then
      writeln('BILD         = Punkte')
    else
      writeln('BILD         = Streifen');
    writeln('N1           = ',n1:4:0);
    writeln('N2           = ',n2:4:0);
    writeln('r1           = ',e.r1:2:2);
    writeln('r2           = ',e.r2:2:2);
    writeln('K1           = ',e.k1:4:0);
    writeln('K2           = ',e.k2:4:0);
    writeln(chr(224),'            = ',e.a:2:3);
    writeln(chr(225),'            = ',e.b:2:3);
    window(1,19,80,23);
  end;

begin (* ein *)
  clrscr;
  n1:=e.n1;
  n2:=e.n2;
  h:=e.h;
  tmax:=e.tmax;
  writeln('KERBL-SCHLUDERBACHER                           (C) 1986  ver. 1.0':72);
  writeln;
  writeln(' KONKURRENZMODELL':72);

  repeat
    werte;
    clrscr;
    writeln('(N)x,(r)x,(K)x,(a)lfa,(b)eta');
    write('(B)ILD,(S)CHRITTWEITE,(T)END,<ENTER> oder <ESC> : ');
    read(kbd,c);
    writeln(c);
.fi schoen
.pa
.fi elite
    case c of
      'a':begin
            write(chr(224),' : ');
            readln(e.a);
          end;
      'b':begin
            write(chr(225),' : ');
            readln(e.b);
          end;
      'B':b:=not b;
      'K':begin
            write('K1 : ');
            readln(e.k1);
            write('K2 : ');
            readln(e.k2);
          end;
      'N':begin
            repeat
              write('N1 : ');
              readln(n1);
            until n1 > 0;
            repeat
              write('N2 : ');
              readln(n2);
            until n2 > 0;
          end;
      'S':begin
            repeat
              write('SCHRITTWEITE  H = TEND/(640*L) , L = ',l,' , L = 1..',lmax,' : ');
              readln(l);
            until (0<l) and (l<lmax+1);
            j:=640*l;
            h:=tmax/j;
          end;
      'T':begin
            repeat
              write('T-END ( 0 < TMAX < ',dim+1,' !!): ');
              readln(tmax);
            until (tmax>0) and (tmax<dim+1);
            h:=tmax/640;
            j:=640;
            writeln('SCHRITTWEITE WURDE AUF ',h:1:4,' GESETZT');
            delay(3000);
          end;
      'r':begin
            write('r1 : ');
            readln(e.r1);
            write('r2 : ');
            readln(e.r2);
          end;
    end;
  until (c=^M) or (c=^[);
  e.n1:=n1;
  e.n2:=n2;
  e.h:=h;
  e.tmax:=tmax;
  window(1,1,80,25);
end; (* ein *)
.fi schoen
.pa
.fi elite

begin
  b:=true;
  l:=1;
  j:=640;
  lmax:=dim div 640;
  e.tmax:=20;
  e.a:=0.5;
  e.b:=0.5;
  e.h:=e.tmax/j;
  e.k1:=300;
  e.k2:=300;
  e.n2:=50;
  e.n1:=5;
  e.r1:=5;
  e.r2:=1;
  repeat
    ein;
    if c<>^[ then
    begin
      aus1;
      for i:=1 to j-1 do
      begin
        ar[1,i]:=n1;
        ar[2,i]:=n2;
        write('*');
        int;
      end;
      aus2;
      if c<>^[ then
        read(kbd,c);
    end;
  until c = ^[;
  textmode;
  gotoxy(32,13);
  write('PROGRAM BEENDET');
  gotoxy(1,24);
end.
.fi schoen
.pa
2. Das Lotka-Volterra Raubwesen-Modell
   -----------------------------------

Da erst Model welche di Ruber-Beute-Wechselwirkun i homoge
ne Populatione zeig wurd unabhngi voneinande vo Lotk 192 
un Volterr 193 entwickelt Obwoh diese Model gan einfac ist 
bilde e ein Basi f viel nachfolgend Modell un is dahe 
de Ausgangspunk f di Diskussio be Raubwesen.

Di folgende  Gleichunge beschreibe de Wechse i de Popula
tionsdichte vo N de Beute un P de Rubern.

dN
-- = r*N - p*N*P       (3)  und
dt 

dP
-- = alpha*p*N*P - d*P (4)
dt

Dabe is  di Wachstumsrat f di Beute  is di Raubkonstan
te alph is di Angleichungskonstant di erzeug wir u di 
Beut z tte un  is di Todesrat f di Ruber Da Produkt 
pNP is ei charakteristische Merkma diese Gleichunge un ba
sier au de Geset de Massenverhaltens.

Ein de Schwierigkeiten di i Simulatione auftrete di au de 
einfache Produkt-Ausdruc f Raubwese basiere ist da di ein
fach Euler-Integratio de Gleichun  Ergebniss f Π aufweise 
kann di kleine al Nul sind Normalerweis kan die verhinder 
werden inde ma di prziser verbessert Euler-Integratio ver
wende ode inde ma da Zeitinterval krzt.

Wi bei Konkurrenzmodel is e ntzlic un hilfreich di Ergeb
niss diese Modell i For eine Phasen-Raum-Diagramme darzustel
len i welche di Ruberdicht  al ein Funktio de Beut  
gesetz wird Da Ergebni i Fall de Lotka-Volterr Modelle is 
ein elliptisch Kurve di sic mi de Zei gege de Uhrzeiger
sin bewegt Kurve diese Ar sin charakteristisc f di meiste 
Ruber-Beute-Systeme Wi auc immer da Lotka-Volterr Model is 
einzi darin da ei neutrale Kreislau resultier mi konstante 
Amplituden di nu durc ursprnglich Raub- un Beutepopulatione 
f eine bestimmte Tei de Paramete bestimm werden Sieh 
Rosenzwei un Ma Arthu (1963).

ACHTUN !!!
Wen di numerisch Integratio korrek ausgefhr wurd  d.h  di 
Integratio relati genau da Zeitinterval richti un di Fehler
summierun de Rechner nich gro ist) s wir di Amplitud de 
Schwankunge sowoh f di Rube al auc f di Beut mi de 
Zei kostant.

Di folgende Paramete knne verwende werden u da Verhale 
diese Modell z demonstrieren:

N  150  P  5    0.    0.00    0.  alph  0. 
T-en  640

.pa
.fi elite
(*****************************************************************************)
program leben-lv  {LOTKA-VOLTERRA-MODELL};
(*****************************************************************************)

type ee                       = record
                                  a,b,d,h,n,p,r  : real;
                                  tmax           : integer;
                                end;

{$I LEBEN.INC}


function deltan(p,n:real):real;

begin
  deltan:=e.r*n-e.b*n*p;
end;


function deltap(p,n:real):real;

begin
  deltap:=e.a*e.b*n*p-e.d*p;
end;


procedure int;                 procedure ein;                                 
                                                                              
begin                            procedure werte;                             
  k1:=deltan(p,n);                                                            
  l1:=deltap(p,n);               begin                                        
  k2:=deltan(p+l1/2,n+k1/2);       window(1,5,30,16);                         
  l2:=deltap(p+l1/2,n+k1/2);       clrscr;                                    
  k3:=deltan(p+l2/2,n+k2/2);       writeln('SCHRITTWEITE = ',h:1:4);          
  l3:=deltap(p+l2/2,n+k2/2);       writeln('T-END        = ',tmax:4);         
  k4:=deltan(p+l3,n+k3);           if b then                                  
  l4:=deltap(p+l3,n+k3);             writeln('BILD         = Punkte')         
  p:=p+h*(l1+2*l2+2*l3+l4)/6;      else                                       
  n:=n+h*(k1+2*k2+2*k3+k4)/6;        writeln('BILD         = Streifen');      
  if p < 0 then                    writeln('Po           = ',p:4:0);          
    p:=0;                          writeln('No           = ',n:4:0);          
  if n < 0 then                    writeln('r            = ',e.r:2:3);        
    n:=0;                          writeln('p            = ',e.b:2:3);        
end;                               writeln('d            = ',e.d:2:3);        
                                   writeln(chr(224),'            = ',e.a:2:3);
                                   window(1,16,80,20);                        
                                 end;                                         
.fi schoen
Fortsetzung rechts oben
.pa
.fi elite

begin
  clrscr;
  p:=e.p;
  n:=e.n;
  h:=e.h;
  tmax:=e.tmax;
  writeln('KERBL-SCHLUDERBACHER                           (C) 1986  ver. 1.0':72);
  writeln;
  writeln('LOTKA-VOTERRA-RAEUBER-BEUTE-SYSTEM':72);
  repeat
    werte;
    clrscr;
    writeln('(P)o,(N)o,(r),(p),(d),(a)lfa');
    write('(B)ILD,(S)CHRITTWEITE,(T)END,<ENTER> oder <ESC> :');
    read(kbd,c);
    writeln(c);
    case c of
      'a':begin
            write(chr(224),' : ');
            readln(e.a);
          end;
      'B':b:=not b;
      'd':begin
            write('d : ');
            readln(e.d);
          end;
      'N':begin
            repeat
              write('No : ');
              readln(n);
            until n > 0;
          end;
      'p':begin
            write('p : ');
            readln(e.b);
          end;
      'P':begin
            repeat
              write('Po : ');
              readln(p);
            until p > 0;
          end;
      'r':begin
            write('r : ');
            readln(e.r);
          end;
      'S':begin
            repeat
              write('SCHRITTWEITE  H = TEND/(640*L) , L = ',l,' , L = 1..',lmax,' : ');
              readln(l);
            until (0<l) and (l<lmax+1);
            j:=640*l;
            h:=tmax/j;
          end;
.fi schoen
.pa
.fi elite
      'T':begin
            repeat
              write('T-END ( 0 < TMAX < ',dim+1,' !!): ');
              readln(tmax);
            until (tmax>0) and (tmax<dim+1);
            h:=tmax/640;
            j:=640;
            writeln('SCHRITTWEITE WURDE AUF ',h:1:4,' GESETZT');
            delay(3000);
          end;
    end;
  until (c=^M) or (c=^[);
  e.p:=p;
  e.n:=n;
  e.h:=h;
  e.tmax:=tmax;
  window(1,1,80,25);
end;


begin
  b:=true;
  l:=1;
  j:=640;
  lmax:=dim div 640;
  e.tmax:=640;
  e.a:=0.1;
  e.b:=0.002;
  e.d:=0.2;
  e.h:=e.tmax/j;
  e.n:=1500;
  e.p:=50;
  e.r:=0.1;
  repeat
    ein;
    if c<>^[ then
    begin
      aus1;
      for i:=1 to j-1 do
      begin
        ar[1,i]:=p;
        ar[2,i]:=n;
        write('*');
        int;
      end;
      aus2;
      if c<>^[ then
        read(kbd,c);
    end;
  until c = ^[;
  textmode;
  gotoxy(32,13);
  write('PROGRAM BEENDET');
  gotoxy(1,24);
end.
.fi schoen
.pa
I beide Programme is da folgend Include-Fil LEBEN.IN enthal
ten:
.fi elite
const dim                     = 3840;
{ Mit 8087  dim = 3840  ohne  dim = 5120 }

type aa                       = array [1..2,1..dim] of real;
     bb                       = string[2];

var  ar                                        : aa;
     b                                         : boolean;
     c                                         : char;
     e                                         : ee;
     i,j,k,l,lmax,tmax                         : integer;
     d1,d2,h,k1,k2,k3,k4,l1,l2,l3,l4           : real;
     max1,max2,min1,min2,n,p                   : real;
     inf1,inf2,sup1,sup2,seite                 : integer;

procedure bild(ix,iy,sx,sy:integer;bx,by,bz:bb);

begin
  gotoxy(round(2+seite),25);
  write(ix);
  gotoxy(round((80+seite)/3),25);
  write(round((sx+2*ix)/3));
  gotoxy(round(40+seite/2),25);
  write(round((sx+ix)/2));
  gotoxy(round(59+seite/4),25);
  write(round((3*sx+ix)/4));
  if sx < 10 then
  begin
    gotoxy(79,25);
    write(sx);
  end
  else
    if sx < 100 then
    begin
      gotoxy(78,25);
      write(sx);
    end
    else
      if sx < 1000 then
      begin
        gotoxy(77,25);
        write(sx);
      end
      else
        if sx < 10000 then
        begin
          gotoxy(76,25);
          write(sx);
        end
        else
        begin
          gotoxy(75,25);
          write(sx);
        end;
.fi schoen
.pa
.fi elite
  draw(1,185,640,185,15);
  draw(1,186,640,186,15);
  draw(1,187,640,187,15);
  draw(seite*8,1,seite*8,200,15);
  draw(seite*8-1,1,seite*8-1,200,15);
  draw(seite*8-2,1,seite*8-2,200,15);
  draw(seite*8-3,1,seite*8-3,200,15);
  gotoxy(12+seite,25);
  write(bx,chr(26));
  gotoxy(1,1);
  writeln(sy);
  writeln;
  gotoxy(1,12);
  writeln(round((sy+iy)/2));
  gotoxy(1,17);
  writeln(chr(24));
  writeln;
  writeln(by);
  if bz <> '  ' then
  begin
    writeln('+');
    writeln(bz);
  end;
  gotoxy(1,23);
  write(iy);
end;


procedure aus3;

begin
  hires;
  if j > 640 then
  begin
    l:= j div 640;
    k:=1;
    for i:=1 to j do
      if i mod l = 1 then
      begin
        ar[1,k]:=ar[1,i];
        ar[2,k]:=ar[2,i];
        k:=k+1;
      end;
  end;
  if max1 < max2 then
    max1:=max2;
  if min1 > min2 then
    min1:=min2;
  sup1:=round(max1+0.49999999);
  inf1:=trunc(min1);
  seite:=round(ln(sup1)/ln(10)+1.5);
  bild(0,inf1,tmax,sup1,'T ','P ','N ');
.fi schoen
.pa
.fi elite
  if min1 = max1 then
  begin
    gotoxy(10,12);
    write('RAEUBER UND BEUTE SIND KONSTANT ':57,min1:3:0);
  end
  else
  begin
    k1:=183/(min1-max1);
    d1:=(185-k1*(min1+max1))/2;
    if b then
      for i:=1+(8*seite) to 640 do
        plot(i,round(k1*ar[2,i-(8*seite)]+d1),15)
    else
      for i:=1+(8*seite) to 639 do
        draw(i,round(k1*ar[2,i-(8*seite)]+d1),
             i+1,round(k1*ar[2,i+1-(8*seite)]+d1),15);
    for i:=1+(8*seite) to 640 do
      if odd(i) then
        plot(i,round(k1*ar[1,i-(8*seite)]+d1),15);
  end;
end;


procedure aus2;                       procedure aus1;             
                                      begin                       
begin                                   clrscr;                   
  write(chr(7));                        write('BITTE WARTEN':46); 
  hires;                                gotoxy(1,5);              
  ar[1,j]:=p;                           for i:=1 to dim do        
  ar[2,j]:=n;                           begin                     
  max1:=ar[1,1];                          ar[1,i]:=0;             
  min1:=ar[1,1];                          ar[2,i]:=0;             
  max2:=ar[2,1];                        end;                      
  min2:=ar[2,1];                      end;                        
  for i:=1 to j do
  begin
    if max1 < ar[1,i] then
      max1:=ar[1,i];
    if max2 < ar[2,i] then
      max2:=ar[2,i];
    if min1 > ar[1,i] then
      min1:=ar[1,i];
    if min2 > ar[2,i] then
      min2:=ar[2,i];
  end;
.fi schoen
.pa
.fi elite
  if (max1>32767) or (max2>32767) then
  begin
    writeln('WERTE ZU GROSS - AUSGABE LEIDER NICHT MOEGLICH !!');
    writeln('BEUTE : ',max2,'   RAEUBER : ',max1);
    write('PRESS <ENTER>');
  end
  else
  begin
    sup1:=round(max1+0.49999999);
    sup2:=round(max2+0.49999999);
    inf1:=trunc(min1);
    inf2:=trunc(min2);
    seite:=round(ln(sup1)/ln(10)+1.5);
    bild(inf2,inf1,sup2,sup1,'N ','P ','  ');
    if min1 = max1 then
    begin
      gotoxy(10,12);
      write('RAEUBER SIND KONSTANT ':57,min1:3:0);
    end
    else
    if min2 = max2 then
    begin
      gotoxy(10,12);
      write('BEUTETIERE SIND KONSTANT ':57,min2:3:0);
    end
    else
    begin
      k1:=183/(min1-max1);
      d1:=(185-k1*(min1+max1))/2;
      k2:=(639-(8*seite))/(max2-min2);
      d2:=(641+(8*seite)-k2*(max2+min2))/2;
      if b then
      begin
        for i:=1 to j do
          plot(round(k2*ar[2,i]+d2),round(k1*ar[1,i]+d1),15);
      end
      else
      begin
        for i:=1 to j-1 do
          draw(round(k2*ar[2,i]+d2),round(k1*ar[1,i]+d1),
               round(k2*ar[2,i+1]+d2),round(k1*ar[1,i+1]+d1),15);
      end;
    end;
    read(kbd,c);
    if c<>^[ then
      aus3;
  end;
end;
.fi schoen
De theoretische Hintergrund zu diesem Beitrag wurd entnomme aus 

JAME D SPAI  "BASI MICROCOMPUTE MODEL I BIOLOG  (1982).

bersetzung  : ANDREA KSTLER
Programme    : MONIKA KERBL
               HELMUT SCHLUDERBACHER

I de folgende PC-NEW werde zwe weiter Modell diese Ar 
vorgestellt.
.pa
