આ રિપોર્ટ મૌખિક ગણિત પરીક્ષાની તૈયારી માટે પ્રાકૃતિક સંખ્યાઓના ગુણાકાર અને સરવાળાની પરંપરાગત અને આધુનિક પદ્ધતિઓનું વિશ્લેષણ પ્રસ્તુત કરે છે^1.
શાળામાં શીખવવામાં આવતી સરવાળાની પદ્ધતિ બિટ-બાય-બિટ આધારિત છે. બે પ્રાકૃતિક સંખ્યાઓ z₁ અને z₂ નો સરવાળો કરવા માટે અમે જમણેથી ડાબે તરફ દરેક અંકને કેરી સાથે ઉમેરીએ છીએ^1.
બે 6-બિટ દ્વિસંકેતિક સંખ્યાઓનું ઉદાહરણ લેવાય:
Step-by-step binary addition process showing how carries propagate through bit positions
દરેક સ્થાન પર કેરીનો પ્રસાર થાય છે:
પરિણામ: (1,1,0,0,0,0,1) = 97₁₀^1
શાળા પદ્ધતિથી સરવાળો કરવા માટે O(n) સમય લાગે છે, જ્યાં n એ બિટ્સની સંખ્યા છે. આ શ્રેષ્ઠ શક્ય સમય જટિલતા છે કારણ કે દરેક બિટને ઓછામાં ઓછું એક વખત જોવું આવશ્યક છે^1.
પરંપરાગત ગુણાકાર પદ્ધતિમાં અમે દ્વિતીય સંખ્યાના દરેક અંક માટે આંશિક ગુણાકાર બનાવીએ છીએ અને તે બધાને ઉમેરીએ છીએ^1.
z₁ = (1,0,1,0,1,1) અને z₂ = (1,1,0,1,1,0) માટે:
શાળા પદ્ધતિથી ગુણાકાર કરવા માટે O(n²) સમય લાગે છે. આ બહુ બિટ્સવાળી મોટી સંખ્યાઓ માટે કાર્યક્ષમ નથી અને નોંધપાત્ર રીતે ઘટાડી શકાય છે^1.
કરાત્સુબા અલ્ગોરિધમનો મૂળ વિચાર ડિવાઇડ એન્ડ કોન્કર અભિગમ પર આધારિત છે. બે n-બિટ સંખ્યાઓના ગુણાકાર માટે શાળા પદ્ધતિમાં 4 આંશિક ગુણાકાર જરૂરી છે, પરંતુ કરાત્સુબા માત્ર 3 આંશિક ગુણાકાર વાપરે છે^1.
n ≥ 5 બિટ્સવાળી સંખ્યાઓ માટે:
કરાત્સુબા અલ્ગોરિધમ રિકર્શન વૃક્ષ બનાવે છે જ્યાં:
Work distribution across recursion levels in Karatsuba algorithm showing increasing work per level
દરેક સ્તર i માટે:
કુલ સ્તરો: d = ⌊log₂(n/2)⌋
કુલ સમય જટિલતા:
T(n) = Σᵢ₌₀ᵈ (3/2)ⁱ × n = n × (3/2)ᵈ⁺¹-1 / (3/2-1) = O(n^log₂(3)) = O(n^1.58)^1
Comparison of time complexity between the school multiplication method and Karatsuba algorithm showing significant improvement for larger inputs
કરાત્સુબા અલ્ગોરિધમ નાની સંખ્યાઓ (n ≤ 4-8 બિટ્સ) માટે શાળા પદ્ધતિ કરતાં ધીમું છે કારણ કે:
વાસ્તવિક અમલીકરણમાં સામાન્યતે હાઇબ્રિડ અભિગમ વાપરવામાં આવે છે:
કરાત્સુબા અલ્ગોરિધમ મોટી સંખ્યાઓના ગુણાકાર માટે નોંધપાત્ર સુધારણા લાવે છે, O(n²) ને O(n^1.58) માં ઘટાડીને. તેની રિકર્શન વૃક્ષ વિશ્લેષણ દ્વારા અમે સમજી શકીએ છીએ કે કેવી રીતે ડિવાઇડ એન્ડ કોન્કર તકનીક વધુ કાર્યક્ષમ અલ્ગોરિધમ્સ બનાવવામાં મદદ કરે છે. આજકાલ RSA ક્રિપ્ટોગ્રાફી અને અન્ય એપ્લિકેશન્સમાં હજારો બિટ્સવાળી મોટી સંખ્યાઓ માટે આવી પદ્ધતિઓ અત્યંત જરૂરી છે^1.