दो 1-डी सरणियों

Question

गुणा करने का तेजी से जिस तरह से मैं निम्नलिखित डेटा है:

A = [a0 a1 a2 a3 a4 a5 .... a24] 
B = [b0 b1 b2 b3 b4 b5 .... b24] 

जो मैं तो इस प्रकार गुणा करने के लिए करना चाहते हैं:

C = A * B' = [a0b0 a1b1 a2b2 ... a24b24] 

यह स्पष्ट रूप से 25 गुणा शामिल है।

हालांकि, मेरे परिदृश्य में, केवल 5 नए मान प्रति "लूप पुनरावृत्ति" में स्थानांतरित किए जाते हैं (और 5 पुराने मान ए से बाहर स्थानांतरित किए जाते हैं)। क्या इस तथ्य का फायदा उठाने का कोई तेज़ तरीका है कि डेटा पूरी तरह से नए होने के बजाय ए के माध्यम से स्थानांतरित हो रहा है? आदर्श रूप से मैं गुणात्मक संचालन की संख्या को कम करना चाहता हूं (शायद अधिक जोड़/घटाव/संचय की लागत पर)। मैंने शुरू में सोचा था कि एक सिस्टोलिक सरणी मदद कर सकती है, लेकिन यह नहीं (मुझे लगता है !?)

अद्यतन 1: नोट बी लंबी अवधि के लिए तय किया गया है, लेकिन इसे पुन: प्रोग्राम किया जा सकता है।

अद्यतन 2: एक [24] < = एक [19], एक [23] < = एक [18] ... एक [1] < = new01, एक [: एक का स्थानान्तरण निम्नलिखित की तरह है 0] < = नया 00। और इसलिए प्रत्येक घड़ी चक्र

बहुत धन्यवाद!

Answer 1

क्या इस तथ्य का फायदा उठाने का कोई तेज़ तरीका है कि डेटा पूरी तरह से नए होने के बजाय ए के माध्यम से स्थानांतरित हो रहा है?

भले ही आप जो भी कर रहे हैं वह बदल रहा है और ए में नए तत्व जोड़ रहा है, सामान्य रूप से सी इच्छा में उत्पाद, अलग-अलग होंगे, क्योंकि ऑपरेशन में से प्रत्येक आम तौर पर प्रत्येक पुनरावृत्ति के बाद बदल जाएगा। यदि आपके पास ए या बी के तत्वों के तरीके के बारे में अतिरिक्त जानकारी है, तो आप गुणा की संख्या को कम करने के लिए संभावित रूप से उस संरचना का उपयोग कर सकते हैं। इस तरह के किसी भी संरचनात्मक विचारों को छोड़कर, आपको प्रत्येक लूप के सभी 25 उत्पादों की गणना करनी होगी।

आदर्श रूप से मैं गुणात्मक संचालन की संख्या को कम करना चाहता हूं (शायद अधिक जोड़/घटाव/संचय की लागत पर)।

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

Answer 2

क्या आप ए में परिवर्तित/अपरिवर्तित मान को ध्वजांकित करने के लिए एक और सरणी डी जोड़ सकते हैं। प्रत्येक बार जब आप यह सरणी जांचते हैं कि नए गुणा करने के लिए या नहीं।

Answer 3

पर बहुत पहले 5 डेटा सेट आप 50 गुणा तक बचा सकते हैं। लेकिन उसके बाद यह गुणा की एक सपाट सड़क है। चूंकि पहले 5 सेट के बाद प्रत्येक सेट के लिए आपको डेटा के नए सेट के साथ गुणा करने की आवश्यकता है।

मुझे लगता है कि सभी सरणी शून्य में शुरू हो गई हैं। मुझे नहीं लगता कि उन 50 बचाए गए किसी भी उपयोग के पूरे पर गुणा की मात्रा पर विचार कर रहे हैं।

लेकिन फिर भी मैं आपको उन 50 को बचाने के तरीके पर एक संकेत दूंगा, शायद आप इसे विस्तार प्राप्त कर सकें?

पहला डेटा सेट आया: में पहले डेटा सेट को b में प्रत्येक डेटा सेट के साथ गुणा करें। सभीa में सहेजें, केवल a[0]a[4] से c पर कॉपी करें। 25 गुणा यहाँ।

2 डेटा सेट पहुंचे: गुणा केवल a[0]a[4]-b[0]b[4] को resp साथ (नया डेटा वाले)। a[0] से a[4] में सहेजें, a[0->9] पर c पर कॉपी करें। यहाँ 5 गुणा

3 डेटा सेट पहुंचे: गुणा a[0]b[9] इस समय के लिए b[0] साथ a[9] करने और इसी a[0->14]c करने के लिए नकल। यहाँ 10 गुणा

4 डेटा सेट: गुणा a[0] इसी b प्रतिलिपि इसी c को a[0->19] साथ a[14] करने के लिए। 15 गुणा यहाँ।

5 वीं डेटा सेट: mutiply a[0] इसी b प्रतिलिपि इसी c को a[0->24] साथ करने के लिए। 20 गुणा यहाँ।

कुल सहेजे गए उत्परिवर्तन: गुणाएं।

6 वां डेटा सेट: सामान्य डेटा गुणा। 25 प्रत्येक। ऐसा इसलिए है क्योंकि सरणी a में प्रत्येक सेट के लिए एक नया डेटा सेट उपलब्ध है इसलिए गुणा अपरिहार्य है।