Differentialgleichungen in Java

Question

Ich versuche, ein einfaches Simulationsprogramm des SIR-Epidemiemodells in Java zu erstellen.

Grundsätzlich wird SIR durch ein System von drei Differentialgleichungen definiert:
S '(t) = - l (t) * S (t)
I' (t) = L (t) * S (t) - g (t) * I (t)
R '(t) = g (t) * I (t)

S - anfällige Menschen, I - infizierte Menschen, R - erholte Menschen.

l (t) = [c * x * I (t)]/N (T)

c - Anzahl der Kontakte, x - Infektiosität (Wahrscheinlichkeit nach Kontakt mit kranken Menschen krank), N (t) - Gesamtbevölkerung (die konstant ist).

Wie kann ich solche Differentialgleichungen in Java lösen? Ich glaube nicht, dass ich einen brauchbaren Weg kenne, so dass meine Umsetzung Unsinn produziert.

public class Main { 
public static void main(String[] args) { 
    int tppl = 100; 
    double sppl = 1; 
    double hppl = 99; 
    double rppl = 0; 
    int numContacts = 50; 
    double infectiveness = 0.5; 
    double lamda = 0; 
    double duration = 0.5; 
    double gamma = 1/duration; 
    for (int i = 0; i < 40; i++) { 
     lamda = (numContacts * infectiveness * sppl)/tppl; 
     hppl = hppl - lamda * hppl; 
     sppl = sppl + lamda * hppl - gamma * sppl; 
     rppl = rppl + gamma * sppl; 
     System.out.println (i + " " + tppl + " " + hppl + " " + sppl + " " + rppl); 
    } 
} 

}

ich sehr jede mögliche Hilfe, vielen Dank im Voraus zu schätzen wissen!

Answer 1

Zeitreihendifferentialgleichungen können numerisch simuliert werden, indem dt = eine kleine Zahl genommen wird, und unter Verwendung eines von mehreren numerical integration techniques z. Euler's method oder Runge-Kutta. Eulers Methode mag primitiv sein, aber es funktioniert für einige Gleichungen OK und es ist einfach genug, dass Sie es versuchen könnten. Beispiel:

S '(t) = - l (t) * S (t)

I' (t) = L (t) * S (t) - g (t) * I (t)

R '(t) = g (t) * I (t)

int N = 100; 
double[] S = new double[N+1]; 
double[] I = new double[N+1]; 
double[] R = new double[N+1]; 

S[0] = /* initial value */ 
I[0] = /* initial value */ 
R[0] = /* initial value */ 

double dt = total_time/N; 

for (int i = 0; i < 100; ++i) 
{ 
    double t = i*dt; 
    double l = /* compute l here */ 
    double g = /* compute g here */ 

    /* calculate derivatives */ 
    double dSdt = - I[i] * S[i]; 
    double dIdt = I[i] * S[i] - g * I[i]; 
    double dRdt = g * I[i]; 

    /* now integrate using Euler */ 
    S[i+1] = S[i] + dSdt * dt; 
    I[i+1] = I[i] + dIdt * dt; 
    R[i+1] = R[i] + dRdt * dt; 
} 

Der schwierige Teil ist, herauszufinden, wie viele Schritte zu verwenden. Du solltest einen der Artikel lesen, mit denen ich verlinkt bin. Fortgeschrittenere Differentialgleichungslöser verwenden variable Schrittweiten, die sich an Genauigkeit/Stabilität für jeden Schritt anpassen.

Ich würde tatsächlich empfehlen, numerische Software wie R oder Mathematica oder MATLAB oder Octave zu verwenden, da sie ODE-Löser enthalten und Sie nicht selbst alle Schwierigkeiten auf sich nehmen müssten. Aber wenn Sie dies als Teil einer größeren Java-Anwendung tun müssen, probieren Sie es zunächst mit einer Mathe-Software aus, dann erhalten Sie einen Eindruck davon, was die Schrittgrößen sind und welche Löser funktionieren.

Viel Glück!