Les équations différentielles en Java

Question

Je suis en train de créer un programme de simulation simple du modèle SIR-épidémies en java.

Fondamentalement, SIR est défini par un système de trois équations différentielles:
S '(t) = - l (t) * S (t)
I '(t) = l (t) * S (t) - g (t) * I (t)
R '(t) = g (t) * I (t)

S - personnes sensibles, I - personnes infectées, R -. Personnes récupérées

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

c - nombre de contacts, x - infectiosité (probabilité de tomber malade après contact avec la personne malade), N (t) -. Population totale (qui est constante)

Comment puis-je résoudre ces équations différentielles en Java? Je ne pense pas que je sais tout moyen utile de le faire, donc ma mise en œuvre produit des déchets.

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); 
    }
}

}

J'apprécierais beaucoup d'aide, un grand merci à l'avance!

Answer 1

équations différentielles séries chronologiques peuvent être simulées numériquement en prenant dt = un petit nombre, et en utilisant l'un de plusieurs numérique techniques d'intégration par exemple méthode d'Euler ou Runge-Kutta . La méthode d'Euler peut être primitive, mais il fonctionne bien pour certaines équations et il est assez simple que vous pourriez essayer. par exemple:.

  

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;
}

La partie difficile est de déterminer combien d'étapes à utiliser. Vous devriez lire l'un des articles que j'ai liés à. équations différentielles plus sophistiquées solveurs utilisent des tailles de pas variables qui s'adaptent à la précision / stabilité pour chaque étape.

Je recommande en fait l'utilisation de logiciels numériques comme R ou Mathematica ou Matlab ou Octave, comme ils comprennent solveurs ODE et vous auriez pas besoin d'aller à tous les problèmes vous-même. Mais si vous avez besoin de le faire dans le cadre d'une application Java plus grande, au moins essayer d'abord avec un logiciel de mathématiques, alors avoir une idée de ce que les pas sont et ce solveurs travail.

Bonne chance!