Differentialgleichungen in Java

Question

Ich versuche, ein einfaches Simulationsprogramm von SIR-Epidemien Modell in Java zu erstellen.

Grundsätzlich ist 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 - Infizierten, R -. Erholen Menschen

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

c - Anzahl der Kontakte, x - Infektiosität (Wahrscheinlichkeit krank nach dem Kontakt mit Kranken zu bekommen), N (t.) - Gesamtbevölkerung (die konstant)

Wie kann ich eine solche Differentialgleichungen in Java lösen? Ich glaube nicht, ich weiß, irgendeine nützliche Art und Weise, das zu tun, so meine Implementierung Müll 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 würde sehr schätzen jede mögliche Hilfe, vielen Dank im Voraus!

Answer 1

Zeitreihendifferentialgleichungen kann, indem man dt = eine kleine Zahl numerisch simuliert werden, und unter Verwendung eines von mehreren numerischen Integrationstechniken zB Eulersche Methode oder Runge-Kutta . Eulers Methode primitiv sein, aber es funktioniert OK für einige Gleichungen und es ist einfach genug, dass man es versuchen könnte. z.

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. Sie sollten einen der Artikel habe ich gelesen zu verknüpft haben. Ausgefeiltere variable Schrittgrößen verwendet Gleichung Löser Differential, die für jeden Schritt, um die Genauigkeit / Stabilität anzupassen.

würde ich tatsächlich mit numerischen Software wie R oder Mathematica oder MATLAB oder Octave empfehlen, da sie ODE Solver sind und Sie würden nicht, sich die Mühe zu gehen. Aber wenn Sie dies als Teil einer größeren Java-Anwendung tun, zumindest versuchen Sie es zuerst mit Mathematik-Software, dann bekommt ein Gefühl dafür, was die Schrittgrößen sind und was Löser Arbeit.

Viel Glück!