दिलचस्प पोस्ट
पीआईएल का उपयोग करते हुए एक और छवि के साथ एक पारदर्शी पीजीजी छवि को मर्ज करने के लिए एंड्रॉइड के साथ जावा 7 भाषा की विशेषताएं एंड्रॉइड 6.0 मार्शमॉलो एसडी कार्ड पर लिख नहीं सकते HTML5 "डाउनलोड" विशेषता के लिए समर्थन का पता कैसे लगाया जाता है? आईओएस 5: एक इमोजी को एक यूनिकोड वर्ण में कनवर्ट कैसे करें? एंड्रॉइड कैमरा इन्टेंट सेविंग इमेज लैंडस्केप जब ले लिया पोर्ट्रेट एक निश्चित वर्ण के बाद सब कुछ निकालें फेसबुक की ग्राफ़ एपीआई कॉल की सीमा क्या है? जीसीसी: गणित पुस्तकालय को लिंक करने के लिए एलएम फ्लैग की आवश्यकता क्यों है? अपनी स्वयं की फ़ंक्शन लिखते समय आर की एलीपिसिस सुविधा का उपयोग कैसे करें? प्रति कुंजी एकाधिक / वैकल्पिक वर्णों के साथ एक सॉफ्टके-बोर्ड बनाना आईओएस पर यूआरएल से आईपीए डाउनलोड करें और इंस्टॉल करें डीजेंगो rest_framework में अनुपलब्ध प्राधिकरण हैडर, क्या अपाचे का दोष है? कमानों को अलग करने के लिए कॉलम मूल्यों को पंक्तियों में कनवर्ट करें जांचें कि क्या वर्ष जावा स्क्रिप्ट में वर्ष है

यह निर्धारित करने का सबसे तेज़ तरीका है कि एक पूर्णांक मान के ज्ञात सेटों के साथ दो पूर्णांक (समस्त) के बीच है

क्या कोई पूर्णांक दो पूर्णांक के बीच है, इसका परीक्षण करने के लिए सी x >= start && x <= end या सी x >= start && x <= end में सी या सी ++ की तुलना में एक तेज़ तरीका है?

अद्यतनः मेरा विशिष्ट मंच आईओएस है I यह एक बॉक्स ब्लर फंक्शन का हिस्सा है जो किसी दिए गए स्क्वायर में एक मंडल में पिक्सेल को प्रतिबंधित करता है।

अद्यतनः स्वीकार्य उत्तर की कोशिश करने के बाद, मुझे सामान्य x >= start && x <= end मार्ग पर कोड की एक पंक्ति पर परिमाण गति के आदेश मिला।

अद्यतन करें : यहां एक्सकोड से कोडांतरक के साथ कोड के बाद और पहले किया गया है:

नया रास्ता

 // diff = (end - start) + 1 #define POINT_IN_RANGE_AND_INCREMENT(p, range) ((p++ - range.start) < range.diff) Ltmp1313: ldr r0, [sp, #176] @ 4-byte Reload ldr r1, [sp, #164] @ 4-byte Reload ldr r0, [r0] ldr r1, [r1] sub.w r0, r9, r0 cmp r0, r1 blo LBB44_30 

पुराना तरीका

 #define POINT_IN_RANGE_AND_INCREMENT(p, range) (p <= range.end && p++ >= range.start) Ltmp1301: ldr r1, [sp, #172] @ 4-byte Reload ldr r1, [r1] cmp r0, r1 bls LBB44_32 mov r6, r0 b LBB44_33 LBB44_32: ldr r1, [sp, #188] @ 4-byte Reload adds r6, r0, #1 Ltmp1302: ldr r1, [r1] cmp r0, r1 bhs LBB44_36 

बहुत आश्चर्यजनक कैसे शाखाओं को कम करने या दूर करने में इतनी नाटकीय गति प्रदान की जा सकती है

Solutions Collecting From Web of "यह निर्धारित करने का सबसे तेज़ तरीका है कि एक पूर्णांक मान के ज्ञात सेटों के साथ दो पूर्णांक (समस्त) के बीच है"

यह केवल एक तुलना / शाखा के साथ करने के लिए एक पुरानी चाल है चाहे वह वास्तव में गति को बेहतर बना सके, प्रश्न के लिए खुले हो सकते हैं, और भले ही ऐसा होता है, शायद यह नोटिस या देखभाल करने में बहुत कम है, लेकिन जब आप केवल दो तुलना के साथ शुरू कर रहे हैं, तो एक विशाल सुधार की संभावना काफी दूरदराज है। कोड ऐसा दिखता है:

 // use a < for an inclusive lower bound and exclusive upper bound // use <= for an inclusive lower bound and inclusive upper bound // alternatively, if the upper bound is inclusive and you can pre-calculate // upper-lower, simply add + 1 to upper-lower and use the < operator. if ((unsigned)(number-lower) <= (upper-lower)) in_range(number); 

एक ठेठ, आधुनिक कंप्यूटर (यानी, twos पूरक का उपयोग कर कुछ भी) के साथ, अहस्ताक्षरित रूपांतरण वास्तव में एक एनओपी है – बस एक ही बिट्स को कैसे देखा जाता है में एक बदलाव।

ध्यान दें कि एक विशिष्ट मामले में, आप upper-lower (पूर्वकल्पित) लूप के बाहर पूर्व-गणना कर सकते हैं, जिससे कि सामान्य रूप से किसी भी महत्वपूर्ण समय में योगदान न हो। शाखा निर्देशों की संख्या को कम करने के साथ-साथ, यह भी (सामान्यतया) शाखा भविष्यवाणी में सुधार करता है इस मामले में, यह शाखा ली गई है कि क्या संख्या नीचे के अंत के नीचे या सीमा के शीर्ष अंत से ऊपर है या नहीं।

यह कैसे काम करता है, बुनियादी विचार बहुत आसान है: एक ऋणात्मक संख्या, जब एक अहस्ताक्षरित संख्या के रूप में देखा जाता है, वह किसी भी चीज से बड़ा होगा जो एक सकारात्मक संख्या के रूप में शुरू हुआ।

अभ्यास में यह विधि number और अंतराल को मूल बिंदु के रूप में बदलती है और अगर number अंतराल [0, D] , जहां D = upper - lower । अगर कम से नीचे की number : नकारात्मक , और ऊपरी बाध्य से ऊपर: D से बड़ा

ऐसे छोटे पैमाने पर कोड के लिए महत्वपूर्ण अनुकूलन करने में सक्षम होने में यह दुर्लभ है। उच्च निष्पादन लाभ उच्च स्तर से कोड को देखने और संशोधित करने से आते हैं। आप श्रेणी परीक्षण के लिए पूरी तरह से समाप्त करने में सक्षम हो सकते हैं, या ओ (एन ^ 2) के बजाय केवल ओ (एन) कर सकते हैं। आप परीक्षणों को फिर से ऑर्डर करने में सक्षम हो सकते हैं ताकि असमानता के एक तरफ हमेशा निहित हो। यहां तक ​​कि अगर एल्गोरिदम आदर्श है, तो लाभ अधिक होने की संभावना है जब आप देखते हैं कि यह कोड 10 मिलियन बार कैसे रेंज का परीक्षण करता है और आप उन्हें बैच करने का एक रास्ता खोजते हैं और समानांतर में कई परीक्षण करने के लिए एसएसई का उपयोग करते हैं।

यह इस बात पर निर्भर करता है कि आप कितनी बार एक ही डेटा पर परीक्षण करना चाहते हैं।

यदि आप एक ही समय परीक्षण कर रहे हैं, तो संभवत: एल्गोरिदम को गति देने का एक सार्थक तरीका नहीं है।

यदि आप यह मान की एक बहुत ही सीमित सेट के लिए कर रहे हैं, तो आप एक लुकअप तालिका बना सकते हैं अनुक्रमण करना अधिक महंगा हो सकता है, लेकिन यदि आप कैश में पूरी तालिका को फिट कर सकते हैं, तो आप कोड से सभी शाखाओं को निकाल सकते हैं, जिससे चीजें तेज होनी चाहिए।

आपके डेटा के लिए लुकअप तालिका 128 ^ 3 = 2,097,152 होगी। यदि आप तीन चर में से किसी एक को नियंत्रित कर सकते हैं तो आप सभी उदाहरणों पर विचार करते हैं, जहां एक बार start = N , तो काम करने का आकार 128^2 = 16432 बाइट्स के नीचे चला जाता है, जो कि सबसे आधुनिक कैश में ठीक होना चाहिए।

आपको अभी भी वास्तविक कोड को बेंचमार्क करना होगा, यह देखने के लिए कि क्या एक शाखाहीन लुकअप तालिका स्पष्ट तुलना से काफी तेज है।

यह उत्तर स्वीकार किए गए उत्तर के साथ किए गए परीक्षण पर रिपोर्ट करना है। मैंने क्रमबद्ध यादृच्छिक पूर्णांक के एक बड़े सदिश पर एक बंद रेंज परीक्षण किया और मेरे आश्चर्य के लिए (कम <= अंक और& <num = <= उच्च) की मूल विधि ऊपर से स्वीकार किए गए उत्तर की तुलना में तेज़ है! एचपी मंडप जी 6 (6 जीबी रैम के साथ एएमडी ए 6-3400 एपीयू) पर टेस्ट किया गया था। यहां परीक्षण के लिए इस्तेमाल किया गया कोर कोड है:

 int num = rand(); // num to compare in consecutive ranges. chrono::time_point<chrono::system_clock> start, end; auto start = chrono::system_clock::now(); int inBetween1{ 0 }; for (int i = 1; i < MaxNum; ++i) { if (randVec[i - 1] <= num && num <= randVec[i]) ++inBetween1; } auto end = chrono::system_clock::now(); chrono::duration<double> elapsed_s1 = end - start; 

निम्न के साथ तुलना में जो ऊपर स्वीकृत उत्तर है:

 int inBetween2{ 0 }; for (int i = 1; i < MaxNum; ++i) { if (static_cast<unsigned>(num - randVec[i - 1]) <= (randVec[i] - randVec[i - 1])) ++inBetween2; } 

ध्यान दें कि रैंडविएक एक सॉर्टेड वेक्टर है मैक्सनम के किसी भी आकार के लिए पहली विधि मेरी मशीन पर दूसरे को धड़कता है!

क्या यह केवल पूर्णांक पर बिटवा ऑपरेशन करने के लिए संभव नहीं है?

चूंकि यह 0 और 128 के बीच है, अगर 8 वी बिट सेट (2 ^ 7) है, तो यह 128 या अधिक है बढ़त का मामला एक दर्द होगा, हालांकि, जब से आप एक समावेशी तुलना करना चाहते हैं