データの要約

要約統計量を計算します。

count(iterable, accessor)

d3.count(penguins, (d) => d.body_mass_g) // 342

例 · ソース · 指定されたiterable内の有効な数値（つまり、null、NaN、またはundefinedではない）の数を返します。アクセサを受け入れます。

min(iterable, accessor)

例 · ソース · 自然順序を使用して、与えられたiterableの最小値を返します。

d3.min([3, 2, 1, 1, 6, 2, 4]) // 1

Math.minとは異なり、d3.minは入力を数値に強制変換しません。たとえば、文字列["20", "3"]の最小値は"20"であり、数値[20, 3]の最小値は3です。

d3.min(["bob", "alice", "carol"]) // "alice"

d3.min([new Date("2018-01-01"), new Date("2011-03-09")]) // 2011-03-09

また、Math.minとは異なり、このメソッドはundefined、null、およびNaN値を無視します。これは、欠落データを無視するのに役立ちます。

d3.min([3, 2, 1, NaN, 4]) // 1

オプションのアクセサ関数を指定できます。これは、最小値を計算する前にArray.fromを呼び出すのと似ています。アクセサ関数は、与えられた反復可能オブジェクト（多くの場合d）とゼロベースのインデックス（i）から要素が繰り返し渡されます。

d3.min(alphabet, (d) => d.frequency) // 0.00074

undefined値は無視されるため、アクセサ関数を使用して値を無視できます。たとえば、Zではない最も頻度の低い文字の頻度を取得するには

d3.min(alphabet, (d) => d.letter === "Z" ? NaN : d.frequency) // 0.00095

反復可能オブジェクトに比較可能な値が含まれていない場合は、undefinedを返します。

d3.min([]) // undefined

d3.min(alphabet, (d) => d.doesnotexist) // undefined

extentおよびleastも参照してください。

minIndex(iterable, accessor)

ソース · minと同様ですが、値自体ではなく最小値のインデックスを返します。

d3.minIndex([3, 2, 1, 1, 6, 2, 4]) // 2

このメソッドは、leastと同様に、指定されたアクセサに従って最小の要素を見つけることができます。

d3.minIndex(alphabet, (d) => d.frequency) // 25

alphabet[d3.minIndex(alphabet, (d) => d.frequency)] // {letter: "Z", frequency: 0.00074}

leastIndexも参照してください。

max(iterable, accessor)

例 · ソース · 自然順序を使用して、与えられたiterableの最大値を返します。

d3.max([3, 2, 1, 1, 6, 2, 4]) // 6

Math.maxとは異なり、d3.maxは入力を数値に強制変換しません。たとえば、文字列["20", "3"]の最大値は"3"であり、数値[20, 3]の最大値は20です。

d3.max(["bob", "alice", "carol"]) // "carol"

d3.max([new Date("2018-01-01"), new Date("2011-03-09")]) // 2018-01-01

また、Math.maxとは異なり、このメソッドはundefined、null、およびNaN値を無視します。これは、欠落データを無視するのに役立ちます。

d3.max([3, 2, 1, NaN, 4]) // 4

オプションのアクセサ関数を指定できます。これは、最大値を計算する前にArray.fromを呼び出すのと似ています。アクセサ関数は、与えられた反復可能オブジェクト（多くの場合d）とゼロベースのインデックス（i）から要素が繰り返し渡されます。

d3.max(alphabet, (d) => d.frequency) // 0.12702

undefined値は無視されるため、アクセサ関数を使用して値を無視できます。たとえば、Eではない最も頻度の高い文字の頻度を取得するには

d3.max(alphabet, (d) => d.letter === "E" ? NaN : d.frequency) // 0.09056

反復可能オブジェクトに比較可能な値が含まれていない場合は、undefinedを返します。

d3.max([]) // undefined

d3.max(alphabet, (d) => d.doesnotexist) // undefined

extentおよびgreatestも参照してください。

maxIndex(iterable, accessor)

ソース · maxと同様ですが、値自体ではなく最大値のインデックスを返します。

d3.maxIndex([3, 2, 1, 1, 6, 2, 4]) // 2

このメソッドは、greatestと同様に、指定されたアクセサに従って最大の要素を見つけることができます。

d3.maxIndex(alphabet, (d) => d.frequency) // 0

alphabet[d3.maxIndex(alphabet, (d) => d.frequency)] // {letter: "E", frequency: 0.12702}

greatestIndexも参照してください。

least(iterable, comparator)

例 · ソース · 指定されたコンパレータに従って、指定されたiterableの最小要素を返します。

d3.least(alphabet, (a, b) => a.frequency - b.frequency) // {letter: "Z", frequency: 0.00074}

d3.least(alphabet, (a, b) => b.frequency - a.frequency) // {letter: "E", frequency: 0.12702}

コンパレータが単一の引数を取る場合、アクセサとして解釈され、返された要素は自然順序を使用して比較されます。

d3.least(alphabet, (d) => d.frequency) // {letter: "Z", frequency: 0.00074}

d3.least(alphabet, (d) => -d.frequency) // {letter: "E", frequency: 0.12702}

コンパレータが指定されていない場合は、ascendingがデフォルトになります。

d3.least(alphabet.map((d) => d.frequency)) // 0.00074

与えられたiterableに比較可能な要素が含まれていない場合（つまり、コンパレータが各要素をそれ自体と比較したときにNaNを返す場合）、undefinedを返します。

d3.least([]) // undefined

この関数は、アクセサではなくコンパレータの使用を許可する点を除いて、minに似ています。

leastIndex(iterable, comparator)

ソース · 指定されたコンパレータまたはアクセサに従って、指定されたiterableの最小要素のインデックスを返します。与えられたiterableに比較可能な要素が含まれていない場合（つまり、コンパレータが各要素をそれ自体と比較したときにNaNを返す場合）、-1を返します。コンパレータが指定されていない場合は、ascendingがデフォルトになります。例

const array = [{foo: 42}, {foo: 91}];
d3.leastIndex(array, (a, b) => a.foo - b.foo); // 0
d3.leastIndex(array, (a, b) => b.foo - a.foo); // 1
d3.leastIndex(array, (d) => d.foo); // 0

この関数は、アクセサではなくコンパレータの使用を許可する点を除いて、minIndexに似ています。

greatest(iterable, comparator)

例 · ソース · 指定されたコンパレータまたはアクセサに従って、指定されたiterableの最大要素を返します。与えられたiterableに比較可能な要素が含まれていない場合（つまり、コンパレータが各要素をそれ自体と比較したときにNaNを返す場合）、undefinedを返します。コンパレータが指定されていない場合は、ascendingがデフォルトになります。例

const array = [{foo: 42}, {foo: 91}];
d3.greatest(array, (a, b) => a.foo - b.foo); // {foo: 91}
d3.greatest(array, (a, b) => b.foo - a.foo); // {foo: 42}
d3.greatest(array, (d) => d.foo); // {foo: 91}

この関数は、アクセサではなくコンパレータの使用を許可する点を除いて、maxに似ています。

greatestIndex(iterable, comparator)

ソース · 指定されたコンパレータまたはアクセサに従って、指定されたiterableの最大要素のインデックスを返します。与えられたiterableに比較可能な要素が含まれていない場合（つまり、コンパレータが各要素をそれ自体と比較したときにNaNを返す場合）、-1を返します。コンパレータが指定されていない場合は、ascendingがデフォルトになります。例

const array = [{foo: 42}, {foo: 91}];
d3.greatestIndex(array, (a, b) => a.foo - b.foo); // 1
d3.greatestIndex(array, (a, b) => b.foo - a.foo); // 0
d3.greatestIndex(array, (d) => d.foo); // 1

この関数は、アクセサではなくコンパレータの使用を許可する点を除いて、maxIndexに似ています。

extent(iterable, accessor)

例 · ソース · 自然順序を使用して、与えられたiterableの最小値と最大値を返します。

d3.extent([3, 2, 1, 1, 6, 2, 4]) // [1, 6]

オプションのアクセサ関数を指定できます。これは、範囲を計算する前にArray.fromを呼び出すのと同等です。

d3.extent(alphabet, (d) => d.frequency) // [0.00074, 0.12702]

反復可能オブジェクトに比較可能な値が含まれていない場合は、[undefined, undefined]を返します。

d3.extent(alphabet, (d) => d.doesnotexist) // [undefined, undefined]

mode(iterable, accessor)

例 · ソース · 与えられたiterableの最頻値を返します。つまり、最も頻繁に表示される値。undefined、null、およびNaN値を無視します。

d3.mode([1, 2, 2, 2, 3, 3]) // 2

オプションのアクセサ関数を指定できます。これは、最頻値を計算する前にArray.fromを呼び出すのと同等です。

d3.mode(penguins, (d) => d.island) // "Biscoe"

等しい場合は、関連する値の最初の値を返します。反復可能オブジェクトに比較可能な値が含まれていない場合は、undefinedを返します。

sum(iterable, accessor)

例 · ソース · 与えられた数値のiterableの合計を返します。undefined、null、NaNの値は無視されます。

d3.sum([1, 2, 2, 2, NaN, 3, null]) // 10

オプションのaccessor関数を指定できます。これは合計を計算する前にArray.fromを呼び出すのと同じです。

d3.sum(penguins, (d) => d.body_mass_g) // 1437000

iterableに数値が含まれない場合は、0を返します。 fsumも参照してください。

mean(iterable, accessor)

例 · ソース · 与えられた数値のiterableの平均を返します。undefined、null、NaNの値は無視されます。

d3.mean([1, 2, 2, 2, NaN, 3, null]) // 2

オプションのaccessor関数を指定できます。これは平均を計算する前にArray.fromを呼び出すのと同じです。

d3.mean(penguins, (d) => d.body_mass_g) // 4201.754385964912

iterableに数値が含まれない場合は、undefinedを返します。

median(iterable, accessor)

例 · ソース · R-7法を使用して、与えられた数値のiterableの中央値を返します。undefined、null、NaNの値は無視されます。

d3.median([1, 2, 2, 2, NaN, 3, null]) // 2

オプションのaccessor関数を指定できます。これは中央値を計算する前にArray.fromを呼び出すのと同じです。

d3.median(penguins, (d) => d.body_mass_g) // 4050

iterableに数値が含まれない場合は、undefinedを返します。

medianIndex(array, accessor)

ソース · medianと同様ですが、中央値の左側の要素のインデックスを返します。

d3.medianIndex([1, 2, 2, 2, NaN, 3, null]) // 2

cumsum(iterable, accessor)

例 · ソース · 与えられた数値のiterableの累積和を、同じ長さのFloat64Arrayとして返します。

d3.cumsum([1, 1, 2, 3, 5]) // [1, 2, 4, 7, 12]

オプションのaccessor関数を指定できます。これは累積和を計算する前にArray.fromを呼び出すのと同じです。

d3.cumsum(penguins, (d) => d.body_mass_g) // [3750, 7550, 10800, 10800, …]

このメソッドはundefinedとNaNの値を無視します。これは欠損データを無視するのに役立ちます。iterableに数値が含まれない場合は、ゼロを返します。 fcumsumも参照してください。

quantile(iterable, p, accessor)

例 · ソース · 与えられた数値のiterableのp-分位数を返します。ここで、pは[0, 1]の範囲の数値です。たとえば、中央値はp = 0.5を使用して、第1四分位数はp = 0.25、第3四分位数はp = 0.75で計算できます。この特定の実装では、R-7法を使用しています。これは、Rプログラミング言語とExcelのデフォルトです。

const numbers = [0, 10, 30];
d3.quantile(numbers, 0); // 0
d3.quantile(numbers, 0.5); // 10
d3.quantile(numbers, 1); // 30
d3.quantile(numbers, 0.25); // 5
d3.quantile(numbers, 0.75); // 20
d3.quantile(numbers, 0.1); // 2

オプションのaccessor関数を指定できます。これは分位数を計算する前にarray.mapを呼び出すのと同じです。

quantileIndex(array, p, accessor)

ソース · quantileと同様ですが、pの左側のインデックスを返します。

quantileSorted(array, p, accessor)

例 · ソース · quantileと同様ですが、入力がソートされた値のarrayであることを想定しています。quantileとは対照的に、アクセサーは分位数を計算するために必要な要素でのみ呼び出されます。

rank(iterable, comparator)

例 · ソース · iterable内の各値の順位、つまりiterableがソートされたときの値のゼロベースのインデックスを持つ配列を返します。nullish値は最後にソートされ、NaNとランク付けされます。オプションのcomparatorまたはaccessor関数を指定できます。後者は、ランクを計算する前にarray.mapを呼び出すのと同じです。comparatorが指定されていない場合は、デフォルトでascendingになります。タイ（同等の値）はすべて同じランクを取得します。これは、値が最初に見つかったときとして定義されます。

d3.rank([{x: 1}, {}, {x: 2}, {x: 0}], d => d.x); // [1, NaN, 2, 0]
d3.rank(["b", "c", "b", "a"]); // [1, 3, 1, 0]
d3.rank([1, 2, 3], d3.descending); // [2, 1, 0]

variance(iterable, accessor)

例 · ソース · 母分散の不偏推定量を、ウェルフォードのアルゴリズムを使用して、与えられた数値のiterableに対して返します。iterableに2つ未満の数値がある場合は、undefinedを返します。オプションのaccessor関数を指定できます。これは分散を計算する前にArray.fromを呼び出すのと同じです。このメソッドはundefinedとNaNの値を無視します。これは欠損データを無視するのに役立ちます。

deviation(iterable, accessor)

例 · ソース · 与えられた数値のiterableのバイアス補正された分散の平方根として定義された標準偏差を返します。iterableに2つ未満の数値がある場合は、undefinedを返します。オプションのaccessor関数を指定できます。これは標準偏差を計算する前にArray.fromを呼び出すのと同じです。このメソッドはundefinedとNaNの値を無視します。これは欠損データを無視するのに役立ちます。

every(iterable, test)

ソース · 与えられたtest関数が、与えられたiterableのすべての値に対してtrueを返す場合はtrueを返します。このメソッドは、testが非真の値を返すか、すべての値が反復処理されたらすぐに返します。array.everyと同じです

d3.every(new Set([1, 3, 5, 7]), x => x & 1) // true

some(iterable, test)

ソース · 与えられたtest関数が、与えられたiterableのいずれかの値に対してtrueを返す場合はtrueを返します。このメソッドは、testが真の値を返すか、すべての値が反復処理されたらすぐに返します。array.someと同じです

d3.some(new Set([0, 2, 3, 4]), x => x & 1) // true