MongoDB में, $atan2 एग्रीगेशन पाइपलाइन ऑपरेटर एक मान के आर्कटेंगेंट (उलटा स्पर्शरेखा) को दूसरे से विभाजित करके लौटाता है।
आप एक सरणी में दो मान प्रदान करते हैं। $atan2 . को प्रदान किए गए दो मानों में से प्रत्येक कोई भी मान्य व्यंजक हो सकता है जो किसी संख्या का समाधान करता हो।
वापसी मूल्य रेडियन में है।
$atan2 ऑपरेटर को MongoDB 4.2 में पेश किया गया था।
उदाहरण
मान लीजिए हमारे पास data . नामक संग्रह है निम्नलिखित दस्तावेज़ के साथ:
{ "_id" :1, "a" :2, "b" :3 }
हम $atan2 . का उपयोग कर सकते हैं ऑपरेटर a . की चाप स्पर्शरेखा लौटाने के लिए b . से विभाजित फ़ील्ड फ़ील्ड:
db.data.aggregate(
[
{ $match: { _id: 1 } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a", "$b" ] }
}
}
]
) परिणाम:
{ "arctangent" :0.5880026035475675 } डिग्री में बदलें
जैसा कि बताया गया है, $atan2 रेडियन में अपना परिणाम देता है। आप $radiansToDegrees . का उपयोग कर सकते हैं यदि आप परिणाम डिग्री में चाहते हैं तो ऑपरेटर।
उदाहरण:
db.data.aggregate(
[
{ $match: { _id: 1 } },
{ $project: {
_id: 0,
radians: { $atan2: [ "$a", "$b" ] },
degrees: { $radiansToDegrees: { $atan2: [ "$a", "$b" ] } }
}
}
]
) परिणाम:
{ "रेडियन" :0.5880026035475675, "डिग्री" :33.690067525979785 } इस उदाहरण में, पहला फ़ील्ड परिणाम को रेडियन में प्रस्तुत करता है, और दूसरा फ़ील्ड इसे डिग्री में प्रस्तुत करता है।
128-बिट दशमलव मान
डिफ़ॉल्ट रूप से, $atan2 ऑपरेटर मानों को double . के रूप में लौटाता है , लेकिन यह 128-बिट दशमलव के रूप में भी मान लौटा सकता है, जब तक कि व्यंजक 128-बिट दशमलव मान पर हल हो जाता है।
यह तब भी होता है जब व्यंजकों में से केवल एक ही 128-बिट दशमलव होता है।
मान लीजिए हम अपने संग्रह में निम्नलिखित दस्तावेज़ जोड़ते हैं:
{ "_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 }
चलिए $atan2 चलाते हैं उन दस्तावेजों के खिलाफ ऑपरेटर:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4 ] } } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a", "$b" ] }
}
}
]
) परिणाम:
{ "arctangent" :NumberDecimal("0.4877792766738730791507215461936449") }{ "arctangent" :NumberDecimal("0.7539075768401526572881006364456838") }{ "arctangent" :NumberDecimal("0.81688431055474396")
सभी मामलों में, आउटपुट 128-बिट दशमलव है।
शून्य मान
शून्य मान null लौटाते हैं $atan2 . का उपयोग करते समय ऑपरेटर। यह सच है, भले ही केवल एक व्यंजक null . हो ।
मान लीजिए हम अपने संग्रह में निम्नलिखित दस्तावेज़ जोड़ते हैं:
{ "_id" :5, "a" :null, "b" :2 }{ "_id" :6, "a" :2, "b" :null }{ "_id" :7, "a " :2, "null" :null }
चलिए $atan2 चलाते हैं उन दस्तावेजों के खिलाफ ऑपरेटर:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 5, 6, 7 ] } } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a", "$b" ] }
}
}
]
)
परिणाम:
{ "arctangent" :null }{ "arctangent" :null }{ "arctangent" :null }
हम देख सकते हैं कि परिणाम null है सभी मामलों में।
NaN मान
अगर तर्क का समाधान NaN . हो जाता है , $atan2 रिटर्न NaN ।
उदाहरण:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4 ] } } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a" * 1, "$b" ] }
}
}
]
)
परिणाम:
{ "arctangent" :NumberDecimal("NaN") }{ "arctangent" :NumberDecimal("NaN") }{ "arctangent" :NaN }
आइए इसे थोड़ा बदल दें, ताकि हम b field फ़ील्ड को गुणा करें फ़ील्ड के बजाय a ।
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4 ] } } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a", "$b" * 1 ] }
}
}
]
)
परिणाम:
{ "arctangent" :NumberDecimal("NaN") }{ "arctangent" :NaN }{ "arctangent" :NumberDecimal("NaN") }
और अब दोनों क्षेत्रों को गुणा करते हैं:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4 ] } } },
{ $project: {
_id: 0,
arctangent: { $atan2: [ "$a" * 1, "$b" * 1 ] }
}
}
]
)
परिणाम:
{ "arctangent" :NaN }{ "arctangent" :NaN }{ "arctangent" :NaN } गैर-मौजूद फ़ील्ड
अगर $atan2 ऑपरेटर को उस फ़ील्ड के विरुद्ध लागू किया जाता है जो मौजूद नहीं है, null लौटा दिया गया है।
उदाहरण:
db.data.aggregate(
[
{ $match: { _id: 1 } },
{ $project: {
_id: 0,
result: { $atan2: [ "$a", "$name" ] }
}
}
]
)
परिणाम:
{ "result" :null }
