MongoDB $atan2

W MongoDB $atan2 Operator potoku agregacji zwraca arcus tangens (odwrotny tangens) jednej wartości podzielonej przez drugą.

Podajesz dwie wartości w tablicy. Każda z dwóch wartości dostarczonych do $atan2 może być dowolnym prawidłowym wyrażeniem, które prowadzi do liczby.

Zwracana wartość jest w radianach.

$atan2 operator został wprowadzony w MongoDB 4.2.

Przykład

Załóżmy, że mamy kolekcję o nazwie data z następującym dokumentem:

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

Możemy użyć $atan2 operator zwracający arcus tangens a pole podzielone przez b pole:

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

Wynik:

{ "arctangens" :0.5880026035475675 }

Konwertuj na stopnie

Jak wspomniano, $atan2 zwraca wynik w radianach. Możesz użyć $radiansToDegrees operatora, jeśli chcesz otrzymać wynik w stopniach.

Przykład:

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

Wynik:

{ "radiany" :0.5880026035475675, "stopnie" :33.690067525979785 }

W tym przykładzie pierwsze pole przedstawia wynik w radianach, a drugie pole przedstawia go w stopniach.

128-bitowe wartości dziesiętne

Domyślnie $atan2 operator zwraca wartości jako double , ale może również zwracać wartości jako 128-bitowe wartości dziesiętne, o ile wyrażenie daje wynik 128-bitowej wartości dziesiętnej.

Dzieje się tak nawet wtedy, gdy tylko jedno z wyrażeń jest 128-bitowym dziesiętnym.

Załóżmy, że do naszej kolekcji dodamy następujące dokumenty:

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

Uruchommy $atan2 operatora w stosunku do tych dokumentów:

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

Wynik:

{ "arctangens" :liczba dziesiętna("0.4877792766738730791507215461936449") }{ "arctangens" :liczba dziesiętna("0.7539075768401526572881006364456838") }{"arctangens" :liczba dziesiętna("0.8168887499547437619432") 
 We wszystkich przypadkach wyjście jest 128-bitowe po przecinku.
 Wartości puste
 
 Wartości null zwracają null podczas korzystania z $atan2 operator. Dzieje się tak, nawet jeśli jedynym z wyrażeń jest null .
 
 Załóżmy, że do naszej kolekcji dodamy następujące dokumenty:
 { "_id" :5, "a" :null, "b" :2 }{ "_id" :6, "a" :2, "b" :null }{ "_id" :7, "a " :2, "null" :null }
 
 Uruchommy $atan2 operatora w stosunku do tych dokumentów:
 db.data.aggregate(
  [
    { $match: { _id: { $in: [ 5, 6, 7 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" ] }
      }
    }
  ]
) 
 
 Wynik:
 { "arctangens" :null }{ "arctangens" :null }{ "arctangens" :null }
 
 Widzimy, że wynikiem jest null we wszystkich przypadkach. 
 Wartości NaN
 
 Jeśli argument ma postać NaN , $atan2 zwraca NaN .
 
 Przykład:
 db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a" * 1, "$b" ] }
      }
    }
  ]
) 
 
 Wynik:
 { "arctangens" :NumberDecimal("NaN") }{ "arctangens" :NumberDecimal("NaN") }{ "arctangens" :NaN }
 
 Zmieńmy to trochę, aby pomnożyć pole b zamiast pola a .
 db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a", "$b" * 1 ] }
      }
    }
  ]
) 
 
 Wynik:
 { "arctangens" :NumberDecimal("NaN") }{ "arctangens" :NaN }{ "arctangens" :NumberDecimal("NaN") }
 
 A teraz pomnóżmy oba pola:
 db.data.aggregate(
  [
    { $match: { _id: { $in: [ 2, 3, 4 ] } } },
    { $project: { 
        _id: 0,
        arctangent: { $atan2: [ "$a" * 1, "$b" * 1 ] }
      }
    }
  ]
) 
 
 Wynik:
 { "arctangens" :NaN }{ "arctangens" :NaN }{ "arctangens" :NaN }
 Nieistniejące pola
 
 Jeśli $atan2 operator jest stosowany do pola, które nie istnieje, null jest zwracany.
 
 Przykład:
 db.data.aggregate(
  [
    { $match: { _id: 1 } },
    { $project: { 
        _id: 0,
        result: { $atan2: [ "$a", "$name" ] }
      }
    }
  ]
) 
 
 Wynik:
 { "wynik" :null }