Calcolare Numeri Primi Con Numeri Maggiori Di 100 Javascript

Guida Completa: Come Calcolare Numeri Primi Maggiori di 100 con JavaScript

I numeri primi rappresentano una delle fondamenta della teoria dei numeri e della crittografia moderna. Mentre i numeri primi minori di 100 sono relativamente semplici da identificare, lavorare con numeri primi maggiori di 100 richiede approcci algoritmici più sofisticati per mantenere l’efficienza computazionale.

Perché i Numeri Primi > 100 Sono Importanti

• Crittografia RSA: Gli algoritmi di crittografia asimmetrica come RSA si basano su numeri primi molto grandi (tipicamente 1024 bit o più) per garantire la sicurezza delle comunicazioni.
• Teoria dei numeri: Lo studio della distribuzione dei numeri primi (come l’ipotesi di Riemann) si concentra spesso su intervalli superiori a 100.
• Applicazioni pratiche: Dalla generazione di chiavi sicure ai test di primalità in protocolli blockchain, i numeri primi grandi sono onnipresenti nella tecnologia moderna.

Metodi per Calcolare Numeri Primi > 100

1. Metodo della Prova per Divisione (Trial Division)

Il metodo più semplice ma meno efficiente. Per verificare se un numero n è primo, si divide n per tutti i numeri interi da 2 a √n:

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

2. Crivello di Eratostene (Sieve of Eratosthenes)

Ottimizzato per trovare tutti i numeri primi fino a un limite n. Crea una tabella booleana e "setaccia" i multipli dei numeri primi trovati:

function sieveOfEratosthenes(limit) {
    let sieve = new Array(limit + 1).fill(true);
    sieve[0] = sieve[1] = false;
    for (let p = 2; p * p <= limit; p++) {
        if (sieve[p]) {
            for (let i = p * p; i <= limit; i += p) {
                sieve[i] = false;
            }
        }
    }
    return sieve.reduce((primes, isPrime, num) =>
        isPrime ? [...primes, num] : primes, []);
}

3. Test di Miller-Rabin (Probabilistico)

Un algoritmo probabilistico più efficiente per numeri molto grandi. La sua complessità è O(k log³n), dove k è il numero di iterazioni:

function isPrimeMillerRabin(n, k = 5) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 === 0) return false;

    let d = n - 1;
    let s = 0;
    while (d % 2 === 0) {
        d /= 2;
        s++;
    }

    for (let i = 0; i < k; i++) {
        let a = 2 + Math.floor(Math.random() * (n - 3));
        let x = modPow(a, d, n);
        if (x === 1 || x === n - 1) continue;

        let isComposite = true;
        for (let j = 0; j < s - 1; j++) {
            x = modPow(x, 2, n);
            if (x === n - 1) {
                isComposite = false;
                break;
            }
        }
        if (isComposite) return false;
    }
    return true;
}

Confronto delle Prestazioni

Metodo	Complessità	Tempo per n=1,000	Tempo per n=10,000	Precisione
Prova per Divisione	O(√n)	~15ms	~500ms	100%
Crivello di Eratostene	O(n log log n)	~5ms	~80ms	100%
Miller-Rabin (k=5)	O(k log³n)	~10ms	~120ms	99.9999%

Ottimizzazioni per JavaScript

1. Web Workers: Esegui calcoli intensivi in un thread separato per evitare il blocco dell'interfaccia utente:

   const worker = new Worker('prime-worker.js');
   worker.postMessage({ start: 101, end: 1000 });
   worker.onmessage = (e) => console.log(e.data);

2. Typed Arrays: Utilizza Uint8Array o Uint32Array per il crivello per ridurre l'uso di memoria.
3. Memoization: Cache i risultati dei test di primalità per evitare calcoli ridondanti.
4. Bitwise Operations: Sostituisci i % 2 con i & 1 per verifiche di pari/dispari.

Applicazioni Pratiche in JavaScript

Ecco alcuni casi d'uso reali dove il calcolo di numeri primi > 100 è cruciale:

• Generazione di chiavi RSA: Librerie come Node.js Crypto utilizzano numeri primi grandi per creare coppie di chiavi pubbliche/private.
• Blockchain: Alcuni algoritmi di consenso (come Proof-of-Work) si basano su funzioni hash che coinvolgono numeri primi.
• Simulazioni scientifiche: In fisica quantistica, i numeri primi appaiono in modelli di distribuzione energetica.

Errori Comuni da Evitare

Errore	Conseguenza	Soluzione
Non gestire i limiti di Number.MAX_SAFE_INTEGER (2⁵³ - 1)	Risultati errati per numeri > 9,007,199,254,740,991	Usa BigInt per numeri molto grandi
Dimenticare di controllare la divisibilità per 2 e 3	Aumento inutile del 50% dei cicli di calcolo	Filtra prima i numeri pari e divisibili per 3
Usare Math.sqrt(n) in loop critici	Ricalcolo costoso della radice quadrata	Calcola Math.sqrt(n) una volta fuori dal loop

Risorse Accademiche

Per approfondire la teoria matematica dietro i numeri primi:

• Corso su Teoria dei Numeri - UC Berkeley (include dimostrazioni sulla distribuzione dei primi)
• NIST FIPS 186-4 (Standard governativo USA per la generazione di numeri primi in crittografia)
• The Prime Pages - University of Tennessee at Martin (Database completo sui record dei numeri primi)

Esempio Pratico: Implementazione Completa

Ecco come integrare il calcolatore in una pagina web:

<!DOCTYPE html>
<html>
<head>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
    <div id="app">
        <input type="number" id="start" min="101" value="101">
        <input type="number" id="end" min="102" value="200">
        <button onclick="calculatePrimes()">Calcola</button>
        <div id="results"></div>
        <canvas id="chart"></canvas>
    </div>

    <script>
        function calculatePrimes() {
            const start = parseInt(document.getElementById('start').value);
            const end = parseInt(document.getElementById('end').value);
            const primes = [];

            for (let num = start; num <= end; num++) {
                if (isPrime(num)) primes.push(num);
            }

            document.getElementById('results').innerHTML =
                `<h3>Numeri primi tra ${start} e ${end}:</h3>
                 <p>Trovati ${primes.length} numeri primi</p>
                 <div>${primes.join(', ')}</div>`;

            renderChart(primes, start, end);
        }

        function renderChart(primes, start, end) {
            const ctx = document.getElementById('chart').getContext('2d');
            const allNumbers = Array.from({length: end - start + 1},
                (_, i) => start + i);
            const isPrime = allNumbers.map(n => primes.includes(n));

            new Chart(ctx, {
                type: 'bar',
                data: {
                    labels: allNumbers.filter((_, i) => i % 10 === 0),
                    datasets: [{
                        label: 'Numeri Primi',
                        data: isPrime.map(p => p ? 1 : 0),
                        backgroundColor: '#2563eb',
                        borderWidth: 0
                    }]
                },
                options: {
                    responsive: true,
                    scales: { y: { beginAtZero: true, max: 1 } },
                    plugins: { legend: { display: false } }
                }
            });
        }

        function isPrime(n) {
            if (n <= 1) return false;
            if (n <= 3) return true;
            if (n % 2 === 0 || n % 3 === 0) return false;
            for (let i = 5; i * i <= n; i += 6) {
                if (n % i === 0 || n % (i + 2) === 0) return false;
            }
            return true;
        }
    </script>
</body>
</html>