web-dev-qa-db-ja.com

中央値の計算-JavaScript

私はmedianを計算しようとしましたが、正しい中央値を取得できず、理由がわからなかったため、数学的問題を抱えています。コードは次のとおりです。

class StatsCollector {

    constructor() {
        this.inputNumber = 0;
        this.average = 0;

        this.timeout = 19000;

        this.frequencies = new Map();
        for (let i of Array(this.timeout).keys()) {
            this.frequencies.set(i, 0);
        }
    }

    pushValue(responseTimeMs) {
        let req = responseTimeMs;
        if (req > this.timeout) {
            req = this.timeout;
        }

        this.average = (this.average * this.inputNumber + req) / (this.inputNumber + 1);

        console.log(responseTimeMs / 1000)
        let groupIndex = Math.floor(responseTimeMs / 1000);
        this.frequencies.set(groupIndex, this.frequencies.get(groupIndex) + 1);

        this.inputNumber += 1;
    }

    getMedian() {
        let medianElement = 0;
        if (this.inputNumber <= 0) {
            return 0;
        }
        if (this.inputNumber == 1) {
            return this.average
        }
        if (this.inputNumber == 2) {
            return this.average
        }
        if (this.inputNumber > 2) {
            medianElement = this.inputNumber / 2;
        }

        let minCumulativeFreq = 0;
        let maxCumulativeFreq = 0;
        let cumulativeFreq = 0;
        let freqGroup = 0;
        for (let i of Array(20).keys()) {
            if (medianElement <= cumulativeFreq + this.frequencies.get(i)) {
                minCumulativeFreq = cumulativeFreq;
                maxCumulativeFreq = cumulativeFreq + this.frequencies.get(i);
                freqGroup = i;
                break;
            }
            cumulativeFreq += this.frequencies.get(i);
        }

        return (((medianElement - minCumulativeFreq) / (maxCumulativeFreq - minCumulativeFreq)) + (freqGroup)) * 1000;
    }

    getAverage() {
        return this.average;
    }

}

以下の値を入力したときの結果のスナップショットです

342,654,987,1093,2234,6243,7087,20123

enter image description here

正しい結果は次のとおりです。

中央値：1663.5

javascriptmedian
14
Muhammed Bayram

中央値メソッドをこれに変更します。

function median(values){
  if(values.length ===0) return 0;

  values.sort(function(a,b){
    return a-b;
  });

  var half = Math.floor(values.length / 2);

  if (values.length % 2)
    return values[half];

  return (values[half - 1] + values[half]) / 2.0;
}

フィドル

24
jdmdevdotnet

上記の解決策-ソートして中央を見つける-は問題ありませんが、大きなデータセットでは低速です。最初にデータを並べ替えるには、n x log（n）の複雑さがあります。

より高速な中央値アルゴリズムがあります。これは、ピボットに従って配列を2つに分離し、より大きなセットの中央値を探すことです。以下にJavaScriptコードを示しますが、 詳細な説明はこちら

// Trying some array
alert(quickselect_median([7,3,5])); // 2300,5,4,0,123,2,76,768,28]));

function quickselect_median(arr) {
   const L = arr.length, halfL = L/2;
   if (L % 2 == 1)
      return quickselect(arr, halfL);
   else
      return 0.5 * (quickselect(arr, halfL - 1) + quickselect(arr, halfL));
}

function quickselect(arr, k) {
   // Select the kth element in arr
   // arr: List of numerics
   // k: Index
   // return: The kth element (in numerical order) of arr
   if (arr.length == 1)
      return arr[0];
   else {
      const pivot = arr[0];
      const lows = arr.filter((e)=>(e<pivot));
      const highs = arr.filter((e)=>(e>pivot));
      const pivots = arr.filter((e)=>(e==pivot));
      if (k < lows.length) // the pivot is too high
         return quickselect(lows, k);
      else if (k < lows.length + pivots.length)// We got lucky and guessed the median
         return pivot;
      else // the pivot is too low
         return quickselect(highs, k - lows.length - pivots.length);
   }
}

気の利いた読者は、いくつかのことに気付くでしょう。

  1. 私は単にラッセル・コーエンのPythonソリューションをJSに音訳しました。
  2. 実行する価値のある小さな最適化がいくつかありますが、実行する価値のある並列化があり、コードは、より高速なシングルスレッド版またはより高速なマルチスレッド版のいずれかで変更しやすいです。
  3. これは、平均線形時間アルゴリズムであり、より効率的な決定論的線形時間バージョン。パフォーマンスデータを含む詳細については、 Russelの投稿 を参照してください。

2019年9月19日：

1つのコメントは、これがjavascriptで行う価値があるかどうかを尋ねます。 JSPerf でコードを実行すると、興味深い結果が得られます。

  • 配列の要素の数が奇数の場合（検索する1つの数字）、ソートはこの「高速中央値」命題より20％遅くなります。

  • 偶数個の要素がある場合、「高速」アルゴリズムは40％遅くなります。これは、データを2回フィルタリングして、平均する要素番号kおよびk + 1を見つけるためです。これを行わないバージョンの高速中央値を記述することは可能です。

このテストでは、かなり小さな配列（jsperfテストの29要素）を使用しました。配列が大きくなるにつれて、効果はより顕著になります。より一般的なポイントは、これらの種類の最適化がJavascriptで行う価値があることを示しています。 JSでは、大量のデータ（ダッシュボード、スプレッドシート、データの視覚化など）やリソースが限られたシステム（モバイルコンピューティングや組み込みコンピューティングなど）を含む、非常に多くの計算が行われます。

1
boisvert

`

var arr = {  
  max: function(array) {
    return Math.max.apply(null, array);
  },

  min: function(array) {
    return Math.min.apply(null, array);
  },

  range: function(array) {
    return arr.max(array) - arr.min(array);
  },

  midrange: function(array) {
    return arr.range(array) / 2;
  },

  sum: function(array) {
    var num = 0;
    for (var i = 0, l = array.length; i < l; i++) num += array[i];
    return num;
  },

  mean: function(array) {
    return arr.sum(array) / array.length;
  },

  median: function(array) {
    array.sort(function(a, b) {
      return a - b;
    });
    var mid = array.length / 2;
    return mid % 1 ? array[mid - 0.5] : (array[mid - 1] + array[mid]) / 2;
  },

  modes: function(array) {
    if (!array.length) return [];
    var modeMap = {},
      maxCount = 1,
      modes = [array[0]];

    array.forEach(function(val) {
      if (!modeMap[val]) modeMap[val] = 1;
      else modeMap[val]++;

      if (modeMap[val] > maxCount) {
        modes = [val];
        maxCount = modeMap[val];
      }
      else if (modeMap[val] === maxCount) {
        modes.Push(val);
        maxCount = modeMap[val];
      }
    });
    return modes;
  },

  variance: function(array) {
    var mean = arr.mean(array);
    return arr.mean(array.map(function(num) {
      return Math.pow(num - mean, 2);
    }));
  },

  standardDeviation: function(array) {
    return Math.sqrt(arr.variance(array));
  },

  meanAbsoluteDeviation: function(array) {
    var mean = arr.mean(array);
    return arr.mean(array.map(function(num) {
      return Math.abs(num - mean);
    }));
  },

  zScores: function(array) {
    var mean = arr.mean(array);
    var standardDeviation = arr.standardDeviation(array);
    return array.map(function(num) {
      return (num - mean) / standardDeviation;
    });
  }
};

`

1
Dps

別のソリューションを次に示します。

function median(numbers) {
    const sorted = numbers.slice().sort((a, b) => a - b);
    const middle = Math.floor(sorted.length / 2);

    if (sorted.length % 2 === 0) {
        return (sorted[middle - 1] + sorted[middle]) / 2;
    }

    return sorted[middle];
}

console.log(median([4, 5, 7, 1, 33]));
1
JBallin