Calcolatore di Probabilità dalla Funzione di Ripartizione

Inserisci i parametri della tua funzione di ripartizione (CDF) per calcolare le probabilità associate a specifici intervalli o valori.

Tipo di Distribuzione

Media (μ)

Deviazione Standard (σ)

Minimo (a)

Massimo (b)

Parametro λ (Lambda)

Funzione di Ripartizione (CDF) in formato JavaScript

<label for="wpc-probability-type" class="wpc-label">Tipo di Calcolo</label>
                <select id="wpc-probability-type" class="wpc-select">
                    <option value="point">P(X = x)</option>
                    <option value="less">P(X ≤ x)</option>
                    <option value="greater">P(X > x)</option>
                    <option value="range">P(a ≤ X ≤ b)</option>
                </select>
            </div>

<div id="wpc-point-param" class="wpc-param-group">
                <div class="wpc-form-group">
                    <label for="wpc-point-value" class="wpc-label">Valore x</label>
                    <input type="number" id="wpc-point-value" class="wpc-input" placeholder="Es. 0.5" step="0.01" value="0.5">
                </div>
            </div>

<div id="wpc-range-param" class="wpc-param-group" style="display: none;">
                <div class="wpc-form-group">
                    <label for="wpc-range-a" class="wpc-label">Limite Inferiore (a)</label>
                    <input type="number" id="wpc-range-a" class="wpc-input" placeholder="Es. -1" step="0.01" value="-1">
                </div>
                <div class="wpc-form-group">
                    <label for="wpc-range-b" class="wpc-label">Limite Superiore (b)</label>
                    <input type="number" id="wpc-range-b" class="wpc-input" placeholder="Es. 1" step="0.01" value="1">
                </div>
            </div>

<button type="button" id="wpc-calculate-btn" class="wpc-button">Calcola Probabilità</button>
        </form>

<div id="wpc-results" class="wpc-results" style="display: none;">
            <div class="wpc-result-title">Risultato:</div>
            <div id="wpc-result-value" class="wpc-result-value"></div>
            <div id="wpc-result-details" class="wpc-result-details" style="margin-top: 0.75rem;"></div>
        </div>

<div class="wpc-content">
        <h2>Guida Completa: Come Calcolare le Probabilità Avendo la Funzione di Ripartizione (CDF)</h2>

<p>La <strong>funzione di ripartizione</strong> (CDF, Cumulative Distribution Function) è uno strumento fondamentale in probabilità e statistica. Essa descrive la probabilità che una variabile casuale <em>X</em> assuma un valore minore o uguale a un certo <em>x</em>, ossia <em>P(X ≤ x)</em>. In questa guida, esploreremo come utilizzare la CDF per calcolare diverse probabilità, con esempi pratici e applicazioni reali.</p>

<h3>1. Cos’è la Funzione di Ripartizione (CDF)?</h3>
        <p>La CDF di una variabile casuale <em>X</em> è definita come:</p>
        <p style="text-align: center; font-style: italic; font-size: 1.1rem; margin: 1.5rem 0;">F(x) = P(X ≤ x)</p>
        <p>Proprietà fondamentali della CDF:</p>
        <ul>
            <li><strong>Monotonia non decrescente</strong>: Se <em>a ≤ b</em>, allora <em>F(a) ≤ F(b)</em>.</li>
            <li><strong>Limiti</strong>:
                <ul>
                    <li>lim<sub>x→-∞</sub> F(x) = 0</li>
                    <li>lim<sub>x→+∞</sub> F(x) = 1</li>
                </ul>
            </li>
            <li><strong>Continuità a destra</strong>: F(x) è continua a destra per ogni <em>x</em>.</li>
        </ul>

<h3>2. Come Calcolare Probabilità dalla CDF</h3>
        <p>La CDF permette di calcolare diverse probabilità:</p>

<ol>
            <li><strong>Probabilità che X sia minore o uguale a x</strong>:
                <p><em>P(X ≤ x) = F(x)</em></p>
            </li>
            <li><strong>Probabilità che X sia maggiore di x</strong>:
                <p><em>P(X > x) = 1 – F(x)</em></p>
            </li>
            <li><strong>Probabilità che X sia compresa tra a e b</strong>:
                <p><em>P(a ≤ X ≤ b) = F(b) – F(a)</em></p>
            </li>
            <li><strong>Probabilità che X sia uguale a x (per variabili continue)</strong>:
                <p>Per variabili continue, <em>P(X = x) = 0</em> per qualsiasi <em>x</em>.</p>
            </li>
        </ol>

<h3>3. Esempi Pratici con Distribuzioni Comuni</h3>

<h4>3.1 Distribuzione Normale (Gaussiana)</h4>
        <p>La CDF della distribuzione normale standard (μ=0, σ=1) è spesso indicata come Φ(x). Per una normale generica:</p>
        <p style="text-align: center; font-style: italic;">F(x) = Φ((x – μ) / σ)</p>
        <p><strong>Esempio</strong>: Calcolare <em>P(X ≤ 1.5)</em> per <em>X ~ N(0, 1)</em>.</p>
        <p><em>P(X ≤ 1.5) = Φ(1.5) ≈ 0.9332</em> (93.32%)</p>

<h4>3.2 Distribuzione Uniforme</h4>
        <p>Per una variabile uniforme <em>U(a, b)</em>, la CDF è:</p>
        <p style="text-align: center; font-style: italic;">
            F(x) = (x – a) / (b – a)   per <em>a ≤ x ≤ b</em>
        </p>
        <p><strong>Esempio</strong>: Calcolare <em>P(0.3 ≤ X ≤ 0.7)</em> per <em>X ~ U(0, 1)</em>.</p>
        <p><em>P(0.3 ≤ X ≤ 0.7) = F(0.7) – F(0.3) = 0.7 – 0.3 = 0.4</em> (40%)</p>

<h4>3.3 Distribuzione Esponenziale</h4>
        <p>La CDF della distribuzione esponenziale con parametro λ è:</p>
        <p style="text-align: center; font-style: italic;">
            F(x) = 1 – e<sup>-λx</sup>   per <em>x ≥ 0</em>
        </p>
        <p><strong>Esempio</strong>: Calcolare <em>P(X > 2)</em> per <em>X ~ Exp(λ=0.5)</em>.</p>
        <p><em>P(X > 2) = 1 – F(2) = e<sup>-0.5*2</sup> ≈ 0.3679</em> (36.79%)</p>

<h3>4. Confronto tra Distribuzioni Comuni</h3>
        <table class="wpc-table">
            <thead>
                <tr>
                    <th>Distribuzione</th>
                    <th>CDF</th>
                    <th>Media</th>
                    <th>Varianza</th>
                    <th>Applicazioni Tipiche</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Normale</td>
                    <td>Φ((x-μ)/σ)</td>
                    <td>μ</td>
                    <td>σ²</td>
                    <td>Misure fisiche, errori di misurazione, IQ</td>
                </tr>
                <tr>
                    <td>Uniforme</td>
                    <td>(x-a)/(b-a)</td>
                    <td>(a+b)/2</td>
                    <td>(b-a)²/12</td>
                    <td>Generazione numeri casuali, tempi di attesa uniformi</td>
                </tr>
                <tr>
                    <td>Esponenziale</td>
                    <td>1 – e<sup>-λx</sup></td>
                    <td>1/λ</td>
                    <td>1/λ²</td>
                    <td>Tempi di attesa, affidabilità, decadimento radioattivo</td>
                </tr>
            </tbody>
        </table>

<h3>5. Errori Comuni da Evitare</h3>
        <ul>
            <li><strong>Confondere CDF e PDF</strong>: La CDF è <em>P(X ≤ x)</em>, mentre la PDF (Probability Density Function) è la sua derivata (per variabili continue).</li>
            <li><strong>Dimenticare la continuità</strong>: Per variabili continue, <em>P(X = x) = 0</em>. Usare sempre intervalli aperti o chiusi correttamente.</li>
            <li><strong>Parametri sbagliati</strong>: Assicurarsi che i parametri (μ, σ, λ, etc.) siano corretti per la distribuzione scelta.</li>
            <li><strong>Approssimazioni</strong>: Per distribuzioni discrete, la CDF è una funzione a gradini, non continua.</li>
        </ul>

<h3>6. Applicazioni Pratiche della CDF</h3>
        <ol>
            <li><strong>Ingegnia</strong>: Calcolo dell’affidabilità dei sistemi (es. tempo medio tra guasti).</li>
            <li><strong>Finanza</strong>: Valutazione del rischio (es. Value at Risk, VaR).</li>
            <li><strong>Medicina</strong>: Analisi della sopravvivenza (es. curve di Kaplan-Meier).</li>
            <li><strong>Machine Learning</strong>: Classificazione probabilistica (es. Naive Bayes).</li>
            <li><strong>Fisica</strong>: Modelli di decadimento particellare.</li>
        </ol>

<h3>7. Risorse Autorevoli</h3>
        <p>Per approfondire:</p>
        <ul>
            <li><a href="https://www.itl.nist.gov/div898/handbook/eda/section3/eda36.htm" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST/SEMATECH e-Handbook of Statistical Methods – CDF</a></li>
            <li><a href="https://seeing-theory.brown.edu/probability-distributions/index.html" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">Brown University – Probability Distributions (Interactive)</a></li>
            <li><a href="https://statistics.berkeley.edu/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">UC Berkeley Department of Statistics</a></li>
        </ul>

<h3>8. Domande Frequenti (FAQ)</h3>

<h4>8.1 Come si calcola la CDF inversa (Quantile Function)?</h4>
        <p>La CDF inversa, detta anche <strong>funzione quantile</strong>, è definita come:</p>
        <p style="text-align: center; font-style: italic;">F<sup>-1</sup>(p) = inf {x : F(x) ≥ p}</p>
        <p>Per distribuzioni continue con CDF invertibile, si ottiene risolvendo <em>F(x) = p</em> per <em>x</em>.</p>

<h4>8.2 Qual è la relazione tra CDF e PDF?</h4>
        <p>Per variabili continue, la PDF è la derivata della CDF:</p>
        <p style="text-align: center; font-style: italic;">f(x) = dF(x)/dx</p>
        <p>Viceversa, la CDF è l’integrale della PDF:</p>
        <p style="text-align: center; font-style: italic;">F(x) = ∫<sub>-∞</sub><sup>x</sup> f(t) dt</p>

<h4>8.3 Come si usa la CDF per generare numeri casuali?</h4>
        <p>Il metodo della <strong>trasformazione inversa</strong> sfrutta la CDF inversa:</p>
        <ol>
            <li>Genera un numero casuale <em>U ~ U(0,1)</em>.</li>
            <li>Calcola <em>X = F<sup>-1</sup>(U)</em>.</li>
        </ol>
        <p><em>X</em> avrà la distribuzione desiderata con CDF <em>F</em>.</p>

<h3>9. Confronto tra Metodi di Calcolo</h3>
        <table class="wpc-table">
            <thead>
                <tr>
                    <th>Metodo</th>
                    <th>Precisione</th>
                    <th>Velocità</th>
                    <th>Applicabilità</th>
                    <th>Esempio</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Formula Analitica</td>
                    <td>Alta</td>
                    <td>Molto Veloce</td>
                    <td>Distribuzioni standard (Normale, Esponenziale)</td>
                    <td>Φ(x) per la Normale</td>
                </tr>
                <tr>
                    <td>Integrazione Numerica</td>
                    <td>Media-Alta</td>
                    <td>Lenta</td>
                    <td>CDF non invertibili analiticamente</td>
                    <td>Metodo di Simpson</td>
                </tr>
                <tr>
                    <td>Approssimazione</td>
                    <td>Bassa-Media</td>
                    <td>Veloce</td>
                    <td>Calcoli rapidi in tempo reale</td>
                    <td>Approssimazione di Abramowitz per Φ(x)</td>
                </tr>
                <tr>
                    <td>Tabelle Precalcolate</td>
                    <td>Media</td>
                    <td>Molto Veloce</td>
                    <td>Distribuzioni standard (es. t-Student)</td>
                    <td>Tabella Z per Normale Standard</td>
                </tr>
            </tbody>
        </table>

<h3>10. Conclusione</h3>
        <p>La funzione di ripartizione (CDF) è uno strumento potente per calcolare probabilità in modo sistematico. Che tu stia lavorando con distribuzioni teoriche o dati empirici, comprendere come utilizzare la CDF ti permetterà di:</p>
        <ul>
            <li>Calcolare probabilità per qualsiasi intervallo.</li>
            <li>Determinare percentili e quantili.</li>
            <li>Generare variabili casuali con distribuzioni specifiche.</li>
            <li>Valutare modelli statistici e ipotesi.</li>
        </ul>
        <p>Con la pratica e gli esempi forniti in questa guida, sarai in grado di applicare questi concetti a problemi reali in campi come l’ingegneria, la finanza, la medicina e oltre.</p>
    </div>
</section>

// Parameter Groups
        const paramGroups = {
            normal: document.getElementById('wpc-normal-params'),
            uniform: document.getElementById('wpc-uniform-params'),
            exponential: document.getElementById('wpc-exponential-params'),
            custom: document.getElementById('wpc-custom-params')
        };

// Probability Parameter Groups
        const probParamGroups = {
            point: document.getElementById('wpc-point-param'),
            range: document.getElementById('wpc-range-param')
        };

// Chart instance
        let probabilityChart = null;

// Toggle parameter groups based on distribution type
        distributionType.addEventListener('change', function() {
            Object.values(paramGroups).forEach(group => group.style.display = 'none');
            paramGroups[this.value].style.display = 'block';
        });

// Toggle probability parameter groups
        probabilityType.addEventListener('change', function() {
            probParamGroups.point.style.display = 'none';
            probParamGroups.range.style.display = 'none';

if (this.value === 'range') {
                probParamGroups.range.style.display = 'block';
            } else {
                probParamGroups.point.style.display = 'block';
            }
        });

// Calculate button click handler
        calculateBtn.addEventListener('click', function() {
            try {
                const distType = distributionType.value;
                const probType = probabilityType.value;
                let result, details, chartData;

// Get parameters based on distribution type
                switch (distType) {
                    case 'normal':
                        const mean = parseFloat(document.getElementById('wpc-mean').value);
                        const stdDev = parseFloat(document.getElementById('wpc-std-dev').value);
                        if (stdDev <= 0) throw new Error("La deviazione standard deve essere positiva.");

// Standard normal CDF approximation (Abramowitz and Stegun)
                        function standardNormalCDF(x) {
                            const a1 =  0.254829592;
                            const a2 = -0.284496736;
                            const a3 =  1.421413741;
                            const a4 = -1.453152027;
                            const a5 =  1.061405429;
                            const p  =  0.3275911;

const sign = x < 0 ? -1 : 1;
                            const absX = Math.abs(x);
                            const t = 1.0 / (1.0 + p * absX);
                            const y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);

return sign < 0 ? 1 - y : y;
                        }

function normalCDF(x, mu, sigma) {
                            return standardNormalCDF((x - mu) / sigma);
                        }

// Calculate based on probability type
                        if (probType === 'point') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 0; // P(X = x) = 0 for continuous distributions
                            details = "Per una variabile continua, la probabilità in un punto singolo è sempre 0.";
                            chartData = generateChartData(normalCDF, mean - 4*stdDev, mean + 4*stdDev, 100, mean, stdDev);
                        } else if (probType === 'less') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = normalCDF(x, mean, stdDev);
                            details = `P(X ≤ ${x.toFixed(2)}) = F(${x.toFixed(2)})`;
                            chartData = generateChartData(normalCDF, mean - 4*stdDev, mean + 4*stdDev, 100, mean, stdDev, x);
                        } else if (probType === 'greater') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 1 - normalCDF(x, mean, stdDev);
                            details = `P(X > ${x.toFixed(2)}) = 1 - F(${x.toFixed(2)})`;
                            chartData = generateChartData(normalCDF, mean - 4*stdDev, mean + 4*stdDev, 100, mean, stdDev, x);
                        } else if (probType === 'range') {
                            const a = parseFloat(document.getElementById('wpc-range-a').value);
                            const b = parseFloat(document.getElementById('wpc-range-b').value);
                            if (a > b) throw new Error("Il limite inferiore deve essere minore di quello superiore.");
                            result = normalCDF(b, mean, stdDev) - normalCDF(a, mean, stdDev);
                            details = `P(${a.toFixed(2)} ≤ X ≤ ${b.toFixed(2)}) = F(${b.toFixed(2)}) - F(${a.toFixed(2)})`;
                            chartData = generateChartData(normalCDF, mean - 4*stdDev, mean + 4*stdDev, 100, mean, stdDev, a, b);
                        }
                        break;

case 'uniform':
                        const min = parseFloat(document.getElementById('wpc-min').value);
                        const max = parseFloat(document.getElementById('wpc-max').value);
                        if (min >= max) throw new Error("Il valore minimo deve essere minore di quello massimo.");

function uniformCDF(x, a, b) {
                            if (x < a) return 0;
                            if (x >= b) return 1;
                            return (x - a) / (b - a);
                        }

if (probType === 'point') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 0; // P(X = x) = 0 for continuous distributions
                            details = "Per una variabile continua, la probabilità in un punto singolo è sempre 0.";
                            chartData = generateChartData((x) => uniformCDF(x, min, max), min - 0.5, max + 0.5, 100);
                        } else if (probType === 'less') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = uniformCDF(x, min, max);
                            details = `P(X ≤ ${x.toFixed(2)}) = F(${x.toFixed(2)})`;
                            chartData = generateChartData((x) => uniformCDF(x, min, max), min - 0.5, max + 0.5, 100, null, null, x);
                        } else if (probType === 'greater') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 1 - uniformCDF(x, min, max);
                            details = `P(X > ${x.toFixed(2)}) = 1 - F(${x.toFixed(2)})`;
                            chartData = generateChartData((x) => uniformCDF(x, min, max), min - 0.5, max + 0.5, 100, null, null, x);
                        } else if (probType === 'range') {
                            const a = parseFloat(document.getElementById('wpc-range-a').value);
                            const b = parseFloat(document.getElementById('wpc-range-b').value);
                            if (a > b) throw new Error("Il limite inferiore deve essere minore di quello superiore.");
                            result = uniformCDF(b, min, max) - uniformCDF(a, min, max);
                            details = `P(${a.toFixed(2)} ≤ X ≤ ${b.toFixed(2)}) = F(${b.toFixed(2)}) - F(${a.toFixed(2)})`;
                            chartData = generateChartData((x) => uniformCDF(x, min, max), min - 0.5, max + 0.5, 100, null, null, a, b);
                        }
                        break;

case 'exponential':
                        const lambda = parseFloat(document.getElementById('wpc-lambda').value);
                        if (lambda <= 0) throw new Error("Lambda deve essere positiva.");

function exponentialCDF(x, λ) {
                            return x < 0 ? 0 : 1 - Math.exp(-λ * x);
                        }

if (probType === 'point') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 0; // P(X = x) = 0 for continuous distributions
                            details = "Per una variabile continua, la probabilità in un punto singolo è sempre 0.";
                            chartData = generateChartData((x) => exponentialCDF(x, lambda), 0, 10/lambda, 100);
                        } else if (probType === 'less') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = exponentialCDF(x, lambda);
                            details = `P(X ≤ ${x.toFixed(2)}) = F(${x.toFixed(2)})`;
                            chartData = generateChartData((x) => exponentialCDF(x, lambda), 0, 10/lambda, 100, null, null, x);
                        } else if (probType === 'greater') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 1 - exponentialCDF(x, lambda);
                            details = `P(X > ${x.toFixed(2)}) = 1 - F(${x.toFixed(2)})`;
                            chartData = generateChartData((x) => exponentialCDF(x, lambda), 0, 10/lambda, 100, null, null, x);
                        } else if (probType === 'range') {
                            const a = parseFloat(document.getElementById('wpc-range-a').value);
                            const b = parseFloat(document.getElementById('wpc-range-b').value);
                            if (a > b) throw new Error("Il limite inferiore deve essere minore di quello superiore.");
                            result = exponentialCDF(b, lambda) - exponentialCDF(a, lambda);
                            details = `P(${a.toFixed(2)} ≤ X ≤ ${b.toFixed(2)}) = F(${b.toFixed(2)}) - F(${a.toFixed(2)})`;
                            chartData = generateChartData((x) => exponentialCDF(x, lambda), 0, 10/lambda, 100, null, null, a, b);
                        }
                        break;

case 'custom':
                        const customCDFText = document.getElementById('wpc-custom-cdf').value;
                        let customCDF;
                        try {
                            // Wrap the custom CDF in a function to avoid scope issues
                            customCDF = new Function('x', `return (${customCDFText})(x);`);
                        } catch (e) {
                            throw new Error("Errore nella funzione CDF personalizzata: " + e.message);
                        }

if (probType === 'point') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            // For custom CDF, we can't assume it's continuous, so we'll allow point probability
                            result = customCDF(x);
                            details = `P(X = ${x.toFixed(2)}) = F(${x.toFixed(2)}) - F(${x.toFixed(2)}-) (approssimato)`;
                            chartData = generateChartData(customCDF, -5, 5, 100, null, null, x);
                        } else if (probType === 'less') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = customCDF(x);
                            details = `P(X ≤ ${x.toFixed(2)}) = F(${x.toFixed(2)})`;
                            chartData = generateChartData(customCDF, -5, 5, 100, null, null, x);
                        } else if (probType === 'greater') {
                            const x = parseFloat(document.getElementById('wpc-point-value').value);
                            result = 1 - customCDF(x);
                            details = `P(X > ${x.toFixed(2)}) = 1 - F(${x.toFixed(2)})`;
                            chartData = generateChartData(customCDF, -5, 5, 100, null, null, x);
                        } else if (probType === 'range') {
                            const a = parseFloat(document.getElementById('wpc-range-a').value);
                            const b = parseFloat(document.getElementById('wpc-range-b').value);
                            if (a > b) throw new Error("Il limite inferiore deve essere minore di quello superiore.");
                            result = customCDF(b) - customCDF(a);
                            details = `P(${a.toFixed(2)} ≤ X ≤ ${b.toFixed(2)}) = F(${b.toFixed(2)}) - F(${a.toFixed(2)})`;
                            chartData = generateChartData(customCDF, -5, 5, 100, null, null, a, b);
                        }
                        break;
                }

// Display results
                resultValue.textContent = (result * 100).toFixed(4) + "%";
                resultDetails.textContent = details;
                resultsDiv.style.display = 'block';

// Update chart
                updateChart(chartData);

} catch (error) {
                alert("Errore: " + error.message);
            }
        });

// Initialize parameter groups
        Object.values(paramGroups).forEach(group => group.style.display = 'none');
        paramGroups[distributionType.value].style.display = 'block';

// Initialize probability parameter groups
        probParamGroups.range.style.display = 'none';

// Chart functions
        function generateChartData(cdf, minX, maxX, points, mean=null, stdDev=null, highlightX=null, highlightA=null, highlightB=null) {
            const data = [];
            const step = (maxX - minX) / points;

for (let i = 0; i <= points; i++) {
                const x = minX + i * step;
                data.push({
                    x: x,
                    y: cdf(x)
                });
            }

// Add PDF for normal distribution if applicable
            const pdfData = [];
            if (mean !== null && stdDev !== null) {
                for (let i = 0; i <= points; i++) {
                    const x = minX + i * step;
                    const pdf = (1 / (stdDev * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((x - mean) / stdDev, 2));
                    pdfData.push({
                        x: x,
                        y: pdf
                    });
                }
            }

return {
                cdf: data,
                pdf: pdfData.length > 0 ? pdfData : null,
                highlightX: highlightX,
                highlightA: highlightA,
                highlightB: highlightB,
                minX: minX,
                maxX: maxX
            };
        }

function updateChart(chartData) {
            if (probabilityChart) {
                probabilityChart.destroy();
            }

const ctx = chartCanvas.getContext('2d');

// Create datasets
            const datasets = [{
                label: 'Funzione di Ripartizione (CDF)',
                data: chartData.cdf,
                borderColor: '#2563eb',
                backgroundColor: 'rgba(37, 99, 235, 0.1)',
                borderWidth: 2,
                pointRadius: 0,
                tension: 0.1,
                yAxisID: 'y'
            }];

if (chartData.pdf) {
                datasets.push({
                    label: 'Funzione di Densità (PDF)',
                    data: chartData.pdf,
                    borderColor: '#ef4444',
                    backgroundColor: 'rgba(239, 68, 68, 0.1)',
                    borderWidth: 2,
                    pointRadius: 0,
                    tension: 0.1,
                    yAxisID: 'y1'
                });
            }

// Add vertical lines for highlights
            if (chartData.highlightX !== null) {
                datasets.push({
                    label: chartData.highlightB !== null ? 'Intervallo' : 'Valore',
                    data: [
                        {x: chartData.highlightX, y: 0},
                        {x: chartData.highlightX, y: chartData.cdf.find(d => d.x >= chartData.highlightX).y}
                    ],
                    borderColor: '#10b981',
                    backgroundColor: 'rgba(16, 185, 129, 0.1)',
                    borderWidth: 2,
                    borderDash: [5, 5],
                    pointRadius: 0,
                    yAxisID: 'y'
                });
            }

if (chartData.highlightA !== null && chartData.highlightB !== null) {
                // Area between a and b
                const areaData = chartData.cdf.filter(d => d.x >= chartData.highlightA && d.x <= chartData.highlightB);
                datasets.push({
                    label: 'Area Probabilità',
                    data: areaData,
                    borderColor: 'rgba(16, 185, 129, 0.3)',
                    backgroundColor: 'rgba(16, 185, 129, 0.2)',
                    borderWidth: 1,
                    pointRadius: 0,
                    tension: 0.1,
                    yAxisID: 'y',
                    fill: true
                });

// Vertical lines for a and b
                datasets.push({
                    label: 'Limite Inferiore',
                    data: [
                        {x: chartData.highlightA, y: 0},
                        {x: chartData.highlightA, y: chartData.cdf.find(d => d.x >= chartData.highlightA).y}
                    ],
                    borderColor: '#f97316',
                    backgroundColor: 'rgba(249, 115, 22, 0.1)',
                    borderWidth: 2,
                    borderDash: [5, 5],
                    pointRadius: 0,
                    yAxisID: 'y'
                });

datasets.push({
                    label: 'Limite Superiore',
                    data: [
                        {x: chartData.highlightB, y: 0},
                        {x: chartData.highlightB, y: chartData.cdf.find(d => d.x >= chartData.highlightB).y}
                    ],
                    borderColor: '#f97316',
                    backgroundColor: 'rgba(249, 115, 22, 0.1)',
                    borderWidth: 2,
                    borderDash: [5, 5],
                    pointRadius: 0,
                    yAxisID: 'y'
                });
            }

probabilityChart = new Chart(ctx, {
                type: 'line',
                data: {
                    datasets: datasets
                },
                options: {
                    responsive: true,
                    maintainAspectRatio: false,
                    interaction: {
                        mode: 'index',
                        intersect: false,
                    },
                    plugins: {
                        legend: {
                            position: 'top',
                        },
                        tooltip: {
                            callbacks: {
                                label: function(context) {
                                    if (context.dataset.yAxisID === 'y1') {
                                        return `PDF: ${context.raw.y.toFixed(4)}`;
                                    } else {
                                        return `CDF: ${context.raw.y.toFixed(4)}`;
                                    }
                                }
                            }
                        }
                    },
                    scales: {
                        x: {
                            type: 'linear',
                            display: true,
                            title: {
                                display: true,
                                text: 'Valore (x)'
                            },
                            min: chartData.minX,
                            max: chartData.maxX
                        },
                        y: {
                            type: 'linear',
                            display: true,
                            position: 'left',
                            title: {
                                display: true,
                                text: 'Probabilità Cumulativa'
                            },
                            min: 0,
                            max: 1
                        },
                        y1: chartData.pdf ? {
                            type: 'linear',
                            display: true,
                            position: 'right',
                            title: {
                                display: true,
                                text: 'Densità di Probabilità'
                            },
                            grid: {
                                drawOnChartArea: false,
                            },
                            min: 0
                        } : undefined
                    }
                }
            });
        }
    });
</script>
		</div>

</article>

</div>

<div class="ct-comments" id="comments">
	
	
	
	
		<div id="respond" class="comment-respond">
		<h2 id="reply-title" class="comment-reply-title">Leave a Reply<span class="ct-cancel-reply"><a rel="nofollow" id="cancel-comment-reply-link" href="/calcolare-probabilit-avendo-funzione-di-ripartizione/#respond" style="display:none;">Cancel Reply</a></span></h2><form action="https://cal48.calculator.city/wp-comments-post.php" method="post" id="commentform" class="comment-form has-website-field has-labels-inside"><p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> <span class="required-field-message">Required fields are marked <span class="required">*</span></span></p><p class="comment-form-field-input-author">
			<label for="author">Name <b class="required"> *</b></label>
			<input id="author" name="author" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-email">
				<label for="email">Email <b class="required"> *</b></label>
				<input id="email" name="email" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-url">
				<label for="url">Website</label>
				<input id="url" name="url" type="text" value="" size="30">
				</p>

<p class="comment-form-field-textarea">
			<label for="comment">Add Comment<b class="required"> *</b></label>
			<textarea id="comment" name="comment" cols="45" rows="8" required="required">