JavaScript BigInt yordamida tub sonlarni yaratish: Katta tub sonlarni hisoblash

Tub sonlar, sonlar nazariyasining asosiy qurilish bloklari, asrlar davomida matematiklarni o'ziga jalb qilib kelgan. Bugungi kunda ular nafaqat nazariy qiziqishlar, balki zamonaviy kriptografiya va xavfsiz aloqaning muhim tarkibiy qismlaridir. Ushbu keng qamrovli qo'llanma JavaScript'ning BigInt'idan foydalanib tub sonlarni yaratishning hayratlanarli dunyosiga sho'ng'iydi va juda katta tub sonlarni hisoblash imkonini beradi.

Tub sonlar va ularning ahamiyatiga kirish

Tub son — bu 1 dan katta boʻlgan butun son boʻlib, uning faqat ikkita boʻluvchisi bor: 1 va oʻzi. Masalan, 2, 3, 5, 7, 11 va hokazo. Tub sonlarning taqsimlanishi jiddiy matematik tadqiqotlar mavzusi bo'lib, Tub sonlar teoremasi ularning chastotasi haqida tushuncha beradi. Ularning noyob xususiyatlari RSA kabi turli xil kriptografik algoritmlar uchun asos bo'lib, bu yerda katta sonlarni ularning tub ko'paytuvchilariga ajratishning qiyinligi xavfsizlikni ta'minlaydi.

Hisoblash quvvatidagi yutuqlar va kriptografik tizimlarga qarshi hujumlarning doimiy rivojlanishi tufayli katta tub sonlarga bo'lgan ehtiyoj doimiy ravishda ortib bormoqda. Natijada, tobora kattaroq sonlarning tubligini yaratish va sinash qobiliyati muhim ahamiyatga ega.

JavaScript'da BigInt'ni tushunish

JavaScript an'anaviy ravishda juda katta butun sonlar bilan ishlashda cheklovlarga ega. `Number` tipi maksimal xavfsiz butun son qiymatiga ega (2⁵³ - 1). Bundan tashqari, aniqlik yo'qoladi. ES2020 da `BigInt` ning joriy etilishi JavaScript'ning sonlar bilan ishlash imkoniyatlarini inqilob qildi. `BigInt` faqat mavjud xotira bilan cheklangan holda ixtiyoriy aniqlikdagi butun sonlarni ifodalash imkonini beradi.

`BigInt` yaratish oddiy:

            const bigNumber = 123456789012345678901234567890n; // 'n' qo'shimchasiga e'tibor bering
            

              
                Copy
              
            
          

Qo'shish, ayirish, ko'paytirish va bo'lish kabi amallar qo'llab-quvvatlanadi, garchi ba'zi bitli amallar manfiy `BigInt` qiymatlari bilan ishlashda cheklovlarga ega. `BigInt` dan foydalanish JavaScript'da juda katta sonlar bilan ishlash imkoniyatini ochib beradi va katta tub sonlarni yaratish va sinashni amalga oshirishga imkon beradi.

Tub sonlarni yaratish algoritmlari

Tub sonlarni yaratish uchun bir nechta algoritmlar mavjud. Algoritm tanlovi kerakli tub sonlarning hajmiga, ishlash talablariga va tezlik bilan xotira ishlatish o'rtasidagi kelishuvga bog'liq. Mana bir nechta taniqli usullar:

1. Sinov bo'lish

Sinov bo'lish — bu biror sonning tub ekanligini aniqlashning oddiy, ammo samarasiz usuli. U sonni 2 dan boshlab shu sonning kvadrat ildizigacha bo'lgan barcha butun sonlarga bo'lishni o'z ichiga oladi. Agar hech qanday bo'lish butun son bilan natijalanmasa (ya'ni qoldiq 0 bo'lmasa), u holda son tub hisoblanadi.

            function isPrimeTrialDivision(n) { 
 if (n <= 1n) return false; 
 if (n <= 3n) return true; 
 if (n % 2n === 0n || n % 3n === 0n) return false; 
 for (let i = 5n; i * i <= n; i = i + 6n) { 
 if (n % i === 0n || n % (i + 2n) === 0n) return false; 
 } 
 return true; 
}
            

              
                Copy
              
            
          

Sinov bo'lishni amalga oshirish nisbatan oson, lekin uning vaqt murakkabligi O(√n) ni tashkil etadi, ya'ni bajarilish vaqti kiritilgan sonning kvadrat ildiziga proportsional ravishda ortadi. Bu usul juda katta sonlar uchun hisoblash jihatidan qimmatga tushadi.

2. Eratosfen g'alviri

Eratosfen g'alviri — bu berilgan chegaragacha bo'lgan barcha tub sonlarni yaratish uchun samarali algoritm. U eng kichik tub son, ya'ni 2 dan boshlab, har bir tub sonning karralilarini murakkab (tub emas) deb belgilash orqali ishlaydi. Algoritmning vaqt murakkabligi taxminan O(n log log n) ni tashkil etadi.

BigInt yordamida Eratosfen g'alvirini amalga oshirish xotirani ehtiyotkorlik bilan boshqarishni talab qiladi, chunki biz ancha katta diapazonlar bilan ishlashimiz mumkin. Biz g'alvirni faqat chegaraning kvadrat ildizigacha takrorlash orqali optimallashtirishimiz mumkin.

            function sieveOfEratosthenes(limit) { 
 const isPrime = new Array(Number(limit) + 1).fill(true); // Massiv indeksatsiyasi uchun BigInt limitini Number'ga o'zgartirish 
 isPrime[0] = isPrime[1] = false; 
 
 for (let p = 2; p * p <= Number(limit); p++) { // Siklni ishga tushirish uchun Number(limit) 
 if (isPrime[p]) { 
 for (let i = p * p; i <= Number(limit); i += p) { 
 isPrime[i] = false; 
 } 
 } 
 } 
 
 const primes = []; 
 for (let p = 2; p <= Number(limit); p++) { 
 if (isPrime[p]) { 
 primes.push(BigInt(p)); // Yana BigInt'ga o'zgartirish 
 } 
 } 
 
 return primes; 
}
            

              
                Copy
              
            
          

Eslatma: JavaScript massiv indeksatsiyasi BigInt'larni emas, balki Number'larni talab qilganligi sababli, `isPrime` massivining indekslari uchun Number'ga o'zgartirish kerak. Yodda tutingki, qaytariladigan qiymatlar BigInt bo'lishi kerak.

3. Ehtimoliy tublik testlari: Miller-Rabin

Juda katta sonlar uchun deterministik tublik testlari yuqori hisoblash xarajatlari tufayli amaliy bo'lmay qoladi. Ehtimoliy tublik testlari samaraliroq alternativa taklif qiladi. Miller-Rabin testi biror sonning tub bo'lish ehtimolini aniqlaydigan keng qo'llaniladigan algoritmdir. U tublikni aniq isbotlamaydi, ammo testning bir nechta takrorlanishini (raundlarini) bajarish orqali xatolik ehtimolini kamaytirish mumkin.

Miller-Rabin algoritmi quyidagicha ishlaydi:

1. n - 1 ni 2^r * d shaklida yozing, bunda d toq son.
2. [2, n - 2] oralig'ida tasodifiy butun son *a* ni tanlang.
3. x = a^d mod n ni hisoblang.
4. Agar x === 1 yoki x === n - 1 bo'lsa, n ehtimoliy tub son.
5. Quyidagini r - 1 marta takrorlang:
• x = x² mod n ni hisoblang.
• Agar x === n - 1 bo'lsa, n ehtimoliy tub son. Agar x === 1 bo'lsa, n murakkab son.
6. Agar takrorlashlardan keyin testlar muvaffaqiyatsiz bo'lsa, n murakkab son.

            function millerRabin(n, k = 5) { 
 if (n <= 1n) return false; 
 if (n <= 3n) return true; 
 if (n % 2n === 0n) return false; 
 
 // n - 1 = 2^r * d bo'ladigan r va d ni topish 
 let r = 0n; 
 let d = n - 1n; 
 while (d % 2n === 0n) { 
 r++; 
 d /= 2n; 
 } 
 
 for (let i = 0; i < k; i++) { 
 const a = 2n + BigInt(Math.floor(Math.random() * Number(n - 3n))); // Tasodifiy son yaratish 
 let x = modPow(a, d, n); // a^d mod n 
 
 if (x === 1n || x === n - 1n) continue; 
 
 let isComposite = true; 
 for (let j = 0n; j < r - 1n; j++) { 
 x = modPow(x, 2n, n); // x^2 mod n 
 if (x === n - 1n) { 
 isComposite = false; 
 break; 
 } 
 if (x === 1n) return false; // Aniq murakkab 
 } 
 if (isComposite) return false; // Aniq murakkab 
 } 
 return true; // Ehtimoliy tub son 
} 

// Modul bo'yicha darajaga ko'tarish uchun yordamchi funksiya (a^b mod m) 
function modPow(base, exponent, modulus) { 
 let result = 1n; 
 base = base % modulus; 
 if (base === 0n) return 0n; 
 
 while (exponent > 0n) { 
 if (exponent % 2n === 1n) result = (result * base) % modulus; 
 base = (base * base) % modulus; 
 exponent = exponent / 2n; 
 } 
 return result; 
}
            

              
                Copy
              
            
          

`millerRabin` dagi `k` parametri takrorlashlar sonini belgilaydi va tublik testiga bo'lgan ishonchni oshiradi. `k` ning yuqori qiymatlari murakkab sonni noto'g'ri tub deb belgilash ehtimolini kamaytiradi, ammo hisoblash xarajatlarini oshiradi. Miller-Rabin testining vaqt murakkabligi O(k * log³ n) ni tashkil etadi, bunda k — raundlar soni va n — sinovdan o'tkazilayotgan son.

Samaradorlik masalalari va optimallashtirish

JavaScript'da katta sonlar bilan ishlash samaradorlikka ehtiyotkorlik bilan e'tibor berishni talab qiladi. Mana optimallashtirish strategiyalari:

1. Algoritm tanlash

Yuqorida aytib o'tilganidek, sinov bo'lish katta sonlar uchun samarasiz bo'lib qoladi. Miller-Rabin, ayniqsa juda katta BigInt qiymatlarining tubligini sinashda samaradorlik afzalligini beradi. Eratosfen g'alviri o'rtacha chegaragacha bo'lgan bir qator tub sonlarni yaratishingiz kerak bo'lganda amaliydir.

2. Kodni optimallashtirish

• Keraksiz hisob-kitoblardan qoching. Iloji boricha hisob-kitoblarni optimallashtiring.
• Sikllar ichidagi funksiya chaqiruvlari sonini kamaytiring.
• Samarali modul arifmetikasi amallaridan foydalaning. Taqdim etilgan `modPow` funksiyasi samarali hisob-kitoblar uchun juda muhimdir.

3. Oldindan hisoblash va keshlashtirish

Ba'zi ilovalar uchun tub sonlar ro'yxatini oldindan hisoblash va saqlash operatsiyalarni sezilarli darajada tezlashtirishi mumkin. Agar siz ma'lum bir diapazonda tublikni qayta-qayta sinashingiz kerak bo'lsa, bu tub sonlarni keshlashtirish ortiqcha hisob-kitoblarni kamaytiradi.

4. Parallellashtirish (Web Worker'da bo'lishi mumkin)

Juda katta sonlarning tubligini sinash yoki sezilarli diapazondagi tub sonlarni yaratish kabi protsessorga intensiv hisob-kitoblar uchun JavaScript'ning Web Worker'laridan foydalanib, hisob-kitoblarni fonda bajaring. Bu asosiy ish oqimini bloklashning oldini olishga yordam beradi va sezgir foydalanuvchi interfeysini ta'minlaydi.

5. Profil yaratish va benchmarking

Samaradorlikdagi to'siqlarni aniqlash uchun brauzerning ishlab chiquvchi vositalaridan yoki Node.js profil yaratish vositalaridan foydalaning. Turli xil yondashuvlarni turli xil kirish hajmlari bilan benchmarking qilish kodni optimal ishlashi uchun sozlashga yordam beradi.

Amaliy qo'llanilishlar

Katta tub sonlarni yaratish va tublikni sinash ko'plab real dunyo ilovalari uchun asosiy hisoblanadi:

1. Kriptografiya

Eng ko'zga ko'ringan qo'llanilish ochiq kalitli kriptografiyada. Xavfsiz aloqa (HTTPS) uchun keng qo'llaniladigan RSA (Rivest–Shamir–Adleman) algoritmi katta murakkab sonlarni ularning tub ko'paytuvchilariga ajratishning qiyinligiga tayanadi. RSA xavfsizligi katta tub sonlardan foydalanishga bog'liq.

2. Shifrlash uchun kalit yaratish

Butun dunyo bo'ylab ko'plab elektron tijorat tranzaksiyalarida ishlatiladigan xavfsiz aloqa protokollari kuchli kriptografik kalitlarni yaratishni talab qiladi. Tub sonlarni yaratish bu kalitlarni yaratishda muhim qadam bo'lib, maxfiy ma'lumotlar almashinuvini ta'minlaydi.

3. Raqamli imzolar

Raqamli imzolar raqamli hujjatlar va tranzaksiyalarning haqiqiyligi va yaxlitligini ta'minlaydi. DSA (Raqamli imzo algoritmi) va ECDSA (Elliptik egri chiziqli raqamli imzo algoritmi) kabi algoritmlar kalit yaratish va imzolash jarayonlari uchun tub sonlardan foydalanadi. Bu usullar dasturiy ta'minot yuklab olishlarini tasdiqlashdan tortib, moliyaviy tranzaksiyalarni tekshirishgacha bo'lgan keng ko'lamli ilovalarda qo'llaniladi.

4. Xavfsiz tasodifiy sonlarni yaratish

Tub sonlar kriptografik jihatdan xavfsiz psevdo-tasodifiy sonlarni (CSPRNGs) yaratishda ishlatilishi mumkin. Bu tasodifiy sonlar shifrlash, kalit yaratish va xavfsiz aloqa kabi ko'plab xavfsizlik ilovalari uchun juda muhimdir. Tub sonlarning xususiyatlari yuqori darajadagi tasodifiylikni ta'minlashga yordam beradi.

5. Boshqa matematik qo'llanilishlar

Tub sonlar, shuningdek, sonlar nazariyasi, taqsimlangan hisoblashlar va ma'lumotlar fani va mashina o'rganishining ba'zi sohalaridagi tadqiqotlarda ham qo'llaniladi.

Misol: JavaScript'da katta tub sonni yaratish

Bu yerda Miller-Rabin va BigInt yordamida JavaScript'da katta tub sonni yaratish va sinashni namoyish etuvchi misol keltirilgan:

            // Kerakli funksiyalarni import qilish (yuqoridagi kod bloklaridan) - isPrimeTrialDivision, millerRabin, modPow

function generateLargePrime(bits = 2048) {
 let min = 2n ** (BigInt(bits) - 1n); // Belgilangan bitlar bilan min ni yaratish
 let max = (2n ** BigInt(bits)) - 1n; // Belgilangan bitlar bilan max ni yaratish

 let prime;
 do {
 let candidate = min + BigInt(Math.floor(Math.random() * Number(max - min))); // Belgilangan bitlarda tasodifiy son yaratish
 if (millerRabin(candidate, 20)) { // Miller-Rabin yordamida tublikka tekshirish
 prime = candidate;
 break;
 }
 } while (true); 
 
 return prime;
}

const largePrime = generateLargePrime(1024); // 1024-bitli tub son yaratish
console.log("Yaratilgan katta tub son:", largePrime.toString()); 
//  Agar xohlasangiz, uni isPrimeTrialDivision yordamida kichikroq songa nisbatan tekshirishingiz mumkin
// console.log("Sinov bo'lish yordamida tubmi?:", isPrimeTrialDivision(largePrime));  // Diqqat: bu juda uzoq vaqt oladi
            

              
                Copy
              
            
          

Ushbu misol belgilangan bit-hajmi ichida tasodifiy son yaratadi va Miller-Rabin algoritmi yordamida tublikka tekshiradi. `isPrimeTrialDivision` izohga olingan, chunki sinov bo'lish katta sonlarda juda sekin ishlaydi. Siz juda uzoq bajarilish vaqtini ko'rishingiz mumkin. Siz `bits` parametrini o'zgartirib, turli o'lchamdagi tub sonlarni yaratishingiz mumkin, bu esa ajratish qiyinligiga, ya'ni tizimlar xavfsizligiga ta'sir qiladi.

Xavfsizlik masalalari

Tub sonlarni yaratishni ishlab chiqarish muhitida amalga oshirayotganda, xavfsizlik jihatlarini hisobga olish juda muhim:

1. Tasodifiylik

Nomzod tub sonlarni yaratish uchun ishlatiladigan tasodifiy sonlar generatorining sifati juda muhim. Oldindan aytib bo'ladigan yoki noxolis tasodifiy sonlar generatorlaridan saqlaning. Yaratilgan tub sonlarning xavfsizligi va oldindan aytib bo'lmasligini ta'minlash uchun brauzerda `crypto.getRandomValues()` yoki Node.js'dagi `crypto` moduli kabi kriptografik jihatdan xavfsiz tasodifiy sonlar generatoridan (CSPRNG) foydalaning. Bu sonlarni hujumchi tomonidan taxmin qilinmasligini ta'minlaydi.

2. Yon kanal hujumlari

Hisoblashlar paytida ma'lumotlarning sizib chiqishidan foydalanadigan yon kanal hujumlaridan xabardor bo'ling. Amalga oshirishlar bu hujumlarni yumshatish uchun ishlab chiqilishi kerak. Bunga doimiy vaqt algoritmlari va niqoblash usullaridan foydalanish kirishi mumkin.

3. Amalga oshirish xavfsizligi

Buferning to'lib ketishi yoki butun sonning to'lib ketishi kabi zaifliklarning oldini olish uchun barcha kodlarni sinchkovlik bilan sinab ko'ring va tasdiqlang. Kod va kutubxonalarni muntazam ravishda xavfsizlik kamchiliklari uchun tekshirib turing.

4. Kutubxona bog'liqliklari

Agar siz uchinchi tomon kutubxonalaridan foydalansangiz, ularning ishonchli va yangilanganligiga ishonch hosil qiling. Zaifliklarni imkon qadar tezroq bartaraf etish uchun bog'liqliklarni yangilab turing.

5. Kalit hajmi

Ishlatiladigan tub sonlarning hajmi xavfsizlik kuchini belgilaydi. Har doim sanoatning eng yaxshi amaliyotlariga rioya qiling va mo'ljallangan dastur uchun mos o'lchamdagi tub sonlardan foydalaning (masalan, RSA ko'pincha 2048-bit yoki 4096-bit kalit o'lchamlaridan foydalanadi).

Xulosa

JavaScript'ning `BigInt`i katta butun sonlar bilan ishlash uchun mustahkam asosni taqdim etadi, bu esa veb-ilovalarda tub sonlarni o'rganish va ulardan foydalanish imkonini beradi. `BigInt` va Miller-Rabin tublik testining kombinatsiyasi katta tub sonlarni yaratish uchun samarali yondashuvni taklif qiladi. Katta tub sonlarni yaratish va boshqarish qobiliyati zamonaviy kriptografiya uchun asosiy hisoblanadi va xavfsizlik, moliyaviy tranzaksiyalar va ma'lumotlar maxfiyligi bo'yicha keng ko'lamli ilovalarga ega. `BigInt` va samarali algoritmlardan foydalanish JavaScript ishlab chiquvchilari uchun sonlar nazariyasi va kriptografiya sohalarida yangi imkoniyatlarni ochdi.

Dunyo xavfsiz onlayn o'zaro aloqalarga ko'proq tayanishda davom etar ekan, mustahkam tub sonlarni yaratishga bo'lgan talab faqat ortadi. Ushbu qo'llanmada taqdim etilgan usullar va mulohazalarni o'zlashtirib, ishlab chiquvchilar yanada xavfsiz va ishonchli raqamli tizimlarga hissa qo'shishlari mumkin.

Qo'shimcha o'rganish uchun

Bu yerda o'rganish uchun qo'shimcha sohalar mavjud:

• Miller-Rabin'ni optimallashtirish: Miller-Rabin tublik testi uchun yanada ilg'or optimallashtirishlarni tadqiq qiling.
• Deterministik tublik testlari: AKS tublik testi kabi deterministik tublik testlarini o'rganing. Ular hisoblash jihatidan qimmatroq bo'lsa-da, ba'zan talab qilinadigan tublik isbotini taqdim etadi.
• Tub sonlar kutubxonalari: Qo'shimcha vositalar va usullar uchun sonlar nazariyasi va kriptografiyaga bag'ishlangan mavjud JavaScript kutubxonalarini o'rganing.
• Elliptik egri chiziqli kriptografiya (ECC): Elliptik egri chiziqli kriptografiyada tub sonlar qanday ishlatilishini o'rganing. ECC ko'pincha bir xil darajadagi xavfsizlikka erishish uchun kichikroq kalit o'lchamlaridan foydalanadi.
• Taqsimlangan tub sonlarni yaratish: Juda katta tub sonlarni yaratish uchun taqsimlangan hisoblash usullaridan qanday foydalanishni o'rganing.

Doimiy ravishda o'rganish va tajriba o'tkazish orqali siz tub sonlarning to'liq imkoniyatlarini va ularning raqamli dunyoga chuqur ta'sirini ochishingiz mumkin.