MongoDB $stdDevPop

En MongoDB, el $stdDevPop El operador de tubería de agregación calcula la desviación estándar de la población de sus valores de entrada.

Los valores de entrada pueden ser de un grupo de documentos (es decir, documentos que están agrupados por la misma clave), o pueden ser varios campos dentro de un solo documento.

Sintaxis

El $stdDevPop operador admite dos sintaxis.

Sintaxis 1:

{ $stdDevPop: <expression> }

Sintaxis 2:

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

La primera sintaxis acepta un argumento y la segunda sintaxis acepta múltiples argumentos.

Cuando se usa en el $group etapa, solo puede usar la primera sintaxis. En este caso, $stdDevPop devuelve la desviación estándar de población de la expresión especificada para un grupo de documentos que comparten el mismo grupo por clave.

Ejemplos de sintaxis 1 (argumento único)

Aquí hay un par de ejemplos que usan la sintaxis 1.

Documentos agrupados

Este ejemplo usa $stdDevPop junto con $group para devolver la desviación estándar en un grupo de documentos que están agrupados por clave.

Supongamos que tenemos una colección llamada stonks con los siguientes 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 estos documentos por su ticker y luego use $stdDevPop para devolver la desviación estándar de la población del 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 tiene una desviación estándar mucho más alta que jnj .

Arreglos

Este ejemplo aplica $stdDevPop a un solo documento que contiene un campo con una matriz de valores.

Esta opción solo está disponible cuando se utiliza la sintaxis de argumento único. Las matrices se ignoran cuando se usa la sintaxis de múltiples argumentos (más sobre esto a continuación).

Supongamos que tenemos una colección llamada players con los siguientes 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 a las scores campo en 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 }

En este caso, los tres primeros documentos arrojaron la desviación estándar de los distintos números que estaban en sus respectivas matrices.

El documento 4 dio como resultado una desviación estándar de 0 . Esto se debe a que solo proporcionamos un número en la matriz.

El documento 5 devolvió null porque proporcionamos una matriz vacía.

El documento 6 devolvió null porque proporcionamos null como argumento.

Ejemplo de sintaxis 2 (múltiples argumentos)

La segunda sintaxis consiste en proporcionar $stdDevPop con más de un argumento. $stdDevPop luego calcula la desviación estándar en función de todos los argumentos proporcionados.

Supongamos que tenemos una colección llamada data con los siguientes 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 devolver la desviación estándar de la población de a , b , c y 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 }

El documento 1 devuelve la desviación estándar en función de sus valores de entrada de 1 , 2 , 3 y 4 .

Sin embargo, los últimos dos documentos solo devolvieron la desviación estándar para los valores de entrada de 1 , 2 y 3 . El $stdDevPop el operador ignoró su d los campos.

¿Por qué es esto?

La forma en que funciona es que $stdDevPop ignora los valores no numéricos. Entonces, en este caso, ignoró "Hey" en el documento 3 y calculó la desviación estándar de la población de los campos (numéricos) restantes.

En cuanto al documento 2, es d campo contiene una matriz. Como se mencionó, el $stdDevPop El operador ignora las matrices cuando usa la sintaxis de múltiples argumentos. Más precisamente, trata las matrices como valores no numéricos cuando se usa en este contexto. Y como se mencionó, $stdDevPop ignora los valores no numéricos.

Si todos los valores no son numéricos, entonces $stdDevPop devuelve null .

Campos faltantes

Al usar la sintaxis de varios argumentos, $stdDevPop ignora cualquier campo faltante. Es decir, si proporciona un campo que no existe, lo ignora. Si ninguno de los campos existe, devuelve null .

Ejemplo:

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 }

En este caso proporcioné un campo extra ($e ) que no existe en el documento. $stdDevPop calculó la desviación estándar en función de los campos restantes que hacen existir.

Sin embargo, esto es lo que sucede cuando ninguno de los campos existen:

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

Resultado:

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

El resultado es null para todos los documentos.

Cuando se usa la sintaxis de argumento único, un campo faltante da como resultado null .

Ejemplo:

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

Resultado:

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

Etapas disponibles

$stdDevPop está disponible en las siguientes etapas:

$group
$project
$addFields
$set
$replaceRoot
$replaceWith
$match etapa que incluye un $expr expresión

Calcular la desviación estándar de la muestra

Ver MongoDB $stdDevSamp si necesita obtener la muestra desviación estándar, a diferencia de la población Desviación Estándar. Este operador es útil si sus valores abarcan una muestra de una población de datos a partir de la cual generalizar sobre la población.