मैं कुछ वेक्टर तर्क पर काम कर रहा हूं, इसलिए मैं पूछ रहा हूं: क्या मैं इस असमानता को सरल करके प्रोसेसर समय बचा सकता हूं:
distance(vector1, vector2) < distance(vector1, vector3)
मैं देखता हूं कि vector1
दोनों मामलों में दोहराया जाता है।
मैं कुछ वेक्टर तर्क पर काम कर रहा हूं, इसलिए मैं पूछ रहा हूं: क्या मैं इस असमानता को सरल करके प्रोसेसर समय बचा सकता हूं:
distance(vector1, vector2) < distance(vector1, vector3)
मैं देखता हूं कि vector1
दोनों मामलों में दोहराया जाता है।
जवाबों:
हां , आप इसे सरल बना सकते हैं। सबसे पहले, उन्हें वैक्टर कहना बंद करें। वे बिंदु हैं। चलो उन्हें बुलाओ A
, B
और C
।
तो, आप यह चाहते हैं:
dist(A, B) < dist(A, C)
वर्गों के साथ दूरी को बदलें, फिर डॉट उत्पादों के साथ (की परिभाषा से) यूक्लिडियन लंबाई )। (अब ये असली वैक्टर हैं) के AC
साथ बदलें AB + BC
। विस्तार, सरलीकरण, कारक:
dist(A, B)² < dist(A, C)²
dot(AB, AB) < dot(AC, AC)
dot(AB, AB) < dot(AB + BC, AB + BC)
dot(AB, AB) < dot(AB, AB) + dot(BC, BC) + 2 dot(AB, BC)
0 < dot(BC, BC) + 2 dot(AB, BC)
0 < dot(BC + 2 AB, BC)
तुम यहां हो:
dot(AB + AC, BC) > 0
अपने वेक्टर संकेतन के साथ:
dot(v2 - v1 + v3 - v1, v3 - v2) > 0
यह पिछले दो डॉट उत्पादों के बजाय कुछ अतिरिक्त और एक डॉट उत्पाद है।
dist(A, B)²
ही है तो dot(AB, AB)
यह यूक्लिडियन लंबाई की परिभाषा से आता है ।
हाँ।मान लें कि आपका distance
फ़ंक्शन एक वर्गमूल का उपयोग करता है, तो आप वर्गमूल को हटाकर इसे सरल कर सकते हैं।
दूरी के बड़े (या छोटे) को खोजने की कोशिश करते समय, x^2 > y^2
अभी भी सही है x > y
।
हालाँकि, गणितीय समीकरण को सरल बनाने के और प्रयास निरर्थक हैं। के बीच की दूरी vector1
और vector2
के बीच की दूरी के रूप में ही नहीं है vector1
और vector3
। जबकि सैम के उत्तर के रूप में समीकरण को गणितीय रूप से सरल बनाया जा सकता है , यह वर्तमान में जिस रूप में संभव है वह उतना ही सरल है जितना आप प्रोसेसर के परिप्रेक्ष्य से प्राप्त करेंगे।
कुछ गणित मदद कर सकता है।
आप क्या करने की कोशिश कर रहे हैं:
<v1, v2> < <v1, v3> =>
sqrt((y2-y1)^2+(x2-x1)^2) < sqrt((y3-y1)^2+(x3-x1)^2) =>
y2^2 - 2*y2y1 + y1^2 + x2^2 - 2*x2x1 + x1^2 < y3^2 - 2*y3y1 + y1^2 + x3^2 - 2*x3x1 + x1^2
क्या आप दोहराया चर हटा सकते हैं और कुछ अन्य लोगों को समूह से। आपको जो ऑपरेशन करना है, वह है:
y3^2 - y2^2 - 2*y1(y3-y2) + x3^2 - x2^2 - 2*x1(x3-x2) > 0
आशा करता हूँ की ये काम करेगा।
वास्तविक प्रश्न यह प्रतीत होता है कि निकटतम वस्तु के निर्धारण के लिए अभिकलन को कैसे कम किया जाए?
इसका अनुकूलन अक्सर खेलों में किया जाता है, हालांकि सभी अनुकूलन के साथ इसे प्रोफ़ाइल-निर्देशित किया जाना चाहिए और, अक्सर, चीजों को सरल नहीं करता है ।
निकटतम चीज़ को निर्धारित करने के लिए अनावश्यक दूरी की गणना से बचने का तरीका - या एक निश्चित सीमा के भीतर सभी चीजें - एक स्थानिक सूचकांक का उपयोग करना है जैसे एक ऑक्ट्री ।
यह केवल तभी भुगतान करता है जब बड़ी संख्या में ऑब्जेक्ट होते हैं। सिर्फ तीन वस्तुओं के लिए, यह भुगतान करने की संभावना नहीं है और निश्चित रूप से कोड को सरल नहीं करता है ।
यह इस बात पर निर्भर करता है कि दूरी (v1, v2) का आउटपुट क्या है
यदि यह एक सदिश पर एक दशमलव (फ्लोट या डबल) है तो संभावना है कि दूर का भाग बहुत तेज होगा
float
चीज से क्या लेना-देना है।