MongoDB $atan2

En MongoDB, el $atan2 El operador de canalización de agregación devuelve la arcotangente (tangente inversa) de un valor dividido por otro.

Usted proporciona los dos valores en una matriz. Cada uno de los dos valores proporcionados a $atan2 puede ser cualquier expresión válida que se resuelva en un número.

El valor de retorno está en radianes.

El $atan2 El operador se introdujo en MongoDB 4.2.

Ejemplo

Supongamos que tenemos una colección llamada data con el siguiente documento:

{ "_id" : 1, "a" : 2, "b" : 3 }

Podemos usar el $atan2 operador para devolver el arcotangente del a campo dividido por b campo:

db.data.aggregate(
  [
    { $match: { _id: 1 } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : 0.5880026035475675 }

Convertir a Grados

Como se mencionó, $atan2 devuelve su resultado en radianes. Puede usar el $radiansToDegrees operador si desea el resultado en grados.

Ejemplo:

db.data.aggregate(
  [
    { $match: { _id: 1 } },
    { $project: { 
        _id: 0,
        radians: { $atan2: [ "$a", "$b" ] },
        degrees: { $radiansToDegrees: { $atan2: [ "$a", "$b" ] } }
      }
    }
  ]
)

Resultado:

{ "radians" : 0.5880026035475675, "degrees" : 33.690067525979785 }

En este ejemplo, el primer campo presenta el resultado en radianes y el segundo campo lo presenta en grados.

Valores decimales de 128 bits

Por defecto, el $atan2 el operador devuelve valores como double , pero también puede devolver valores como un decimal de 128 bits siempre que la expresión se resuelva en un valor decimal de 128 bits.

Este es el caso incluso cuando solo una de las expresiones es decimal de 128 bits.

Supongamos que agregamos los siguientes documentos a nuestra colección:

{ "_id" : 2, "a" : NumberDecimal("1.1301023541559787031443874490659"), "b" : NumberDecimal("2.1301023541559787031443874490659") }
{ "_id" : 3, "a" : 2, "b" : NumberDecimal("2.1301023541559787031443874490659") }
{ "_id" : 4, "a" : NumberDecimal("2.1301023541559787031443874490659"), "b" : 2 }

Ejecutemos el $atan2 operador contra esos documentos:

db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : NumberDecimal("0.4877792766738730791507215461936449") }
{ "arctangent" : NumberDecimal("0.7539075768401526572881006364456838") }
{ "arctangent" : NumberDecimal("0.8168887499547439619432210551940676") }

En todos los casos, la salida es decimal de 128 bits.

Valores nulos

Los valores nulos devuelven null cuando se usa $atan2 operador. Esto es cierto incluso si la única de las expresiones es null .

Supongamos que agregamos los siguientes documentos a nuestra colección:

{ "_id" : 5, "a" : null, "b" : 2 }
{ "_id" : 6, "a" : 2, "b" : null }
{ "_id" : 7, "a" : 2, "null" : null }

Ejecutemos el $atan2 operador contra esos documentos:

db.data.aggregate(
  [
    { $match: { _id: { $in: [ 5, 6, 7 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : null }
{ "arctangent" : null }
{ "arctangent" : null }

Podemos ver que el resultado es null en todos los casos.

Valores NaN

Si el argumento se resuelve en NaN , $atan2 devuelve NaN .

Ejemplo:

db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a" * 1, "$b" ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : NumberDecimal("NaN") }
{ "arctangent" : NumberDecimal("NaN") }
{ "arctangent" : NaN }

Cambiémoslo ligeramente, para que multipliquemos el campo b en lugar del campo a .

db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" * 1 ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : NumberDecimal("NaN") }
{ "arctangent" : NaN }
{ "arctangent" : NumberDecimal("NaN") }

Y ahora multipliquemos ambos campos:

db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a" * 1, "$b" * 1 ] }
      }
    }
  ]
)

Resultado:

{ "arctangent" : NaN }
{ "arctangent" : NaN }
{ "arctangent" : NaN }

Campos Inexistentes

Si el $atan2 el operador se aplica a un campo que no existe, null es devuelto.

Ejemplo:

db.data.aggregate(
  [
    { $match: { _id: 1 } },
    { $project: { 
        _id: 0,
        result: { $atan2: [ "$a", "$name" ] }
      }
    }
  ]
)

Resultado:

{ "result" : null }