MongoDB $stdDevPop

No MongoDB, o $stdDevPop o operador de pipeline de agregação calcula o desvio padrão da população de seus valores de entrada.

Os valores de entrada podem ser de um grupo de documentos (ou seja, documentos agrupados pela mesma chave) ou podem ser vários campos em um único documento.

Sintaxe

O $stdDevPop O operador suporta duas sintaxes.

Sintaxe 1:

{ $stdDevPop: <expression> }

Sintaxe 2:

{ $stdDevPop: [ <expression1>, <expression2> ... ]  }

A primeira sintaxe aceita um argumento e a segunda sintaxe aceita vários argumentos.

Quando usado no $group stage, você só pode usar a primeira sintaxe. Neste caso, $stdDevPop retorna o desvio padrão da população da expressão especificada para um grupo de documentos que compartilham o mesmo grupo por chave.

Exemplos de sintaxe 1 (argumento único)

Aqui estão alguns exemplos que usam a sintaxe 1.

Documentos agrupados

Este exemplo usa $stdDevPop em conjunto com $group para retornar o desvio padrão em um grupo de documentos agrupados por chave.

Suponha que tenhamos uma coleção chamada stonks com os seguintes documentos:

{ "_id" : 1, "ticker" : "gme", "price" : 10 }
{ "_id" : 2, "ticker" : "gme", "price" : 40 }
{ "_id" : 3, "ticker" : "gme", "price" : 90 }
{ "_id" : 4, "ticker" : "gme", "price" : 180 }
{ "_id" : 5, "ticker" : "gme", "price" : 290 }
{ "_id" : 6, "ticker" : "gme", "price" : 390 }
{ "_id" : 7, "ticker" : "gme", "price" : 190 }
{ "_id" : 8, "ticker" : "gme", "price" : 90 }
{ "_id" : 9, "ticker" : "gme", "price" : 10 }
{ "_id" : 10, "ticker" : "jnj", "price" : 131 }
{ "_id" : 11, "ticker" : "jnj", "price" : 133 }
{ "_id" : 12, "ticker" : "jnj", "price" : 138 }
{ "_id" : 13, "ticker" : "jnj", "price" : 141 }
{ "_id" : 14, "ticker" : "jnj", "price" : 145 }
{ "_id" : 15, "ticker" : "jnj", "price" : 150 }
{ "_id" : 16, "ticker" : "jnj", "price" : 154 }
{ "_id" : 17, "ticker" : "jnj", "price" : 156 }
{ "_id" : 18, "ticker" : "jnj", "price" : 160 }

Podemos agrupar esses documentos por seu ticker campo e, em seguida, use $stdDevPop para retornar o desvio padrão da população do price campo para cada grupo:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$price" }
          }
     }
   ]
)

Resultado:

{ "_id" : "gme", "standardDeviation" : 123.7380746218039 }
{ "_id" : "jnj", "standardDeviation" : 9.752492558885207 }

Podemos ver que gme tem um desvio padrão muito maior do que jnj .

Matrizes

Este exemplo se aplica a $stdDevPop para um único documento que contém um campo com uma matriz de valores.

Esta opção só está disponível ao usar a sintaxe de argumento único. As matrizes são ignoradas ao usar a sintaxe de vários argumentos (mais sobre isso abaixo).

Suponha que tenhamos uma coleção chamada players com os seguintes documentos:

{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 7, 2, 3, 8, 7, 1 ] }
{ "_id" : 2, "player" : "Marge", "scores" : [ 0, 1, 8, 17, 18, 8 ] }
{ "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8, 0, 1, 3 ] }
{ "_id" : 4, "player" : "Brian", "scores" : [ 7 ] }
{ "_id" : 5, "player" : "Farnsworth", "scores" : [ ] }
{ "_id" : 6, "player" : "Meg", "scores" : null }

Podemos aplicar $stdDevPop para as scores campo em cada documento:

db.players.aggregate(
   [
     {
       $project:
          {
            standardDeviation: { $stdDevPop: "$scores" }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "standardDeviation" : 2.849991049037143 }
{ "_id" : 2, "standardDeviation" : 6.968181653455625 }
{ "_id" : 3, "standardDeviation" : 5.467073155618908 }
{ "_id" : 4, "standardDeviation" : 0 }
{ "_id" : 5, "standardDeviation" : null }
{ "_id" : 6, "standardDeviation" : null }

Nesse caso, os três primeiros documentos retornaram o desvio padrão para os diversos números que estavam em suas respectivas matrizes.

O documento 4 resultou em um desvio padrão de 0 . Isso ocorre porque fornecemos apenas um número na matriz.

O documento 5 retornou null porque fornecemos um array vazio.

O documento 6 retornou null porque fornecemos null como o argumento.

Exemplo de sintaxe 2 (vários argumentos)

A segunda sintaxe envolve fornecer $stdDevPop com mais de um argumento. $stdDevPop em seguida, calcula o desvio padrão com base em todos os argumentos fornecidos.

Suponha que tenhamos uma coleção chamada data com os seguintes documentos:

{ "_id" : 1, "a" : 1, "b" : 2, "c" : 3, "d" : 4 }
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 4 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "Hey" }

Podemos usar $stdDevPop para retornar o desvio padrão da população de a , b , c e d campos de cada documento:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

O documento 1 retorna o desvio padrão com base em seus valores de entrada de 1 , 2 , 3 e 4 .

No entanto, os dois últimos documentos retornaram apenas o desvio padrão para valores de entrada de 1 , 2 e 3 . O $stdDevPop operador ignorou seu d Campos.

Por que é isso?

A maneira como funciona é que $stdDevPop ignora valores não numéricos. Então, neste caso, ele ignorou "Hey" no documento 3 e calculou o desvio padrão da população dos demais campos (numéricos).

Quanto ao documento 2, seu d campo contém uma matriz. Como mencionado, o $stdDevPop O operador ignora matrizes ao usar a sintaxe de vários argumentos. Mais precisamente, trata arrays como valores não numéricos quando usados neste contexto. E como mencionado, $stdDevPop ignora valores não numéricos.

Se todos os valores não forem numéricos, então $stdDevPop retorna null .

Campos ausentes

Ao usar a sintaxe de vários argumentos, $stdDevPop ignora quaisquer campos ausentes. Ou seja, se você fornecer um campo que não existe, ele o ignora. Se nenhum dos campos existir, ele retornará null .

Exemplo:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

Neste caso forneci um campo extra ($e ) que não existe no documento. $stdDevPop calculou o desvio padrão com base nos campos restantes que fazem existir.

No entanto, veja o que acontece quando nenhum dos campos existem:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$x", "$y", "$z" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }

O resultado é null para todos os documentos.

Ao usar a sintaxe de argumento único, um campo ausente resulta em null .

Exemplo:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$oops!" }
          }
     }
   ]
)

Resultado:

{ "_id" : "gme", "standardDeviation" : null }
{ "_id" : "jnj", "standardDeviation" : null }

Etapas disponíveis

$stdDevPop está disponível nas seguintes etapas:

$group
$project
$addFields
$set
$replaceRoot
$replaceWith
$match estágio que inclui um $expr expressão

Calcular o desvio padrão da amostra

Veja MongoDB $stdDevSamp se você precisar obter a amostra desvio padrão, em oposição à população desvio padrão. Esse operador é útil se seus valores abrangerem uma amostra de uma população de dados a partir da qual generalizar sobre a população.