Was ist der beste Weg, um zu berechnen, Verbleibende download-Zeit?

Könnten Sie einen Algorithmus zur Berechnung der Mittelwerte, wo die alten Werte Verfall Linear. Wenn S_n ist die Geschwindigkeit zum Zeitpunkt n und A_{n-1} ist der Durchschnitt zum Zeitpunkt n-1, dann definieren Sie Ihre mittlere Geschwindigkeit wie folgt.

A_1 = S_1

A_2 = (S_1 + S_2)/2

A_n = S_n/(n-1) + A_{n-1}(1-1/(n-1))

In Englisch, bedeutet dies, dass die länger in der Vergangenheit eine Messung aufgetreten, ist das weniger wichtig, weil Ihre Bedeutung abgeklungen ist.

Vergleichen Sie dies mit dem normalen Algorithmus zur Berechnung der Mittelwerte:
A_n = S_n/n + A_{n-1}(1-1/n)

Könnte man auch geometrisch Zerfall, die würden das Gewicht der jüngsten Geschwindigkeiten sehr stark:
A_n = S_n/2 + A_{n-1}/2

Wenn die Geschwindigkeiten sind dann 4,3,5,6
A_4 saiaźpcd im Dienst = 4.5 (Durchschnitt)

A_4 saiaźpcd im Dienst = 4.75 (linear decay)

A_4 saiaźpcd im Dienst = 5.125 (geometrische decay)

Beispiel in PHP

Beachten Sie, dass $n+1 (nicht $n) ist die aktuelle Anzahl der Datenpunkte aufgrund der PHP-arrays null-indiziert. Entsprechend der obigen Beispiel-set n == $n+1 oder n-1 == $n

<?php

$s = [4,3,5,6];

//average
$a = [];
for ($n = 0; $n < count($s); ++$n)
{
    if ($n == 0)
        $a[$n] = $s[$n];
    else
    {
        //$n+1 = number of data points so far
        $weight = 1/($n+1);

        $a[$n] = $s[$n] * $weight + $a[$n-1] * (1 - $weight);
    }
}

var_dump($a);


//linear decay
$a = [];
for ($n = 0; $n < count($s); ++$n)
{
    if ($n == 0)
        $a[$n] = $s[$n];

    elseif ($n == 1)
        $a[$n] = ($s[$n] + $s[$n-1]) /2;

    else
    {
        //$n = number of data points so far - 1
        $weight = 1/($n);

        $a[$n] = $s[$n] * $weight + $a[$n-1] * (1 - $weight);
    }
}

var_dump($a);


//geometric decay
$a = [];
for ($n = 0; $n < count($s); ++$n)
{
    if ($n == 0)
        $a[$n] = $s[$n];
    else
    {
        $weight = 1/2;

        $a[$n] = $s[$n] * $weight + $a[$n-1] * (1 - $weight);
    }
}

var_dump($a);

Ausgabe

array (size=4)
  0 => int 4
  1 => float 3.5
  2 => float 4
  3 => float 4.5

array (size=4)
  0 => int 4
  1 => float 3.5
  2 => float 4.25
  3 => float 4.8333333333333

array (size=4)
  0 => int 4
  1 => float 3.5
  2 => float 4.25
  3 => float 5.125

Ich denke, es ist nur ein Algorithmus zur Berechnung der Mittelwerte. Es Durchschnitt die rate über ein paar Sekunden.

EDIT: Hier ist, was ich schließlich vorschlagen, ich habe es ausprobiert und es sieht ganz befriedigende Ergebnisse:

Habe ich eine null initialisiert Arrays für jede download-Geschwindigkeit zwischen 0 - 500 kB/s (könnte höher sein, wenn Sie erwarten, dass solche Geschwindigkeiten) in 1 kB/s-Schritten.
Ich Probe die download-Geschwindigkeit momentan (jeder zweite ist ein gutes Intervall), und die Schrittweite in der jeweiligen array-Element von einem.
Jetzt weiß ich, wie viele Sekunden habe ich damit verbracht, die Datei herunterzuladen, bei jeder Drehzahl. Die Summe all dieser Werte ist die verstrichene Zeit (in Sekunden). Die Summe dieser Werte multipliziert mit der entsprechenden Geschwindigkeit ist die Größe heruntergeladen, so weit.
Wenn ich das Verhältnis zwischen jedem einzelnen Wert im array und die verstrichene Zeit, vorausgesetzt, die variation der Drehzahl Muster stabalizes, ich kann die form einer Formel zur Vorhersage der Zeit jede Größe nehmen. Diese Größe ist in diesem Fall, die Größe der übrigen. Das ist, was ich Tue:
Ich nehme die Summe der einzelnen array-Element mit dem Wert multipliziert mit der entsprechenden Geschwindigkeit (Speed-index) und dividiert durch die verstrichene Zeit. Dann Teile ich die Größe Links von diesem Wert, und das ist die Zeit Links.

Dauert ein paar Sekunden stabalize, und arbeitet dann sehr verdammt gut.

Beachten Sie, dass dies ein "kompliziertes" im Durchschnitt, so die Methode verwerfen, ältere Werte (gleitender Durchschnitt) verbessern könnte es sogar noch weiter.