Что лучший способ состоит в том, чтобы вычислить остающееся время загрузки?

Ну, как вы сказали, использование абсолютно текущей скорости загрузки не очень хороший метод, потому что она имеет тенденцию колебаться. Однако что-то вроде общего среднего также не очень хорошая идея, потому что там также могут быть большие колебания.

Подумайте, начну ли я загружать файл одновременно с 9 другими. Я получаю только 10% от моей нормальной скорости, но в середине файла, остальные 9 финишируют. Теперь я загружаю со скоростью 10x, с которой я начал. Моя первоначальная скорость 10% не должна быть фактором, определяющим, «сколько времени осталось?» расчет больше.

Лично я, вероятно, взял бы среднее за последние 30 секунд или около того, и использовал бы это. Это должны делать расчеты, основанные на недавней скорости, без колебаний. 30 секунд, возможно, не правильное количество, потребовались бы некоторые эксперименты, чтобы вычислить хорошую сумму.

Другой вариант - установить своего рода «порог флуктуации», при котором вы не будете пересчитывать, пока скорость не изменится более чем на этот порог. Например (случайное число, опять же, потребует экспериментов), вы можете установить порог в 10%. Затем, если вы загружаете со скоростью 100 кбит / с, вы не пересчитываете оставшееся время до тех пор, пока скорость загрузки не изменится ниже 90 кбит / с или 110 кбит / с. Если происходит одно из этих изменений, время пересчитывается и устанавливается новый порог.

потребует экспериментов), вы можете установить порог в 10%. Затем, если вы загружаете со скоростью 100 кбит / с, вы не пересчитываете оставшееся время до тех пор, пока скорость загрузки не изменится ниже 90 кбит / с или 110 кбит / с. Если происходит одно из этих изменений, время пересчитывается и устанавливается новый порог.

потребует экспериментов), вы можете установить порог в 10%. Затем, если вы загружаете со скоростью 100 кбит / с, вы не пересчитываете оставшееся время до тех пор, пока скорость загрузки не изменится ниже 90 кбит / с или 110 кбит / с. Если происходит одно из этих изменений, время пересчитывается и устанавливается новый порог.

Вы можете использовать алгоритм усреднения, при котором старые значения затухают линейно. Если S_n - это скорость в момент времени n, а A_ {n-1} - это среднее значение в момент времени n-1, определите свою среднюю скорость следующим образом.

A_1 = S_1
A_2 = (S_1 + S_2) / 2
A_n = S_n / (n-1) + A_ {n-1} (1-1 / (n-1))

На английском языке это означает, что чем дольше в прошлом проводилось измерение, тем меньше оно имеет значение, потому что его значение уменьшилось. Сравните это с обычным алгоритмом усреднения: A_n = S_n / n + A_ {n-1} (1-1 / n)

Вы также можете иметь его геометрическое затухание, которое очень сильно отразится на последних скоростях: A_n = S_n / 2 + A_ {n-1} / 2

Если скорости равны 4,3,5,6, то A_4 = 4,5 (простое среднее)
A_4 = 4,75 (линейный распад)
A_4 = 5.125 (геометрическое затухание)

Пример в PHP

Обратите внимание, что $ n + 1 (не $ n ) - это число текущих точек данных из-за массивов PHP будучи нулевым индексом. Для соответствия приведенному выше примеру установите n == $ n + 1 или 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);

. Выведите

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

Я думаю, что это просто алгоритм усреднения. Усредняет скорость за несколько секунд.

Очевидный путь - что-то среднее: вам нужно «скользящее среднее» скорости загрузки.

Что вы можете сделать, так это отслеживать свою среднюю скорость и показывать ее расчет.

РЕДАКТИРОВАТЬ: Вот что я, наконец, предлагаю, я попробовал, и это дает вполне удовлетворительные результаты:

У меня есть инициализированный нулем массив для каждой скорости загрузки от 0 до 500 кБ / с (может быть выше, если вы ожидаете такие скорости) с шагом 1 кБ / с. Я мгновенно определяю скорость загрузки (каждая секунда - хороший интервал) и увеличиваю элемент массива, отвечающий за ядро, на единицу. Теперь я знаю, сколько секунд я потратил на загрузку файла на каждой скорости. Сумма всех этих значений представляет собой прошедшее время (в секундах). Сумма этих значений, умноженная на соответствующую скорость, является размером, загруженным до сих пор. Если я возьму соотношение между каждым значением в массиве и истекшее время, предполагая, что шаблон изменения скорости стабилизируется, я могу сформировать формулу для прогнозирования времени, которое займет каждый размер. Этот размер в данном случае является оставшимся размером. Это то, чем я занимаюсь: Я беру сумму каждого значения элемента массива, умноженную на соответствующую скорость (индекс) и разделенную на прошедшее время. Затем я делю размер, оставленный на это значение, и это оставшееся время.

Занимает несколько секунд, чтобы стабилизировать, а затем чертовски хорошо работает.

Обратите внимание, что это «сложное» среднее, поэтому метод Отказ от старых значений (скользящее среднее) может улучшить его еще больше.