En MongoDB, el $stdDevSamp El operador de tubería de agregación calcula la desviación estándar de la muestra de los 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.
$stdDevSamp es similar a $stdDevPop . La diferencia es que $stdDevSamp calcula la muestra desviación estándar, mientras que $stdDevPop calcula la población desviación estándar.
Por lo tanto, use $stdDevSamp si sus valores abarcan una muestra de una población de datos a partir de la cual generalizar sobre la población. Si los valores representan toda la población de datos o no desea generalizar sobre una población mayor, use $stdDevPop en su lugar.
Sintaxis
El $stdDevSamp operador admite dos sintaxis.
Sintaxis 1:
{ $stdDevSamp: <expression> }Sintaxis 2:
{ $stdDevSamp: [ <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, $stdDevSamp devuelve la desviación estándar de muestra 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 $stdDevSamp junto con $group para devolver la desviación estándar de la muestra 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 $stdDevSamp para devolver la desviación estándar de la muestra del price campo para cada grupo:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$price" }
}
}
]
)Resultado:
{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }
Podemos ver que gme tiene una desviación estándar de muestra mucho más alta que jnj .
Arreglos
Este ejemplo aplica $stdDevSamp 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 $stdDevSamp a las scores campo en cada documento:
db.players.aggregate(
[
{
$project:
{
result: { $stdDevSamp: "$scores" }
}
}
]
)Resultado:
{ "_id" : 1, "result" : 3.0783421635988546 }
{ "_id" : 2, "result" : 7.633260552782583 }
{ "_id" : 3, "result" : 5.988878581726855 }
{ "_id" : 4, "result" : null }
{ "_id" : 5, "result" : null }
{ "_id" : 6, "result" : null } En este caso, los primeros tres documentos devolvieron la desviación estándar de la muestra para los diversos números que estaban en sus respectivas matrices.
El documento 4 dio como resultado una desviación estándar de null . Esto se debe a que solo proporcionamos un número en la matriz. Si hubiéramos usado $stdDevPop , esto habría devuelto 0 .
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 $stdDevSamp con más de un argumento. $stdDevSamp 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 $stdDevSamp para devolver la desviación estándar de la muestra del a , b , c y d campos de cada documento:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultado:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
El resultado del primer documento se basa en los valores de entrada de 1 , 2 , 3 y 4 .
Sin embargo, los dos últimos documentos dieron como resultado solo 1 , 2 y 3 siendo evaluado. El $stdDevSamp el operador ignoró su d los campos.
El $stdDevSamp 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 muestra de los campos (numéricos) restantes.
En cuanto al documento 2, es d campo contiene una matriz. Como se mencionó, el $stdDevSamp 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ó, $stdDevSamp ignora los valores no numéricos.
Si todos los valores no son numéricos, entonces $stdDevSamp devuelve null .
Campos faltantes
Al usar la sintaxis de varios argumentos, $stdDevSamp 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: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Resultado:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
En este caso proporcioné un campo extra ($e ) que no existe en el documento. $stdDevSamp calculó la desviación estándar de la muestra 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: { $stdDevSamp: [ "$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",
result: { $stdDevSamp: "$oops!" }
}
}
]
)Resultado:
{ "_id" : "gme", "result" : null }
{ "_id" : "jnj", "result" : null } Etapas disponibles
$stdDevSamp está disponible en las siguientes etapas:
$group$project$addFields$set$replaceRoot$replaceWith$matchetapa que incluye un$exprexpresión
