Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Räuber-Beute-Verhalten (Lotka/Volterra) (Simulationen)

Eine deutsche Formulierung der bekannten Räuber-Beute-Beziehung finden wir auf www.mathekiste.de. Zitat:

In den meisten Regionen der Erde ist die Nahrungskette der verschiedenen Tierarten ein sehr komplexes Gefüge. Jeder Räuber frisst mehrere Beutearten, und jede Beuteart dient mehreren Räuberarten als Nahrung. Relativ einfach wird die Untersuchung nur bei artenarmen Ökosystemen. Ein solches Ökosystem besteht auf Neufundland mit nur 14 heimischen Säugetierarten. Dort stellt man bei der Anzahl der Luchse (Räuber) und der Schneeschuhhasen (Beute) periodische Schwankungen fest. Die Anzahl der von der Hudson's Bay Company gefangenen Hasen und Luchse schwankte von 1850 bis 1900 periodisch im Zehnjahresrhythmus.

Die Anzahl der Luchse (L bzw. Lalt und Lneu) ändert sich in dem betrachteten Zeitintervall ?t um ?L. Der Zuwachs der Luchse ist proportional zur Anzahl der vorhandenen Luchse und, da ein höheres Nahrungsangebot eine höhere Geburtenanzahl mit sich bringt, auch proportional zur Anzahl der vorhandenen Hasen (H bzw. Halt und Hneu), also insgesamt proportional zum Produkt L*H

Die Zuwachs- bzw. Sterberaten (Proportionalitätskonstanten) werden mit fzu bzw. fab bezeichnet. Für Luchse bzw. Hasen also fzuHL, fabL bzw. fzuH und fabHL.

Gleichzeitig wird im Zeitintervall ?t (alt -> neu) ein Teil der Luchse sterben (Feinde haben sie keine). Die Anzahl der sterbenden Luchse ist proportional zur Anzahl der vorhandenen Luchse. Damit ist die gesamte Änderung der Luchse

?L = fzuHL  * H * L - fabL * L

und nach dem Zeitintervall ?t ist die neue Anzahl der Luchse

Lneu = Lalt + ?L = Lalt + fzuHL * H * L - fabL * L

während die Anzahl der Hasen sich wie folgt verändert:

Hneu = Halt + ?H = Halt + fzuH * H - fabHL * H * L

 

Schreiben Sie ein Programm, welches obiges Räuber-Beute-Verhalten simuliert.

Tipp: Es ist mit ganzen Zahlen eine grosse Herausforderung, eine stabile Lösung
zu finden. Verwenden Sie daher sowohl für die Proportionalitätskonstanten, wie
auch für die Anzahl Tiere gebrochene Zahlen (real).

 

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

4 Lösung(en)

/**
 * @author Philipp Gressly (phi AT gressly DOT ch)
 * Modifikation M. Guggisberg.
 */
public class RaeuberBeuteVerhalten {
  public static void main(String[] args) {
    new RaeuberBeuteVerhalten().top();
  }
  
  void top() {
    // Populationen
    double Lalt = 15;
    double Halt = 50;
    // Proportionalitätskonstanten
    double fzuHL = 0.001; // Luchse Zuwachsrate in Abhängigkeit von Hasen und Luchsen
    double fabL  = 0.05;  // Luchse Stebrerate
    double fzuH  = 0.1;   // Hasen Zuwachsrate
    double fabHL = 0.01;  // Hasen Sterberaten in Abhängikeit von Hasen und Luchsen
    
   
    int simulationen = 1000;
    System.out.println("Luchse\tHasen");
    while(simulationen > 0) {
      double Lneu = simuliereLuchse(Lalt, fzuHL, Halt, fabL);
      double Hneu = simuliereHasen (Halt, fzuH, fabHL, Lalt);
      System.out.println((int) Lalt + "\t" + (int) Halt);
      Lalt = Lneu;
      Halt = Hneu;
      simulationen = simulationen - 1;
    }
  }

  double simuliereLuchse(double Lalt, double fzuHL, double Halt, double fabL) {
    double Lneu = Lalt + fzuHL * Halt * Lalt - fabL * Lalt;
    if(Lneu > 0) {
      return Lneu;
    }
    return 0;
  }
  
  double simuliereHasen(double Halt, double fzuH, double fabHL, double Lalt) {
    double Hneu = Halt + fzuH * Halt - fabHL * Halt * Lalt;
    if(Hneu > 0) {
      return Hneu;
    }
    return 0;
  }
  
}
 // end of class RaeuberBeuteVerhalten
                
def simuliereLuchse(Lalt, fzuHL, Halt, fabL):
    Lneu = Lalt + fzuHL * Halt * Lalt - fabL * Lalt
    if(Lneu > 0):
        return Lneu
    return 0

def simuliereHasen(Halt, fzuH, fabHL, Lalt):
    Hneu = Halt + fzuH * Halt - fabHL * Halt * Lalt;
    if(Hneu > 0):
        return Hneu
    return 0

Lalt = 15.0;
Halt = 50.0;
# Proportionalitätskonstanten
fzuHL = 0.001; # Luchse Zuwachsrate in Abhängigkeit von Hasen und Luchsen
fabL  = 0.05;  # Luchse Stebrerate
fzuH  = 0.1;   # Hasen Zuwachsrate
fabHL = 0.01;  # Hasen Sterberaten in Abhängikeit von Hasen und Luchsen
    
   
simulationen = 1000
print"Luchse\tHasen"
while(simulationen > 0):
    Lneu = simuliereLuchse(Lalt, fzuHL, Halt, fabL);
    Hneu = simuliereHasen (Halt, fzuH, fabHL, Lalt);
    print str(int(Lalt)) + "\t" + str(int(Halt))
    Lalt = Lneu
    Halt = Hneu
    simulationen = simulationen - 1
                
const LYNX_QUANTITY  = 15,      HARE_QUANTITY  = 50,
      LYNX_INCREASE  = .001,    HARE_INCREASE  = .1,
      LYNX_MORTALITY = .05,     HARE_MORTALITY = .01;

class Population {
  constructor (quantity, increase, mortality) {
    this.quantity = quantity;
    this.increase = increase;
    this.mortality = mortality;
    this.cur = 0;
  }
  calculate() {}
}

let lynx  = new Population(LYNX_QUANTITY, LYNX_INCREASE, LYNX_MORTALITY),
    hares = new Population(HARE_QUANTITY, HARE_INCREASE, HARE_MORTALITY);

lynx.calculate = function() {
  this.cur = this.quantity + this.increase * hares.quantity * this.quantity
    - this.mortality * this.quantity;
  if (this.cur < 1) this.cur = 1;
}

hares.calculate = function() {
  this.cur = this.quantity + this.increase * this.quantity
    - this.mortality * this.quantity * lynx.quantity;
  if (this.cur < 1) this.cur = 1;
}

// ausgabe
document.write(`
  <table><tr><th>Ciklo</th><th>Linkoj</th><th>Leporoj</th></tr>
    <tr><td>0</td><td>${lynx.quantity}</td>
    <td>${hares.quantity}</td></tr>
`);
for (let i = 1; i <= 1000; i++) {
  lynx.calculate(); hares.calculate();
  document.write(`
    <tr><td>${i}</td>
    <td>${Math.round(lynx.cur)}</td>
    <td>${Math.round(hares.cur)}</td></tr>
  `);
  lynx.quantity = lynx.cur;
  hares.quantity = hares.cur;
}
document.write(`</table>`);

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// C++ 14 | VS-2022
#include <iostream>

constexpr double    LYNX_QUA{ 15 },     HARE_QUA{ 50 },
                    LYNX_INC{ 0.001 },  HARE_INC{ 0.1 },
                    LYNX_MOR{ 0.05 },   HARE_MOR{ 0.01 };
constexpr size_t    SIMULATIONS{ 1000 };

const struct population {
    const double this_qua, other_qua, this_inc, this_mor;
};

constexpr inline auto get_lynx_current(const population& p_) noexcept {
    const auto cur{ p_.this_qua + p_.this_inc * p_.other_qua * p_.this_qua - p_.this_mor * p_.this_qua };
    return cur < 1 ? 1 : cur;
}

constexpr inline auto get_hare_current(const population& p_) noexcept {
    const auto cur{ p_.this_qua + p_.this_inc * p_.this_qua - p_.this_mor * p_.this_qua * p_.other_qua };
    return cur < 1 ? 1 : cur;
}

int main() {
    auto lynx_cur{ LYNX_QUA }, hare_cur{ HARE_QUA };
    auto i{ SIMULATIONS };

    while (--i) {
        std::cout << "Lynx: " << lynx_cur << "; Hare: " << hare_cur << "\n";
        lynx_cur = get_lynx_current(population{ lynx_cur, hare_cur, LYNX_INC, LYNX_MOR });
        hare_cur = get_hare_current(population{ hare_cur, lynx_cur, HARE_INC, HARE_MOR });
    }
}
                

Lösung von: Jens Kelm (@JKooP)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 2
Schwierigkeit: k.A.
Webcode: 47gv-shif
Autor: Martin Guggisberg (Universität Basel / PH FHNW)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen