2010-11-01 10 views
5

में मैं कोई तरीका होना चाहिए गणना करने के लिए:मॉड्यूलर घातांक जावा

(g^u * y^v) mod p 
जावा में

मैं की गणना के लिए इस एल्गोरिथ्म पाया है (छ^यू) आधुनिक p:

int modulo(int a,int b,int c) { 
    long x=1 
    long y=a; 
    while(b > 0){ 
     if(b%2 == 1){ 
      x=(x*y)%c; 
     } 
     y = (y*y)%c; // squaring the base 
     b /= 2; 
    } 
    return (int) x%c; 
} 

और यह बहुत अच्छा काम करता है, लेकिन मैं

(g^u * y^v) mod p 
के लिए ऐसा करने के लिए एक रास्ता खोजने के लिए नहीं कर पा रहे

क्योंकि मेरे गणित कौशल कमजोर हैं।

इसे संदर्भ में रखने के लिए, यह "कम" डीएसए के जावा कार्यान्वयन के लिए है - सत्यापन करने वाले भाग को हल करने की आवश्यकता है।

+0

मुझे लगता है कि पी प्रधान है, है ना? –

+0

हाँ, पी प्राइम है, मुझे लगता है कि यह हल करता है: (जी^यू * वाई^वी) मॉड पी = (जी^यू मॉड पी) * (वाई^वी मॉड पी) मॉड पी, हालांकि मैंने इसका परीक्षण किया है अब तक छोटी संख्या –

+0

और क्या यह बड़ी है? 'Mod p' भाग मुझे देखता है जैसे कि आप लंबे समय के बजाय' BigInteger' का उपयोग करना चाहते हैं। –

उत्तर

8

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

(x * y) mod p = ((x mod p)*(y mod p)) mod p। मुझे यकीन है कि आप इसे वहां से समझ सकते हैं।

+0

हाँ, मुझे लगता है कि यह तरीका है, अब तक मैंने इसके साथ छोटी संख्या में परीक्षण किए हैं, और ऐसा लगता है कि यह काम कर रहा है –

+1

मुझे लगता है कि यह संभवतः ठीक नहीं है मान लें कि कारक बहेंगे नहीं, लेकिन मैं निश्चित नहीं हो सकता। –

+0

कारक तब तक बहेंगे जब तक (पी -1) * (पी -1) एक 'int' के अंदर फिट बैठता है। अन्यथा, हमें केवल एक्स और वाई के लिए 'लांग' का उपयोग करना होगा। तथ्य – MAK

1

प्रयास करें

(Math.pow (क्यू, यू) * Math.pow (y, v))% p

+0

मैं अनुमान लगा रहा हूं कि वह पूछ रहा है कि काम करने के लिए सरल दृष्टिकोण के लिए संख्याएं बहुत बड़ी हैं ... –

+0

यदि ऐसा है, BigInteger का उपयोग क्यों नहीं करें? – Nicholas

+0

Math.pow() लेता है और युगल देता है। http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Math।एचटीएमएल # पाउ% 28 डबल,% 20 डबल% 2 9 – wnoise

4

कोड का टुकड़ा लागू करता है यही कारण है कि अच्छी तरह से जाना "तेजी से घातांक" एल्गोरिथ्म, भी Exponentiation by squaring के रूप में जाना।

यह इस तथ्य का भी उपयोग करता है कि (ए * बी) मॉड पी = ((एक मॉड पी) * (बी मोड पी)) मॉड पी। (दोनों अतिरिक्त और गुणात्मक प्राइम मॉड्यूलस लेने के तहत संरचित संरचनाएं हैं - यह एक होमोमोर्फिज्म है)। इस तरह एल्गोरिदम में हर बिंदु पर यह पी से छोटे संख्याओं को कम कर देता है।

जबकि आप इन्हें लूप में एक अंतःस्थापित फैशन में गणना करने का प्रयास कर सकते हैं, ऐसा करने के लिए कोई वास्तविक लाभ नहीं है। बस उन्हें अलग से गणना करें, उन्हें एक साथ गुणा करें, और आखिरी बार मोड लें।

चेतावनी दीजिये कि यदि आप पी^2 सबसे बड़ा प्रतिनिधित्व करने योग्य int से अधिक है तो आपको अतिप्रवाह मिलेगा, और इससे आपको गलत जवाब मिल जाएगा। जावा के लिए, बड़े पूर्णांक पर स्विच करना समझदार हो सकता है, या कम से कम पी के आकार पर रनटाइम जांच कर रहा है और अपवाद फेंक सकता है।

अंत में, यदि यह क्रिप्टोग्राफिक उद्देश्यों के लिए है, तो आपको शायद इसे स्वयं लागू करने के बजाय ऐसा करने के लिए लाइब्रेरी का उपयोग करना चाहिए। काम में प्रतीत होता है कि कुछ गलत गलत करना बहुत आसान है, लेकिन कोई सुरक्षा के लिए न्यूनतम प्रदान करता है।

+0

यह वास्तव में क्रिप्टोग्राफिक उद्देश्यों के लिए है, लेकिन यह एक स्कूल असाइनमेंट के लिए है जहां हम खुद को डीएसए लागू करना चाहते हैं। आपके अंतर्दृष्टिपूर्ण उत्तर के लिए धन्यवाद! –

संबंधित मुद्दे