1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

  procedure TOsz.nextStep(var s: Single; var v: Single);
  var
    Fa, Fb, Fc, Fd: Array[0..1] of Single;
    omega, z1, z2: Single;
  begin
    omega := - D / m;
    z1 := s;
    z2 := v;

    //############ Klassisches Runge-Kutta-Verfahren ############
    //# w1 = f(v[i], t[i])                                      #
    //# w2 = f(v[i] + h * w1 / 2, t + h / 2)                    #
    //# w3 = f(v[i] + h * w2 / 2, t + h / 2)                    #
    //# w4 = f(v[i] + h * w3, t + h)                            #
    //# v[i+1] = v[i] + h / 6 * (w1 + (2 * w2) + (2 * w3) + w4) #
    //###########################################################

    Fa[0] := z2;
    Fa[1] := omega * z1;

    Fb[0] := z2 + (h / 2) * Fa[1];
    Fb[1] := omega * (z1 + (h / 2) * Fa[0]);

    Fc[0] := z2 + (h / 2) * Fb[1];
    Fc[1] := omega * (z1 + (h / 2) * Fa[0]);

    Fd[0] := z2 + h * Fc[1];
    Fd[1] := omega * (z1 + h * Fc[0]);

    s := s + (h / 6) * (Fa[0] + (2 * Fb[0]) + (2 * Fc[0]) + Fd[0]);
    v := v + (h / 6) * (Fa[1] + (2 * Fb[1]) + (2 * Fc[1]) + Fd[1]);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

  for i := 0 to AnzahlOsz - 1 do
  begin
    BuffS[i] := OszS[i];  //OszS -> Auslenkung des i-ten Schwingers
    BuffV[i] := OszV[i];  //OszV -> Geschwindigkeit
  end;
  
  if AnzahlOsz > 1 then         //AnzahlOsz: Konstanter Wert für die Anzahl der Schwinger
  begin

    //Falls mehrere Osz. vorliegen, werden die "Federn" nicht mehr zum 0-Wert gespannt,
    //sondern zu den Nachbarn.

    //Für einen ersten Test hielt ich es für unsinnig mit dem Pythagoras rumzufuchteln, 
    //daher werden im Folgenden nur Differenzen berechnet.

    //Die Buffer (BuffS und BuffV) sollen verhindern, dass beim einmaligen Durchlaufen der
    //Reihe nicht schon direkt Werte bis nach Hinten weitergegeben werden
    //Beispiel: 
    // 1 0 0 0 0 0     <- Jeder soll den halben Wert des Vorgängers annehmen
    //Ohne Buffer:
    // 1 1/2 1/4 1/8 usw.   (direkt beim ersten Durchlauf werden alle Werte gebildet)

    //Mit Buffer:           (Ausfüllen in mehreren Schritten)
    // 1 1/2 0 0 0 0
    // 1 1/2 1/4 0 0 0
    // 1 1/2 1/4 1/8 0 0
    // usw ... 
    

    for i := 0 to AnzahlOsz - 1 do
    begin
      if (i = 0) then         //Beim ersten Oszillator: berücksichtige nur den nächsten
      begin
        OszS[i] := OszS[i] - BuffS[i + 1];
        Osz.nextStep(OszS[i], OszV[i]);
        OszS[i] := OszS[i] + BuffS[i + 1];
      end;

      if (i > 0) and (i < AnzahlOsz - 1) then     //Alles dazwischen
      begin
        OszS[i] := 2 * OszS[i] - BuffS[i - 1] - BuffS[i + 1];
        Osz.nextStep(OszS[i], OszV[i]);
        OszS[i] := 0.5 * (OszS[i] + BuffS[i - 1] + BuffS[i + 1]);
      end;

      if (i = AnzahlOsz - 1) then        //Nur den vorherigen berücksichtigen
      begin
        OszS[i] := OszS[i] - BuffS[i - 1];
        Osz.nextStep(OszS[i], OszV[i]);
        OszS[i] := OszS[i] + BuffS[i - 1];
      end;
    end;
  end
  else
    Osz.nextStep(OszS[0], OszV[0]);      //Falls nur ein Schwinger vorliegt