Java中的微分方程 [英] Differential Equations in Java

问题描述

我正在尝试用Java创建一个简单的SIR-流行病模型仿真程序.

I am trying to create a simple simulation program of SIR-epidemics model in java.

基本上，SIR由三个微分方程的系统定义:
S'(t)=-l(t)* S(t)
I'(t)= l(t)* S(t)-g(t)* I(t)
R'(t)= g(t)* I(t)

Basically, SIR is defined by a system of three differential equations:
S'(t) = - l(t) * S(t)
I'(t) = l(t) * S(t) - g(t) * I(t)
R'(t) = g(t) * I(t)

S-易感人群，I-感染人群，R-康复人群.

S - susceptible people, I - infected people, R - recovered people.

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

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

c-接触人数，x-传染性(与患病人员接触后生病的可能性)，N(t)-总人口(不变).

c - number of contacts, x - infectiveness (probability to get sick after contact with sick person), N(t) - total population (which is constant).

如何在Java中求解此类微分方程?我认为我不知道有什么有用的方法，所以我的实现产生了垃圾.

How can I solve such differential equations in Java? I don't think I know any useful way to do that, so my implementation produces rubbish.

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

}

非常感谢您的帮助，在此先感谢您！

I would greatly appreciate any help, many thanks in advance!

推荐答案

时间序列微分方程可以通过数字化dt =一个小数字，并使用几个欧拉方法，或

Time-series differential equations can be simulated numerically by taking dt = a small number, and using one of several numerical integration techniques e.g. Euler's method, or Runge-Kutta. Euler's method may be primitive but it works OK for some equations and it's simple enough that you might give it a try. e.g.:

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

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

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

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

R'(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;
}

困难的部分是弄清楚要使用多少步骤.您应该阅读我链接到的文章之一.更复杂的微分方程求解器使用可变步长，以适应每一步的准确性/稳定性.

The tough part is figuring out how many steps to use. You should read one of the articles I have linked to. More sophisticated differential equation solvers use variable step sizes that adapt to accuracy/stability for each step.

我实际上建议使用R或Mathematica或MATLAB或Octave之类的数字软件，因为它们包含ODE求解器，您无需自己去解决所有麻烦.但是，如果您需要在较大的Java应用程序中执行此操作，则至少应首先使用数学软件进行尝试，然后才能了解步长是多少以及求解器的工作原理.

I would actually recommend using numerical software like R or Mathematica or MATLAB or Octave, as they include ODE solvers and you wouldn't need to go to all the trouble yourself. But if you need to do this as part of a larger Java application, at least try it out first with math software, then get a sense of what the step sizes are and what solvers work.

祝你好运！

这篇关于Java中的微分方程的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！