MongoDB $atan2

Dans MongoDB, le $atan2 l'opérateur de pipeline d'agrégation renvoie l'arctangente (tangente inverse) d'une valeur divisée par une autre.

Vous fournissez les deux valeurs dans un tableau. Chacune des deux valeurs fournies à $atan2 peut être n'importe quelle expression valide qui se résout en un nombre.

La valeur de retour est en radians.

Le $atan2 L'opérateur a été introduit dans MongoDB 4.2.

Exemple

Supposons que nous ayons une collection appelée data avec le document suivant :

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

Nous pouvons utiliser le $atan2 opérateur pour retourner l'arc tangente du a champ divisé par le b champ :

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

Résultat :

{ "arctangent" : 0.5880026035475675 }

Convertir en degrés

Comme mentionné, $atan2 renvoie son résultat en radians. Vous pouvez utiliser le $radiansToDegrees opérateur si vous voulez le résultat en degrés.

Exemple :

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

Résultat :

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

Dans cet exemple, le premier champ présente le résultat en radians et le second le présente en degrés.

Valeurs décimales 128 bits

Par défaut, le $atan2 l'opérateur renvoie les valeurs sous la forme d'un double , mais il peut également renvoyer des valeurs sous la forme d'un décimal de 128 bits tant que l'expression se résout en une valeur décimale de 128 bits.

C'est le cas même lorsqu'une seule des expressions est décimale 128 bits.

Supposons que nous ajoutions les documents suivants à notre collection :

{ "_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 }

Exécutons le $atan2 opérateur contre ces documents :

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

Résultat :

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

Dans tous les cas, la sortie est décimale 128 bits.

Valeurs nulles

Les valeurs nulles renvoient null lors de l'utilisation du $atan2 opérateur. Ceci est vrai même si la seule des expressions est null .

Supposons que nous ajoutions les documents suivants à notre collection :

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

Exécutons le $atan2 opérateur contre ces documents :

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

Résultat :

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

Nous pouvons voir que le résultat est null dans tous les cas.

Valeurs NaN

Si l'argument se résout en NaN , $atan2 renvoie NaN .

Exemple :

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

Résultat :

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

Modifions-le légèrement, afin de multiplier le champ b au lieu du champ a .

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

Résultat :

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

Et maintenant multiplions les deux champs :

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

Résultat :

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

Champs inexistants

Si le $atan2 l'opérateur est appliqué sur un champ qui n'existe pas, null est renvoyé.

Exemple :

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

Résultat :

{ "result" : null }