react.java

这是一个,用java写的物理仿真实验程序4

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   react.java

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.*;

public class react extends Applet
    implements Runnable
{

    Image offScreen;
    Image img1;
    Image img2;
    Image hand;
    AudioClip clip1;
    MediaTracker mt;
    Graphics offGraphics;
    Graphics g_this;
    Dimension dim1;
    Thread th;
    Color col;
    double x[][];
    double v[][];
    double dx[][][];
    double nrm[][][];
    double pow[][];
    double ik[][][];
    double im[][][];
    double r[][];
    double aa[][];
    double al[][];
    int ap[][];
    int colflag[][];
    int colflag2;
    double b[];
    double c[];
    double d[][];
    double x0[][];
    double mass[];
    double x1[][];
    double v1[][];
    double v2[][];
    double vn[][];
    double w[][];
    double w1[][];
    double va[];
    double f[][];
    double coef[] = {
        1.0D, 2D, 2D, 1.0D
    };
    boolean swa;
    boolean swb;
    boolean swc;
    boolean swd;
    int dim;
    int n;
    double dt;
    double time;
    int FONTSIZE1;
    int oldx[][];
    int oldnv[];
    double vtemp;
    double vi0;
    double vj0;
    double vi1;
    double vj1;
    double ui0;
    double uj0;
    double ui1;
    double uj1;
    Point pt0;
    int drawmode;
    int drawinitflag;
    int stepflag;
    int contpx;
    int contpy;
    int clipflag;
    int contnum;
    int num;
    int credflag;

    public void init()
    {
        Font f = new Font("TimesRoman", 0, FONTSIZE1);
        setFont(f);
        initrk();
        resize(600, 400);
        setBackground(col);
        dim1 = size();
        clip1 = getAudioClip(getCodeBase(), "clip1.au");
        img1 = getImage(getCodeBase(), "img1.gif");
        img2 = getImage(getCodeBase(), "img2.gif");
        hand = getImage(getCodeBase(), "hand.gif");
        mt.addImage(img1, 0);
        mt.addImage(img2, 0);
        mt.addImage(hand, 0);
        if(offScreen == null)
        {
            offScreen = createImage(dim1.width, dim1.height);
            offGraphics = offScreen.getGraphics();
        }
    }

    public void acce()
    {
        if(swa || swc)
        {
            for(int i = 0; i <= n; i++)
            {
                if(swa)
                {
                    for(int j = 0; j <= i; j++)
                    {
                        double fw = 0.0D;
                        for(int k = 0; k <= dim; k++)
                        {
                            if(i != j)
                            {
                                dx[i][j][k] = x1[i][k] - x1[j][k];
                                dx[j][i][k] = x1[j][k] - x1[i][k];
                            } else
                            {
                                dx[i][j][k] = x1[i][k] - x0[j][k];
                            }
                            fw += dx[i][j][k] * dx[i][j][k];
                        }

                        r[i][j] = Math.sqrt(fw);
                        for(int k = 0; k <= dim; k++)
                        {
                            if(r[i][j] != 0.0D)
                                nrm[i][j][k] = dx[i][j][k] / r[i][j];
                            else
                                nrm[i][j][0] = 1.0D;
                            if(i != j)
                                nrm[j][i][k] = -nrm[i][j][k];
                        }

                        r[j][i] = r[i][j];
                        if(i != j && ap[i][j] == 10)
                        {
                            if(r[i][j] < 50D && colflag[i][j] != 1)
                            {
                                vi0 = v[i][0] * nrm[i][j][0] + v[i][1] * nrm[i][j][1];
                                vi1 = -v[i][0] * nrm[i][j][1] + v[i][1] * nrm[i][j][0];
                                vj0 = v[j][0] * nrm[i][j][0] + v[j][1] * nrm[i][j][1];
                                vj1 = -v[j][0] * nrm[i][j][1] + v[j][1] * nrm[i][j][0];
                                ui0 = ((mass[i] - mass[j]) * vi0 + 2D * mass[j] * vj0) / (mass[i] + mass[j]);
                                ui1 = vi1;
                                uj0 = ((mass[j] - mass[i]) * vj0 + 2D * mass[i] * vi0) / (mass[i] + mass[j]);
                                uj1 = vj1;
                                v[i][0] = ui0 * nrm[i][j][0] - ui1 * nrm[i][j][1];
                                v[i][1] = ui0 * nrm[i][j][1] + ui1 * nrm[i][j][0];
                                v[j][0] = uj0 * nrm[i][j][0] - uj1 * nrm[i][j][1];
                                v[j][1] = uj0 * nrm[i][j][1] + uj1 * nrm[i][j][0];
                                colflag[i][j] = 1;
                                if(j == contnum)
                                    colflag2 = 1;
                                if(clipflag == 0)
                                    clipflag = 1;
                            }
                            if(r[i][j] >= 50D && colflag[i][j] == 1)
                                colflag[i][j] = 0;
                            if(r[i][j] >= 50D && colflag[i][j] == 0)
                            {
                                r[i][j] -= al[i][j];
                                r[j][i] = r[i][j];
                                pow[i][j] = r[i][j];
                            }
                        }
                        if(ap[i][j] == 2)
                        {
                            if(i == contnum)
                            {
                                if(x[i][0] > 275D)
                                    colflag2 = 1;
                                if(x[i][0] < -275D)
                                    colflag2 = 1;
                                if(x[i][1] > 175D)
                                    colflag2 = 1;
                                if(x[i][1] < -175D)
                                    colflag2 = 1;
                            }
                            if(x[i][0] > 275D)
                            {
                                v[i][0] *= -1D;
                                x[i][0] = 275D;
                                clipflag = 1;
                            }
                            if(x[i][0] < -275D)
                            {
                                v[i][0] *= -1D;
                                x[i][0] = -275D;
                                clipflag = 1;
                            }
                            if(x[i][1] > 175D)
                            {
                                v[i][1] *= -1D;
                                x[i][1] = 175D;
                                clipflag = 1;
                            }
                            if(x[i][1] < -175D)
                            {
                                v[i][1] *= -1D;
                                x[i][1] = -175D;
                                clipflag = 1;
                            }
                            if(r[i][j] > al[i][j])
                                pow[i][j] = r[i][j] - al[i][j];
                            else
                                pow[i][j] = 0.0D;
                        }
                        pow[i][j] = pow[i][j] * aa[i][j];
                        pow[j][i] = pow[i][j];
                    }

                }
                double fw1 = 0.0D;
                for(int k = 0; k <= dim; k++)
                    fw1 += v1[i][k] * v1[i][k];

                va[i] = Math.sqrt(fw1);
                for(int k = 0; k <= dim; k++)
                    if(va[i] != 0.0D)
                        vn[i][k] = v1[i][k] / va[i];

            }

        }
        for(int i = 0; i <= n; i++)
        {
            for(int k = 0; k <= dim; k++)
                f[i][k] = 0.0D;

        }

        for(int i = 0; i <= n; i++)
        {
            for(int k = 0; k <= dim; k++)
            {
                if(swa)
                {
                    for(int j = 0; j <= n; j++)
                        f[i][k] += pow[i][j] * nrm[i][j][k];

                }
                if(swb)
                    f[i][k] += b[i] * v1[i][k];
                if(swc)
                    f[i][k] += c[i] * va[i] * va[i] * vn[i][k];
                if(swd)
                    f[i][k] += d[i][k];
                f[i][k] /= mass[i];
            }

        }

    }

    public void rk()
    {
        for(int i = 0; i <= n; i++)
        {
            for(int k = 0; k <= dim; k++)
            {
                x1[i][k] = x[i][k];
                v1[i][k] = v[i][k];
                w[i][k] = 0.0D;
                w1[i][k] = 0.0D;
            }

        }

        acce();
        int l;
        for(l = 0; l <= 2; l++)
        {
            for(int i = 0; i <= n; i++)
            {
                for(int k = 0; k <= dim; k++)
                {
                    ik[l][i][k] = dt * v1[i][k];
                    im[l][i][k] = dt * f[i][k];
                    x1[i][k] = x[i][k] + ik[l][i][k] / coef[l + 1];
                    v1[i][k] = v[i][k] + im[l][i][k] / coef[l + 1];
                    w[i][k] += ik[l][i][k] * coef[l];
                    w1[i][k] += im[l][i][k] * coef[l];
                }

            }

            acce();
        }

        for(int i = 0; i <= n; i++)
        {
            for(int k = 0; k <= dim; k++)
            {
                ik[l][i][k] = dt * v1[i][k];
                im[l][i][k] = dt * f[i][k];
                x1[i][k] = x[i][k] + (w[i][k] + ik[3][i][k]) / 6D;
                v1[i][k] = v[i][k] + (w1[i][k] + im[3][i][k]) / 6D;
            }

        }

        for(int i = 0; i <= n; i++)
        {
            for(int k = 0; k <= dim; k++)
            {