लुकअप टेबल

कंप्यूटर विज्ञान में, एक लुकअप टेबल (LUT) एक सरणी डेटा संरचना है जो रनटाइम (प्रोग्राम जीवनचक्र चरण) गणना को एक सरल सरणी इंडेक्सिंग ऑपरेशन से बदल देती है। प्रक्रिया को डायरेक्ट एड्रेसिंग कहा जाता है और एलयूटी हैश टेबल से इस तरह से भिन्न होते हैं कि, एक मूल्य प्राप्त करने के लिए $$v$$ कुंजी के साथ $$k$$, एक हैश तालिका मान संग्रहीत करेगी $$v$$ स्लॉट में $$h(k)$$ कहाँ पे $$h$$ एक हैश फंकशन है यानी $$k$$ स्लॉट की गणना करने के लिए उपयोग किया जाता है, जबकि LUT के मामले में, मान $$v$$ स्लॉट में रखा जाता है $$k$$, इस प्रकार सीधे संबोधित करने योग्य। प्रसंस्करण समय में बचत महत्वपूर्ण हो सकती है, क्योंकि स्मृति से मूल्य प्राप्त करना अक्सर महंगी गणना या इनपुट/आउटपुट ऑपरेशन करने से तेज़ होता है। तालिकाओं को पूर्वगणना किया जा सकता है और स्थिर मेमोरी आवंटन प्रोग्राम स्टोरेज में संग्रहीत किया जा सकता है, प्रोग्राम के प्रारंभिक चरण (memoization), या एप्लिकेशन-विशिष्ट प्लेटफ़ॉर्म में हार्डवेयर में संग्रहीत भी। किसी सरणी में मान्य (या अमान्य) आइटमों की सूची के विरुद्ध मिलान करके इनपुट मानों को मान्य करने के लिए लुकअप तालिकाओं का व्यापक रूप से उपयोग किया जाता है, और कुछ प्रोग्रामिंग भाषाओं में, मिलान इनपुट को संसाधित करने के लिए पॉइंटर फ़ंक्शन (या लेबल के लिए ऑफ़सेट) शामिल हो सकते हैं। प्रोग्राम योग्य हार्डवेयर कार्यात्मकता प्रदान करने के लिए क्षेत्र में प्रोग्राम की जा सकने वाली द्वार श्रंखला पुन: विन्यास योग्य, हार्डवेयर-कार्यान्वित, लुकअप तालिकाओं का व्यापक उपयोग करता है।

इतिहास
कंप्यूटर के आगमन से पहले, मूल्यों की लुकअप टेबल का उपयोग जटिल कार्यों की हाथ की गणना में तेजी लाने के लिए किया जाता था, जैसे कि त्रिकोणमिति, सामान्य लघुगणक और सांख्यिकीय घनत्व कार्यों में। प्राचीन (499 ईस्वी) भारत में, आर्यभट्ट ने पहली आर्यभट्ट की ज्या तालिका बनाई, जिसे उन्होंने संस्कृत-अक्षर-आधारित संख्या प्रणाली में एन्कोड किया। 493 ईस्वी में, एक्विटाइन के विक्टोरियस ने एक 98-स्तंभ गुणन तालिका लिखी, जिसने (रोमन अंकों में) 2 से 50 बार प्रत्येक संख्या का गुणनफल दिया और पंक्तियाँ एक हज़ार से शुरू होने वाली संख्याओं की एक सूची थीं, जो सैकड़ों से एक सौ तक उतरती थीं।, फिर दसियों से दस तक, फिर एक से एक तक, और फिर भिन्नों को 1/144 तक घटाते हुए आधुनिक स्कूली बच्चों को अक्सर सबसे अधिक इस्तेमाल की जाने वाली संख्याओं (9 x 9 या 12 x 12 तक) की गणना से बचने के लिए गुणा तालिका को याद करना सिखाया जाता है।

कंप्यूटर के इतिहास के आरंभ में, इनपुट/आउटपुट संचालन विशेष रूप से धीमे थे - यहां तक ​​कि उस समय के प्रोसेसर की गति की तुलना में भी। यह या तो स्टैटिक लुकअप टेबल (प्रोग्राम में एम्बेडेड) या डायनेमिक प्रीफेच्ड एरेज़ बनाकर केवल सबसे सामान्य रूप से होने वाले डेटा आइटम को शामिल करके महंगे रीड ऑपरेशंस को मैन्युअल कैश (कंप्यूटिंग) के रूप में कम करने के लिए समझ में आता है। सिस्टमवाइड कैशिंग की शुरूआत के बावजूद जो अब इस प्रक्रिया को स्वचालित करता है, एप्लिकेशन स्तर लुकअप तालिकाएं अभी भी डेटा आइटम्स के प्रदर्शन में सुधार कर सकती हैं जो शायद ही कभी बदलती हैं।

लुकअप तालिकाएँ कंप्यूटर स्प्रेडशीट में कार्यान्वित शुरुआती कार्यात्मकताओं में से एक थीं, जिसमें VisiCalc (1979) का प्रारंभिक संस्करण शामिल था।  अपने मूल 20 कार्यों में कार्य करता है। इसके बाद बाद की स्प्रेडशीट, जैसे कि माइक्रोसॉफ्ट एक्सेल, और विशेष द्वारा पूरक किया गया है   तथा   लंबवत या क्षैतिज तालिका में लुकअप को आसान बनाने के लिए कार्य करता है। माइक्रोसॉफ्ट एक्सेल में   समारोह 28 अगस्त 2019 से शुरू किया गया है।

सीमाएं
हालांकि LUT के प्रदर्शन की गारंटी है $$O(1)$$ लुकअप ऑपरेशन के लिए, किन्हीं भी दो संस्थाओं या मूल्यों में एक ही कुंजी नहीं हो सकती है $$k$$. जब ब्रह्मांड का आकार (गणित) $$\cup$$—जहाँ कुंजियाँ खींची जाती हैं—बड़ी होती है, यह अव्यावहारिक हो सकता है या स्मृति में संग्रहीत करना असंभव हो सकता है। इसलिए, इस मामले में, हैश टेबल एक बेहतर विकल्प होगा।

तुच्छ हैश समारोह
एक तुच्छ हैश फ़ंक्शन लुकअप के लिए, परिणाम निकालने के लिए अहस्ताक्षरित कच्चे डेटा मान को सीधे एक-आयामी तालिका के सूचकांक के रूप में उपयोग किया जाता है। छोटी रेंज के लिए, यह सबसे तेज़ लुकअप में से एक हो सकता है, यहां तक ​​कि शून्य शाखाओं के साथ द्विआधारी खोज गति से अधिक और निरंतर समय में निष्पादित हो सकता है।

बाइट्स की एक श्रृंखला में बिट्स की गिनती
एक असतत समस्या जो कई कंप्यूटरों पर हल करने के लिए महंगी है, वह बिट्स की संख्या की गणना करना है जो एक (बाइनरी) संख्या में 1 पर सेट होती है, जिसे कभी-कभी हैमिंग वजन कहा जाता है। उदाहरण के लिए, बाइनरी में दशमलव संख्या 37 00100101 है, इसलिए इसमें तीन बिट हैं जो बाइनरी 1 पर सेट हैं। C (प्रोग्रामिंग लैंग्वेज) कोड का एक सरल उदाहरण, जिसे एक इंट में 1 बिट गिनने के लिए डिज़ाइन किया गया है, ऐसा दिखाई दे सकता है: <वाक्यविन्यास प्रकाश लैंग = सी> int count_ones (अहस्ताक्षरित int x) { इंट परिणाम = 0; जबकि (एक्स! = 0) { एक्स = एक्स और (एक्स - 1); परिणाम ++; } वापसी परिणाम; }

उपरोक्त कार्यान्वयन के लिए 32-बिट मान के मूल्यांकन के लिए 32 संचालन की आवश्यकता होती है, जो नियंत्रण प्रवाह के कारण संभावित रूप से प्रति निर्देश कई चक्र ले सकता है। यह लुकअप टेबल में लूप अनोलिंग हो सकता है जो बदले में बेहतर प्रदर्शन के लिए तुच्छ हैश फ़ंक्शन का उपयोग करता है। बिट्स सरणी, 256 प्रविष्टियों के साथ बिट्स_सेट का निर्माण प्रत्येक संभावित बाइट मान में एक बिट सेट की संख्या देकर किया जाता है (उदाहरण के लिए 0x00 = 0, 0x01 = 1, 0x02 = 1, और इसी तरह)। हालांकि एक रनटाइम (प्रोग्राम जीवनचक्र चरण) एल्गोरिदम का उपयोग बिट्स_सेट सरणी उत्पन्न करने के लिए किया जा सकता है, जब आकार को ध्यान में रखा जाता है तो यह घड़ी चक्रों का एक अक्षम उपयोग होता है, इसलिए एक प्रीकंप्यूटेड तालिका का उपयोग किया जाता है - हालांकि एक संकलन समय स्क्रिप्ट को गतिशील रूप से उपयोग किया जा सकता है तालिका को स्रोत फ़ाइल में उत्पन्न और संलग्न करें। पूर्णांक (कंप्यूटर विज्ञान) के प्रत्येक बाइट में योग की गणना प्रत्येक बाइट पर तुच्छ हैश फ़ंक्शन लुकअप के माध्यम से की जा सकती है; इस प्रकार, प्रभावी रूप से शाखाओं से बचने के परिणामस्वरूप प्रदर्शन में काफी सुधार हुआ। <वाक्यविन्यास प्रकाश लैंग = सी> इंट काउंट_ओन्स (इंट इनपुट_वैल्यू) { यूनियन फोर_बाइट्स { int big_int; चार प्रत्येक_बाइट [4]; } ऑपरेंड = इनपुट_वैल्यू; कॉन्स्ट इंट बिट्स_सेट [256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,     2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,      2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,      4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,      3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,      4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,      4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};  वापसी (बिट्स_सेट [ऑपरेंड.च_बाइट [0 + बिट्स_सेट [ऑपरेंड.च_बाइट [1 +]          बिट्स_सेट [ऑपरेंड.च_बाइट [2 + बिट्स_सेट [ऑपरेंड.च_बाइट [3]); }} 

इमेज प्रोसेसिंग में लुकअप टेबल


""Lookup tables (LUTs) are an excellent technique for optimizing the evaluation of functions that are expensive to compute and inexpensive to cache. ... For data requests that fall between the table's samples, an interpolation algorithm can generate reasonable approximations by averaging nearby samples.""

डेटा विश्लेषण अनुप्रयोगों में, जैसे मूर्ति प्रोद्योगिकी, एक लुकअप टेबल (LUT) का उपयोग इनपुट डेटा को अधिक वांछनीय आउटपुट स्वरूप में बदलने के लिए किया जाता है। उदाहरण के लिए, शनि ग्रह की एक ग्रेस्केल तस्वीर को उसके छल्लों में अंतर पर जोर देने के लिए एक रंगीन छवि में बदल दिया जाएगा।

लुकअप तालिकाओं का उपयोग करके रन-टाइम संगणनाओं को कम करने का एक उत्कृष्ट उदाहरण एक त्रिकोणमिति गणना का परिणाम प्राप्त करना है, जैसे मान की साइन। त्रिकोणमितीय कार्यों की गणना एक कंप्यूटिंग अनुप्रयोग को काफी धीमा कर सकती है। एक ही एप्लिकेशन बहुत जल्द समाप्त हो सकता है जब यह पहली बार कई मानों की साइन का पूर्व-गणना करता है, उदाहरण के लिए प्रत्येक पूर्ण संख्या में डिग्री के लिए (तालिका को संकलन समय पर स्थिर चर के रूप में परिभाषित किया जा सकता है, बार-बार रन टाइम लागत को कम करता है)। जब प्रोग्राम को मान की ज्या की आवश्यकता होती है, तो यह मेमोरी एड्रेस से निकटतम ज्या मान को पुनः प्राप्त करने के लिए लुकअप तालिका का उपयोग कर सकता है, और गणितीय सूत्र द्वारा गणना करने के बजाय वांछित मान की ज्या में प्रक्षेपित भी कर सकता है। इस प्रकार कंप्यूटर सिस्टम में गणित सहसंसाधकों द्वारा लुकअप तालिकाओं का उपयोग किया जाता है। लुकअप टेबल में एक त्रुटि इंटेल के बदनाम पेंटियम FDIV बग | फ्लोटिंग-पॉइंट डिवाइड बग के लिए जिम्मेदार थी।

एकल चर के कार्य (जैसे साइन और कोसाइन) एक साधारण सरणी द्वारा कार्यान्वित किए जा सकते हैं। दो या दो से अधिक चर वाले कार्यों के लिए बहुआयामी सरणी अनुक्रमण तकनीकों की आवश्यकता होती है। बाद वाला मामला इस प्रकार एक्स की गणना करने के लिए फ़ंक्शन को प्रतिस्थापित करने के लिए [x] [y] की दो-आयामी सरणी को नियोजित कर सकता हैy x और y मानों की सीमित श्रेणी के लिए। जिन कार्यों के एक से अधिक परिणाम हैं, उन्हें लुकअप तालिकाओं के साथ कार्यान्वित किया जा सकता है जो संरचनाओं की सरणियाँ हैं।

जैसा कि उल्लेख किया गया है, ऐसे मध्यवर्ती समाधान हैं जो कम मात्रा में गणना के साथ संयोजन में तालिकाओं का उपयोग करते हैं, अक्सर इंटरपोलेशन का उपयोग करते हुए। प्रक्षेप के साथ संयुक्त पूर्व-गणना उन मानों के लिए उच्च सटीकता उत्पन्न कर सकती है जो दो पूर्व-गणना किए गए मानों के बीच आते हैं। इस तकनीक को निष्पादित करने के लिए थोड़ा अधिक समय की आवश्यकता होती है, लेकिन उच्च सटीकता की आवश्यकता वाले अनुप्रयोगों में सटीकता को बहुत बढ़ा सकता है। पूर्व-गणना किए जा रहे मानों के आधार पर, प्रक्षेप के साथ पूर्व-गणना का उपयोग सटीकता बनाए रखते हुए लुकअप तालिका के आकार को छोटा करने के लिए भी किया जा सकता है।

इमेज प्रोसेसिंग में, लुकअप टेबल को अक्सर 3डी एलयूटी (या 3डीएलयूटी) कहा जाता है, और इंडेक्स वैल्यू की प्रत्येक श्रेणी के लिए आउटपुट वैल्यू देता है। एक सामान्य LUT, जिसे कलोरमैप या पैलेट (कंप्यूटिंग) कहा जाता है, का उपयोग रंगों और तीव्रता के मूल्यों को निर्धारित करने के लिए किया जाता है जिसके साथ एक विशेष छवि प्रदर्शित की जाएगी। संगणित टोमोग्राफी में, विन्डोइंग मापित विकिरण की तीव्रता को प्रदर्शित करने के तरीके को निर्धारित करने के लिए एक संबंधित अवधारणा को संदर्भित करता है।

अक्सर प्रभावी होने के बावजूद, लुकअप टेबल को नियोजित करने के परिणामस्वरूप एक गंभीर जुर्माना हो सकता है यदि LUT की जगह की जाने वाली गणना अपेक्षाकृत सरल हो। मेमोरी पुनर्प्राप्ति समय और मेमोरी आवश्यकताओं की जटिलता अनुप्रयोग संचालन समय और सिस्टम जटिलता को सीधे सूत्र गणना द्वारा आवश्यक होने के सापेक्ष बढ़ा सकती है। कैश प्रदूषण की संभावना भी एक समस्या बन सकती है। बड़ी टेबल के लिए टेबल एक्सेस लगभग निश्चित रूप से कैश मिस का कारण बनता है। यह घटना तेजी से एक मुद्दा बनती जा रही है क्योंकि प्रोसेसर आउटस्पेस मेमोरी। रीमैटीरियलाइजेशन, एक संकलक अनुकूलन में एक समान समस्या दिखाई देती है। कुछ परिवेशों में, जैसे कि जावा (प्रोग्रामिंग भाषा), प्रत्येक लुकअप के लिए एक अतिरिक्त तुलना और शाखा वाली अनिवार्य सीमा-जांच के कारण टेबल लुकअप और भी महंगा हो सकता है।

एक आवश्यक ऑपरेशन के लिए लुकअप टेबल का निर्माण कब संभव है, इस पर दो मूलभूत सीमाएँ हैं। एक उपलब्ध मेमोरी की मात्रा है: तालिका के लिए उपलब्ध स्थान से बड़ी लुकअप टेबल का निर्माण नहीं किया जा सकता है, हालांकि लुकअप समय की कीमत पर डिस्क-आधारित लुकअप टेबल बनाना संभव है। दूसरा वह समय है जो पहली बार तालिका मानों की गणना करने के लिए आवश्यक है; हालाँकि इसे आमतौर पर केवल एक बार करने की आवश्यकता होती है, यदि इसमें निषेधात्मक रूप से लंबा समय लगता है, तो यह लुकअप तालिका के उपयोग को एक अनुपयुक्त समाधान बना सकता है। जैसा कि पहले बताया गया है, टेबल को कई मामलों में स्थिर रूप से परिभाषित किया जा सकता है।

संगणन ज्या
अधिकांश कंप्यूटर केवल बुनियादी अंकगणितीय संचालन करते हैं और सीधे किसी दिए गए मान की ज्या की गणना नहीं कर सकते हैं। इसके बजाय, वे कॉरडिक एल्गोरिथम या एक जटिल सूत्र का उपयोग करते हैं जैसे निम्न टेलर श्रृंखला साइन के मान की गणना करने के लिए उच्च स्तर की सटीकता के लिए:
 * $$\operatorname{sin}(x) \approx x - \frac{x^3}{6} + \frac{x^5}{120} - \frac{x^7}{5040}$$ (एक्स के करीब 0 के लिए)

हालांकि, यह गणना करने के लिए महंगा हो सकता है, विशेष रूप से धीमे प्रोसेसर पर, और कई अनुप्रयोग हैं, विशेष रूप से पारंपरिक कंप्यूटर ग्राफिक्स में, जिन्हें प्रति सेकंड हजारों साइन मानों की गणना करने की आवश्यकता होती है। एक सामान्य समाधान शुरू में कई समान रूप से वितरित मूल्यों की ज्या की गणना करना है, और फिर x की ज्या खोजने के लिए हम सरणी इंडेक्सिंग ऑपरेशन के माध्यम से x के निकटतम मान की ज्या चुनते हैं। यह सही मान के करीब होगा क्योंकि ज्या परिवर्तन की परिबद्ध दर के साथ एक सतत फलन है। उदाहरण के लिए: <वाक्यविन्यास लैंग = abap> वास्तविक सरणी साइन_टेबल [-1000..1000] एक्स के लिए -1000 से 1000 तक साइन_टेबल [एक्स] = साइन (पीआई * एक्स / 1000)

फ़ंक्शन लुकअप_साइन (एक्स) वापसी sine_table [दौर (1000 * x / pi)] 

दुर्भाग्य से, तालिका के लिए काफी जगह की आवश्यकता होती है: यदि IEEE डबल-परिशुद्धता फ़्लोटिंग-पॉइंट नंबरों का उपयोग किया जाता है, तो 16,000 से अधिक बाइट्स की आवश्यकता होगी। हम कम नमूनों का उपयोग कर सकते हैं, लेकिन तब हमारी सटीकता काफी खराब हो जाएगी। एक अच्छा समाधान रैखिक इंटरपोलेशन है, जो मूल्य के दोनों ओर तालिका में दो बिंदुओं के बीच एक रेखा खींचता है और उस रेखा पर उत्तर का पता लगाता है। यह अभी भी गणना करने में तेज है, और साइन फ़ंक्शन जैसे सुचारू कार्यों के लिए अधिक सटीक है। यहाँ रैखिक प्रक्षेप का उपयोग करते हुए एक उदाहरण दिया गया है:

<वाक्यविन्यास लैंग = abap> फ़ंक्शन लुकअप_साइन (एक्स) एक्स 1 = मंजिल (एक्स * 1000 / पीआई) y1 = साइन_टेबल [X1] y2 = sine_table[x1+1] वापसी y1 + (y2-y1)*(x*1000/pi-x1) 

रैखिक इंटरपोलेशन एक इंटरपोलेटेड फ़ंक्शन प्रदान करता है जो निरंतर है, लेकिन सामान्य रूप से निरंतर यौगिक नहीं होगा। टेबल लुकअप के सहज इंटरपोलेशन के लिए जो निरंतर है और निरंतर पहला डेरिवेटिव है, किसी को एंडपॉइंट्स पर मिलान किए गए डेरिवेटिव के साथ यूनिट अंतराल पर क्यूबिक हर्मिट स्पलाइन # इंटरपोलेशन का उपयोग करना चाहिए।

एक अन्य समाधान जो अंतरिक्ष के एक चौथाई का उपयोग करता है लेकिन गणना करने में थोड़ा अधिक समय लेता है, साइन और कोसाइन के बीच संबंधों को उनके समरूपता नियमों के साथ ध्यान में रखना होगा। इस स्थिति में, पहले चतुर्थांश (अर्थात sin(0..pi/2)) के लिए साइन फ़ंक्शन का उपयोग करके लुकअप तालिका की गणना की जाती है। जब हमें एक मान की आवश्यकता होती है, तो हम एक चर को पहले चतुर्थांश में लिपटे कोण के रूप में निर्दिष्ट करते हैं। फिर हम कोण को चार चतुर्थांशों में लपेटते हैं (आवश्यक नहीं है यदि मान हमेशा 0 और 2 * पीआई के बीच होते हैं) और सही मान लौटाते हैं (यानी पहला चतुर्थांश एक सीधा रिटर्न है, दूसरा चतुर्थांश पीआई / 2-एक्स से पढ़ा जाता है, तीसरा और चौथे क्रमशः पहले और दूसरे के नकारात्मक हैं)। कोसाइन के लिए, हमें केवल पीआई/2 (यानी एक्स + पीआई/2) द्वारा स्थानांतरित कोण वापस करना होगा। स्पर्शरेखा के लिए, हम साइन को कोसाइन से विभाजित करते हैं (कार्यान्वयन के आधार पर विभाजित-दर-शून्य हैंडलिंग की आवश्यकता हो सकती है):

<वाक्यविन्यास लैंग = abap> कार्य init_sine x के लिए 0 से (360/4)+1 तक sine_table[x] = sin(2*pi * x / 360)

फ़ंक्शन लुकअप_साइन (एक्स) x = रैप x को 0 से 360 तक वाई = मोड (एक्स, 90) अगर (x <90) sine_table लौटाएं [y] अगर (x <180) साइन_टेबल लौटाएं [90-वाई] अगर (एक्स <270) वापसी -sine_table [y] वापसी - साइन_टेबल [90-वाई]

फ़ंक्शन लुकअप_कोसाइन (एक्स) वापसी लुकअप_साइन (एक्स + 90)

फ़ंक्शन लुकअप_टैन (एक्स) वापसी लुकअप_साइन (एक्स) / लुकअप_कोसाइन (एक्स) 

प्रक्षेप का उपयोग करते समय, लुकअप तालिका के आकार को 'गैर-समान नमूनाकरण'' का उपयोग करके कम किया जा सकता है, जिसका अर्थ है कि जहां फ़ंक्शन सीधे के करीब है, हम कुछ नमूना बिंदुओं का उपयोग करते हैं, जबकि जहां यह तेजी से मूल्य बदलता है हम अधिक नमूना बिंदुओं का उपयोग करते हैं सन्निकटन को वास्तविक वक्र के करीब रखने के लिए। अधिक जानकारी के रेखिक आंतरिक देखें।

कैश
संग्रहण कैश (फ़ाइलों के लिए डिस्क कैश, या कोड या डेटा के लिए प्रोसेसर कैश सहित) लुकअप टेबल की तरह भी काम करते हैं। तालिका धीमी बाहरी मेमोरी पर संग्रहीत होने के बजाय बहुत तेज़ मेमोरी के साथ बनाई गई है, और बाहरी मेमोरी (या डिस्क) पता (विशेष रूप से किसी भी संभावित बाहरी पते के सबसे कम बिट्स) की रचना करने वाली बिट्स की एक उप-श्रेणी के लिए डेटा के दो टुकड़े बनाए रखती है। : वांछित बाह्य संग्रहण पते के निम्नतम बिट्स द्वारा निर्दिष्ट इंडेक्स पर लुकअप तालिका में टैग को पढ़ने के लिए एक एकल (तेज़) लुकअप किया जाता है, और यह निर्धारित करने के लिए कि मेमोरी एड्रेस कैश द्वारा हिट किया गया है या नहीं। जब कोई हिट पाया जाता है, तो बाहरी मेमोरी तक पहुंच की आवश्यकता नहीं होती है (लिखने के कार्यों को छोड़कर, जहां कैश्ड मान को कुछ समय बाद धीमी मेमोरी में एसिंक्रोनस रूप से अपडेट करने की आवश्यकता हो सकती है, या यदि कैश में स्थिति को दूसरे कैश में बदला जाना चाहिए पता)।
 * एक टुकड़ा (टैग) में पते के शेष बिट्स का मान होता है; यदि ये बिट स्मृति पते से पढ़ने या लिखने के लिए मेल खाते हैं, तो दूसरे टुकड़े में इस पते के लिए कैश्ड मान होता है।
 * दूसरा टुकड़ा उस पते से जुड़े डेटा को बनाए रखता है।

हार्डवेयर LUTs
डिजिटल तर्क में, एक लुकअप टेबल को एक बहुसंकेतक के साथ लागू किया जा सकता है, जिसकी चुनिंदा लाइनें एड्रेस सिग्नल द्वारा संचालित होती हैं और जिनके इनपुट ऐरे में निहित तत्वों के मान होते हैं। ये मान या तो हार्ड-वायर्ड हो सकते हैं, जैसा कि ASIC में होता है जिसका उद्देश्य किसी फ़ंक्शन के लिए विशिष्ट होता है, या D लैचेस द्वारा प्रदान किया जाता है जो विन्यास योग्य मानों की अनुमति देता है। (ROM, EPROM, EEPROM, या यादृच्छिक अभिगम स्मृति।)

एक n-बिट LUT किसी भी n-इनपुट बूलियन समारोह को LUT में फ़ंक्शन की सत्य तालिका संग्रहीत करके एनकोड कर सकता है। यह बूलियन तर्क फ़ंक्शंस को एन्कोडिंग करने का एक कुशल तरीका है, और 4-6 बिट्स इनपुट के साथ LUTs वास्तव में आधुनिक फील्ड-प्रोग्रामेबल गेट एरेज़ (FPGAs) के प्रमुख घटक हैं जो पुन: कॉन्फ़िगर करने योग्य हार्डवेयर लॉजिक क्षमताएं प्रदान करते हैं।

डेटा अधिग्रहण और नियंत्रण प्रणाली
डेटा अधिग्रहण और नियंत्रण प्रणाली में, लुकअप टेबल का उपयोग आमतौर पर निम्नलिखित कार्यों को करने के लिए किया जाता है:
 * अंशांकन डेटा का अनुप्रयोग, ताकि अनलिब्रेटेड माप या सेटपॉइंट (नियंत्रण प्रणाली) मानों में सुधार लागू किया जा सके; तथा
 * उपक्रम माप इकाई रूपांतरण; तथा
 * सामान्य उपयोगकर्ता-परिभाषित संगणना करना।

कुछ प्रणालियों में, इन गणनाओं के लिए बहुपदों को लुकअप तालिकाओं के स्थान पर भी परिभाषित किया जा सकता है।

यह भी देखें

 * सहयोगी सरणी
 * शाखा तालिका
 * लड़की की सटीक तालिकाएँ
 * संस्मरण
 * मेमोरी-बाउंड फ़ंक्शन
 * शिफ्ट रजिस्टर लुकअप टेबल
 * पैलेट (कंप्यूटिंग), a.k.a. कलर लुकअप टेबल या CLUT - कंप्यूटर ग्राफिक्स में उपयोग के लिए
 * 3डी लुकअप टेबल - फिल्म उद्योग में उपयोग

इस पेज में लापता आंतरिक लिंक की सूची

 * रनटाइम (कार्यक्रम जीवनचक्र चरण)
 * स्थैतिक स्मृति आवंटन
 * एक्विटेन का विक्टोरियस
 * पहाड़ा
 * ब्रह्मांड (गणित)
 * कच्चा डेटा
 * सी (प्रोग्रामिंग भाषा)
 * निर्देश के अनुसार चक्र
 * बहाव को काबू करें
 * मूल फाइल
 * सह प्रोसेसर
 * उन लोगों के
 * परिकलित टोमोग्राफी
 * जेडडी एलयूटी
 * निरंतर कार्य
 * चिकना समारोह
 * पहला व्युत्पन्न
 * डी कुंडी
 * ट्रुथ टेबल
 * आंकड़ा अधिग्रहण
 * मापन इकाई
 * साहचर्य सरणी

बाहरी संबंध

 * Fast table lookup using input character as index for branch table
 * Art of Assembly: Calculation via Table Lookups
 * "Bit Twiddling Hacks" (includes lookup tables) By Sean Eron Anderson of Stanford University
 * Memoization in C++ by Paul McNamee, Johns Hopkins University showing savings
 * "The Quest for an Accelerated Population Count" by Henry S. Warren, Jr.