MongoDB $ atan2

In MongoDB, il $atan2 l'operatore della pipeline di aggregazione restituisce l'arcotangente (tangente inversa) di un valore diviso per un altro.

Fornisci i due valori in una matrice. Ognuno dei due valori forniti a $atan2 può essere qualsiasi espressione valida che si risolve in un numero.

Il valore restituito è in radianti.

Il $atan2 operatore è stato introdotto in MongoDB 4.2.

Esempio

Supponiamo di avere una raccolta chiamata data con il seguente documento:

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

Possiamo usare il $atan2 operatore per restituire l'arcotangente di a campo diviso per il b campo:

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

Risultato:

{ "arctangent" : 0.5880026035475675 }

Converti in gradi

Come accennato, $atan2 restituisce il suo risultato in radianti. Puoi usare $radiansToDegrees operatore se vuoi il risultato in gradi.

Esempio:

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

Risultato:

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

In questo esempio, il primo campo presenta il risultato in radianti e il secondo campo lo presenta in gradi.

Valori decimali a 128 bit

Per impostazione predefinita, il $atan2 l'operatore restituisce i valori come double , ma può anche restituire valori come decimali a 128 bit, purché l'espressione si risolva in un valore decimale a 128 bit.

Questo è il caso anche quando solo una delle espressioni è decimale a 128 bit.

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

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

Eseguiamo il $atan2 operatore contro tali documenti:

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

Risultato:

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

In tutti i casi, l'uscita è decimale a 128 bit.

Valori Nulli

I valori Null restituiscono null quando si utilizza il $atan2 operatore. Questo è vero anche se l'unica delle espressioni è null .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

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

Eseguiamo il $atan2 operatore contro tali documenti:

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

Risultato:

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

Possiamo vedere che il risultato è null in tutti i casi.

Valori NaN

Se l'argomento si risolve in NaN , $atan2 restituisce NaN .

Esempio:

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

Risultato:

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

Modifichiamolo leggermente, in modo da moltiplicare il campo b invece del campo a .

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

Risultato:

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

E ora moltiplichiamo entrambi i campi:

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

Risultato:

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

Campi inesistenti

Se il $atan2 operatore viene applicato a un campo che non esiste, null viene restituito.

Esempio:

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

Risultato:

{ "result" : null }