Calcolatore Punti di Discontinuità

Analizza le discontinuità di una funzione matematica inserendo i parametri richiesti per identificare punti di salto, eliminabili e asintoti verticali.

Tipo di Funzione

Numeratore P(x) Denominatore Q(x)

Definizione a Tratti (formato: x<1:f(x);1≤x≤3:g(x);x>3:h(x))

<label for="wpc-trig-function" class="wpc-label">Funzione Trigonometrica</label>
                <input type="text" id="wpc-trig-function" class="wpc-input" placeholder="Es: sin(x)/x">

<label for="wpc-trig-domain" class="wpc-label" style="margin-top: 1rem;">Dominio (intervallo)</label>
                <input type="text" id="wpc-trig-domain" class="wpc-input" placeholder="Es: [-π, π]">
            </div>

<div id="wpc-exp-group" class="wpc-form-group" style="display: none;">
                <label for="wpc-exp-function" class="wpc-label">Funzione Esponenziale/Logaritmica</label>
                <input type="text" id="wpc-exp-function" class="wpc-input" placeholder="Es: ln(x-2)/(x-3)">

<label for="wpc-exp-domain" class="wpc-label" style="margin-top: 1rem;">Dominio (intervallo)</label>
                <input type="text" id="wpc-exp-domain" class="wpc-input" placeholder="Es: (2, ∞)">
            </div>

<div class="wpc-form-group">
                <label for="wpc-precision" class="wpc-label">Precisione Decimale</label>
                <select id="wpc-precision" class="wpc-select">
                    <option value="2">2 decimali</option>
                    <option value="4">4 decimali</option>
                    <option value="6">6 decimali</option>
                    <option value="8">8 decimali</option>
                </select>
            </div>

<button type="submit" class="wpc-button">
                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" viewBox="0 0 16 16" style="margin-right: 0.5rem;">
                    <path d="M14.854 4.854a.5.5 0 0 0-.708-.708L10.5 7.793 9.354 6.646a.5.5 0 1 0-.708.708l1.5 1.5a.5.5 0 0 0 .708 0l5-5z"/>
                    <path d="M4.5 6.5A.5.5 0 0 1 5 7v6a.5.5 0 0 1-1 0V7a.5.5 0 0 1 .5-.5zm-2.5 0A.5.5 0 0 1 3 7v6a.5.5 0 0 1-1 0V7a.5.5 0 0 1 .5-.5zm11 0a.5.5 0 0 1 1 0v6a.5.5 0 0 1-1 0V6.5z"/>
                </svg>
                Calcola Discontinuità
            </button>
        </form>

<div id="wpc-results" class="wpc-results">
            <h3 class="wpc-result-title">Risultati Analisi Discontinuità</h3>
            <div id="wpc-result-content"></div>
            <div class="wpc-chart-container">
                <canvas id="wpc-chart"></canvas>
            </div>
        </div>
    </div>

<article class="wpc-content">
        <h2>Guida Completa: Come Calcolare i Punti di Discontinuità di una Funzione</h2>

<p>La determinazione dei punti di discontinuità rappresenta un aspetto fondamentale nell’analisi matematica, con applicazioni che spaziano dalla fisica teorica all’ingegneria pratica. Questa guida approfondita vi condurrà attraverso i concetti teorici, le metodologie pratiche e gli esempi concreti per identificare e classificare correttamente i diversi tipi di discontinuità.</p>

<h3>1. Fondamenti Teorici delle Discontinuità</h3>

<p>Una funzione <em>f(x)</em> presenta un punto di discontinuità in <em>x = c</em> quando non soddisfa una o più delle seguenti condizioni:</p>

<ol>
            <li><strong>Esistenza di f(c)</strong>: La funzione deve essere definita in x = c</li>
            <li><strong>Esistenza del limite</strong>: deve esistere <span style="font-style: italic;">lim<sub>x→c</sub> f(x)</span></li>
            <li><strong>Uguaglianza</strong>: <span style="font-style: italic;">lim<sub>x→c</sub> f(x) = f(c)</span></li>
        </ol>

<p>Quando una o più di queste condizioni non sono soddisfatte, si verificano diversi tipi di discontinuità:</p>

<div class="wpc-grid">
            <div>
                <h4>Discontinuità Eliminabile</h4>
                <p>Si verifica quando il limite esiste ma è diverso dal valore della funzione (o la funzione non è definita). Può essere “riparata” ridefinendo la funzione nel punto.</p>
                <p><strong>Esempio</strong>: f(x) = (x²-1)/(x-1) in x=1</p>
            </div>

<div>
                <h4>Discontinuità di Prima Specie (Salto)</h4>
                <p>I limiti destro e sinistro esistono ma sono diversi. L’ampiezza del salto è data da |lim<sub>x→c⁺</sub> – lim<sub>x→c⁻</sub>|.</p>
                <p><strong>Esempio</strong>: f(x) = {x+1 per x≤0; x+2 per x>0} in x=0</p>
            </div>

<div>
                <h4>Discontinuità di Seconda Specie</h4>
                <p>Almeno uno dei limiti (destro o sinistro) non esiste o è infinito. Comune nelle funzioni con asintoti verticali.</p>
                <p><strong>Esempio</strong>: f(x) = 1/x in x=0</p>
            </div>
        </div>

<h3>2. Metodologia per l’Individuazione dei Punti di Discontinuità</h3>

<p>Il processo sistematico per identificare i punti di discontinuità comprende i seguenti passaggi:</p>

<ol>
            <li><strong>Determinazione del Dominio</strong>: Identificare tutti i punti dove la funzione non è definita (es: denominatori nulli, radici di indice pari con argomento negativo)</li>
            <li><strong>Analisi dei Limiti</strong>: Calcolare i limiti destro e sinistro in ogni punto critico</li>
            <li><strong>Confronto con il Valore della Funzione</strong>: Verificare se il limite coincide con f(c) quando esiste</li>
            <li><strong>Classificazione</strong>: Assegnare il tipo di discontinuità in base ai risultati precedenti</li>
        </ol>

<h4>Strumenti Analitici Utili</h4>
        <ul>
            <li><strong>Teorema di De L’Hôpital</strong>: Per forme indeterminate 0/0 o ∞/∞</li>
            <li><strong>Scomposizione in Fattori</strong>: Per semplificare funzioni razionali</li>
            <li><strong>Limiti Notevoli</strong>: sin(x)/x, (1+x)^(1/x), etc.</li>
            <li><strong>Analisi Grafica</strong>: Supporto visivo per identificare asintoti</li>
        </ul>

<h3>3. Casi Pratici e Esempi Risolti</h3>

<div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Tipo di Funzione</th>
                        <th>Esempio</th>
                        <th>Punto di Discontinuità</th>
                        <th>Tipo</th>
                        <th>Limite Destro</th>
                        <th>Limite Sinistro</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Razionale</td>
                        <td>f(x) = (x²-4)/(x-2)</td>
                        <td>x = 2</td>
                        <td>Eliminabile</td>
                        <td>4</td>
                        <td>4</td>
                    </tr>
                    <tr>
                        <td>A Tratti</td>
                        <td>f(x) = {x² per x≤1; 2x per x>1}</td>
                        <td>x = 1</td>
                        <td>Salto</td>
                        <td>2</td>
                        <td>1</td>
                    </tr>
                    <tr>
                        <td>Trigonometrica</td>
                        <td>f(x) = tan(x)</td>
                        <td>x = π/2 + kπ</td>
                        <td>Seconda Specie</td>
                        <td>+∞</td>
                        <td>-∞</td>
                    </tr>
                    <tr>
                        <td>Esponenziale</td>
                        <td>f(x) = e^(1/x)</td>
                        <td>x = 0</td>
                        <td>Seconda Specie</td>
                        <td>+∞</td>
                        <td>0</td>
                    </tr>
                </tbody>
            </table>
        </div>

<p>L’esempio della funzione razionale <em>f(x) = (x²-4)/(x-2)</em> merita particolare attenzione. Nonostante la funzione non sia definita in x=2 (denominatore nullo), possiamo semplificare l’espressione:</p>

<p>Il limite per x→2 è quindi 4, mentre f(2) non esiste. Questa è una classica discontinuità eliminabile che può essere “riparata” ridefinendo f(2) = 4.</p>

<h3>4. Applicazioni Pratiche delle Discontinuità</h3>

<p>La comprensione delle discontinuità ha importanti applicazioni in diversi campi:</p>

<div class="wpc-grid">
            <div>
                <h4>Fisica</h4>
                <ul>
                    <li>Modellizzazione di fenomeni con cambiamenti improvvisi (es: urti)</li>
                    <li>Analisi di sistemi con isteresi (magnetismo)</li>
                    <li>Studio delle transizioni di fase</li>
                </ul>
            </div>
            <div>
                <h4>Ingegneria</h4>
                <ul>
                    <li>Progettazione di controlli digitali (funzioni a tratti)</li>
                    <li>Analisi di segnalie elettrici con salti di tensione</li>
                    <li>Ottimizzazione di algoritmi con funzioni discontinue</li>
                </ul>
            </div>
            <div>
                <h4>Economia</h4>
                <ul>
                    <li>Modelli con costi fissi e variabili</li>
                    <li>Funzioni di utilità con preferenze non continue</li>
                    <li>Analisi di mercati con prezzi soglia</li>
                </ul>
            </div>
        </div>

<h3>5. Errori Comuni e Come Evitarli</h3>

<p>Nell’analisi delle discontinuità, alcuni errori ricorrenti possono portare a conclusioni errate:</p>

<ol>
            <li><strong>Confondere asintoti verticali con discontinuità di seconda specie</strong>: Non tutti gli asintoti verticali indicano discontinuità di seconda specie (es: x=0 per 1/x² ha limite +∞ da entrambi i lati)</li>
            <li><strong>Trascurare la definizione della funzione</strong>: Una funzione può essere discontinua in un punto anche se il limite esiste (discontinuità eliminabile)</li>
            <li><strong>Errori nei calcoli dei limiti</strong>: Particolare attenzione alle forme indeterminate e all’algebra dei limiti</li>
            <li><strong>Dimenticare di verificare entrambi i limiti</strong>: Per le discontinuità di salto è essenziale calcolare sia il limite destro che sinistro</li>
        </ol>

<div class="wpc-table">
            <table>
                <caption>Confronto tra Tipi di Discontinuità</caption>
                <thead>
                    <tr>
                        <th>Caratteristica</th>
                        <th>Eliminabile</th>
                        <th>Salto</th>
                        <th>Seconda Specie</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Limite bilaterale esiste</td>
                        <td>Sì</td>
                        <td>No</td>
                        <td>No</td>
                    </tr>
                    <tr>
                        <td>Limiti destro/sinistro esistono</td>
                        <td>Sì (uguali)</td>
                        <td>Sì (diversi)</td>
                        <td>No (almeno uno)</td>
                    </tr>
                    <tr>
                        <td>Funzione definita nel punto</td>
                        <td>No (o valore diverso)</td>
                        <td>Possibile</td>
                        <td>Possibile</td>
                    </tr>
                    <tr>
                        <td>Asintoto verticale</td>
                        <td>No</td>
                        <td>No</td>
                        <td>Possibile</td>
                    </tr>
                    <tr>
                        <td>Esempio tipico</td>
                        <td>(x²-1)/(x-1) in x=1</td>
                        <td>sign(x) in x=0</td>
                        <td>1/x in x=0</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>6. Approfondimenti e Risorse Accademiche</h3>

<p>Per un approfondimento rigoroso dell’argomento, si consigliano le seguenti risorse autorevoli:</p>

<ul>
            <li><a href="https://math.mit.edu/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">Dipartimento di Matematica del MIT</a> – Corsi avanzati di analisi matematica con sezioni dedicate alle discontinuità</li>
            <li><a href="https://math.berkeley.edu/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">Università della California, Berkeley – Matematica</a> – Materiali didattici su limiti e continuità</li>
            <li><a href="https://www.nist.gov/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST (National Institute of Standards and Technology)</a> – Applicazioni delle discontinuità in metrologia e standardizzazione</li>
        </ul>

<p>Per uno studio sistematico, il testo “<em>Principles of Mathematical Analysis</em>” di Walter Rudin (McGraw-Hill) rappresenta un riferimento fondamentale, con particolare attenzione ai capitoli 4 e 5 dedicati alla continuità e alle proprietà delle funzioni continue.</p>

<h3>7. Esercizi Pratici per la Verifica delle Competenze</h3>

<p>Per consolidare la comprensione, si propongono i seguenti esercizi:</p>

<ol>
            <li>Determinare i punti di discontinuità di <em>f(x) = (x³ – 8)/(x² – 4)</em> e classificarli</li>
            <li>Analizzare la funzione <em>f(x) = {e^x per x≤0; ln(x+1) per x>0}</em> in x=0</li>
            <li>Trovare e classificare le discontinuità di <em>f(x) = tan(1/x)</em> nell’intervallo (0,1)</li>
            <li>Studiare la continuità di <em>f(x) = |x – [x]|</em> (dove [x] è la parte intera) in tutti i punti reali</li>
            <li>Determinare se la discontinuità in x=0 di <em>f(x) = sin(1/x)</em> è eliminabile, di salto o di seconda specie</li>
        </ol>

<p>La soluzione di questi esercizi richiede l’applicazione integrata di tutti i concetti presentati in questa guida, dalla determinazione del dominio all’analisi dei limiti, fino alla classificazione finale delle discontinuità.</p>

<h3>8. Considerazioni Computazionali</h3>

<p>Nell’era digitale, l’analisi delle discontinuità può essere supportata da strumenti computazionali:</p>

<ul>
            <li><strong>Software di calcolo simbolico</strong> (Mathematica, Maple): Per manipolazioni algebriche complesse</li>
            <li><strong>Linguaggi di programmazione</strong> (Python con SymPy): Per implementazioni algoritmiche</li>
            <li><strong>Calcolatrici grafiche</strong> (Desmos, GeoGebra): Per visualizzazione interattiva</li>
            <li><strong>Librerie numeriche</strong> (NumPy, SciPy): Per approssimazioni numeriche dei limiti</li>
        </ul>

<p>Il calcolatore presentato in questa pagina implementa un algoritmo che:</p>
        <ol>
            <li>Parsifica l’espressione matematica inserita</li>
            <li>Identifica i punti critici (denominatori nulli, radici, etc.)</li>
            <li>Calcola i limiti destro e sinistro in ogni punto critico</li>
            <li>Classifica la discontinuità in base ai risultati</li>
            <li>Genera una rappresentazione grafica della funzione nell’intorno dei punti di discontinuità</li>
        </ol>

<p>L’implementazione utilizza tecniche di analisi simbolica per manipolare le espressioni matematiche e calcolo numerico per approssimare i limiti in punti complessi.</p>

<h3>9. Prospettive Avanzate: Discontinuità in Spazi Metrici</h3>

<p>Il concetto di discontinuità si estende oltre le funzioni reali di variabile reale. In spazi metrici generici, una funzione <em>f: (X,d_X) → (Y,d_Y)</em> è continua in <em>x₀ ∈ X</em> se:</p>

<p>Questa definizione astratta permette di studiare discontinuità in:</p>
        <ul>
            <li>Spazi di funzioni (es: spazi Lᵖ)</li>
            <li>Varietà differenziabili</li>
            <li>Spazi di Banach e Hilbert</li>
            <li>Topologie non metrizzabili</li>
        </ul>

<p>Le discontinuità in questi contesti avanzati trovano applicazione in:</p>
        <ul>
            <li><strong>Fisica quantistica</strong>: Operatori non continui in spazi di Hilbert</li>
            <li><strong>Teoria del controllo</strong>: Funzioni obiettivo discontinue</li>
            <li><strong>Analisi funzionale</strong>: Operatori lineari non continui</li>
            <li><strong>Topologia algebrica</strong>: Applicazioni tra spazi topologici</li>
        </ul>

<h3>10. Conclusione e Sintesi Operativa</h3>

<p>L’analisi delle discontinuità rappresenta una competenza fondamentale per:</p>
        <ul>
            <li>Comprendere profondamente il comportamento delle funzioni</li>
            <li>Modellizzare fenomeni reali con cambiamenti improvvisi</li>
            <li>Sviluppare algoritmi robusti in informatica e ingegneria</li>
            <li>Affrontare problemi avanzati in analisi matematica</li>
        </ul>

<p><strong>Procedura riassuntiva per l’analisi:</strong></p>
        <ol>
            <li>Identificare il dominio della funzione</li>
            <li>Localizzare i punti critici (non definiti o “sospetti”)</li>
            <li>Calcolare i limiti destro e sinistro in ogni punto critico</li>
            <li>Confrontare con il valore della funzione (se esiste)</li>
            <li>Classificare la discontinuità in base ai risultati</li>
            <li>Rappresentare graficamente per conferma visiva</li>
        </ol>

<p>Ricordate che una comprensione profonda delle discontinuità non solo vi permetterà di risolvere esercizi accademici, ma vi fornirà strumenti potenti per analizzare fenomeni complessi in scienza e ingegneria.</p>
    </article>
</section>

functionType.addEventListener('change', function() {
        rationalGroup.style.display = 'none';
        piecewiseGroup.style.display = 'none';
        trigGroup.style.display = 'none';
        expGroup.style.display = 'none';

switch(this.value) {
            case 'rational':
                rationalGroup.style.display = 'block';
                break;
            case 'piecewise':
                piecewiseGroup.style.display = 'block';
                break;
            case 'trigonometric':
                trigGroup.style.display = 'block';
                break;
            case 'exponential':
                expGroup.style.display = 'block';
                break;
        }
    });

// Gestione submit del form
    const form = document.getElementById('wpc-discontinuity-form');
    const resultsDiv = document.getElementById('wpc-results');
    const resultContent = document.getElementById('wpc-result-content');

form.addEventListener('submit', function(e) {
        e.preventDefault();
        resultsDiv.style.display = 'none';

// Leggi i valori dal form
        const functionType = document.getElementById('wpc-function-type').value;
        const precision = parseInt(document.getElementById('wpc-precision').value);

let functionDef, domain;
        switch(functionType) {
            case 'rational':
                functionDef = {
                    type: 'rational',
                    numerator: document.getElementById('wpc-numerator').value,
                    denominator: document.getElementById('wpc-denominator').value
                };
                break;
            case 'piecewise':
                functionDef = {
                    type: 'piecewise',
                    definition: document.getElementById('wpc-piecewise-def').value
                };
                break;
            case 'trigonometric':
                functionDef = {
                    type: 'trigonometric',
                    expression: document.getElementById('wpc-trig-function').value,
                    domain: document.getElementById('wpc-trig-domain').value
                };
                break;
            case 'exponential':
                functionDef = {
                    type: 'exponential',
                    expression: document.getElementById('wpc-exp-function').value,
                    domain: document.getElementById('wpc-exp-domain').value
                };
                break;
        }

// Elabora la funzione e trova le discontinuità
        const analysisResult = analyzeDiscontinuities(functionDef, precision);

// Mostra i risultati
        displayResults(analysisResult, precision);

// Disegna il grafico
        if (analysisResult.points.length > 0) {
            plotFunction(functionDef, analysisResult.points, precision);
        }
    });

function analyzeDiscontinuities(functionDef, precision) {
        try {
            // Inizializza math.js
            const math = window.math;

let points = [];
            let functionExpression;
            let variable = 'x';

// Parsing della funzione in base al tipo
            switch(functionDef.type) {
                case 'rational':
                    try {
                        const numerator = math.parse(functionDef.numerator);
                        const denominator = math.parse(functionDef.denominator);

// Trova i punti dove il denominatore è zero (potenziali discontinuità)
                        // Per semplicità, assumiamo che il denominatore sia un polinomio
                        // e cerchiamo le radici reali
                        const denomStr = denominator.toString();
                        const roots = findPolynomialRoots(denomStr);

// Per ogni radice, analizza la discontinuità
                        points = roots.map(root => {
                            const x = parseFloat(root);

// Calcola limite destro e sinistro
                            const rightLimit = calculateLimit(functionDef.numerator, functionDef.denominator, x, 'right', precision);
                            const leftLimit = calculateLimit(functionDef.numerator, functionDef.denominator, x, 'left', precision);

// Determina il tipo di discontinuità
                            let type;
                            if (rightLimit === leftLimit && !isNaN(rightLimit)) {
                                type = 'eliminabile';
                            } else if (!isNaN(rightLimit) && !isNaN(leftLimit)) {
                                type = 'salto';
                            } else {
                                type = 'seconda specie';
                            }

return {
                                x: x,
                                type: type,
                                leftLimit: leftLimit,
                                rightLimit: rightLimit
                            };
                        });

functionExpression = `${functionDef.numerator}/${functionDef.denominator}`;
                    } catch (e) {
                        return { error: "Errore nel parsing della funzione razionale: " + e.message };
                    }
                    break;

case 'piecewise':
                    try {
                        // Parsing della funzione a tratti (formato semplificato)
                        const pieces = functionDef.definition.split(';');
                        let piecewiseExpr = {};

pieces.forEach(piece => {
                            const [condition, expr] = piece.split(':');
                            piecewiseExpr[condition.trim()] = expr.trim();
                        });

// Trova i punti di cambio tra i pezzi (potenziali discontinuità)
                        const changePoints = Object.keys(piecewiseExpr)
                            .map(cond => {
                                // Estrai i valori numerici dalle condizioni (semplificato)
                                const match = cond.match(/([<≤]=?)\s*([\-0-9.]+)/);
                                if (match) return parseFloat(match[2]);
                                return null;
                            })
                            .filter((v, i, a) => v !== null && a.indexOf(v) === i);

// Analizza ogni punto di cambio
                        points = changePoints.map(x => {
                            // Trova quali pezzi si applicano a sinistra e destra di x
                            let leftExpr, rightExpr;

for (const [cond, expr] of Object.entries(piecewiseExpr)) {
                                if (cond.includes('≤') || cond.includes('<=')) {
                                    const val = parseFloat(cond.split(/[≤<=]/)[1]);
                                    if (val === x) {
                                        rightExpr = expr;
                                    }
                                    if (val < x && (!leftExpr || parseFloat(cond.split(/[≤<=]/)[1]) > parseFloat(leftExprCond.split(/[≤<=]/)[1]))) {
                                        leftExpr = expr;
                                        leftExprCond = cond;
                                    }
                                } else if (cond.includes('<')) {
                                    const val = parseFloat(cond.split('<')[1]);
                                    if (val === x) {
                                        rightExpr = expr;
                                    }
                                    if (val < x && (!leftExpr || parseFloat(cond.split('<')[1]) > parseFloat(leftExprCond.split('<')[1]))) {
                                        leftExpr = expr;
                                        leftExprCond = cond;
                                    }
                                } else if (cond.includes('>=') || cond.includes('≥')) {
                                    const val = parseFloat(cond.split(/[≥>=]/)[1]);
                                    if (val === x) {
                                        leftExpr = expr;
                                    }
                                    if (val > x && (!rightExpr || parseFloat(cond.split(/[≥>=]/)[1]) < parseFloat(rightExprCond.split(/[≥>=]/)[1]))) {
                                        rightExpr = expr;
                                        rightExprCond = cond;
                                    }
                                } else if (cond.includes('>')) {
                                    const val = parseFloat(cond.split('>')[1]);
                                    if (val === x) {
                                        leftExpr = expr;
                                    }
                                    if (val > x && (!rightExpr || parseFloat(cond.split('>')[1]) < parseFloat(rightExprCond.split('>')[1]))) {
                                        rightExpr = expr;
                                        rightExprCond = cond;
                                    }
                                }
                            }

// Calcola i limiti (semplificato - in realtà dovremmo valutare le espressioni)
                            const leftLimit = leftExpr ? evaluateExpression(leftExpr, x - 0.001) : NaN;
                            const rightLimit = rightExpr ? evaluateExpression(rightExpr, x + 0.001) : NaN;

let type;
                            if (isNaN(leftLimit) || isNaN(rightLimit)) {
                                type = 'seconda specie';
                            } else if (leftLimit === rightLimit) {
                                type = 'eliminabile';
                            } else {
                                type = 'salto';
                            }

// Costruisci l'espressione piecewise per il grafico
                        functionExpression = functionDef.definition;
                    } catch (e) {
                        return { error: "Errore nel parsing della funzione a tratti: " + e.message };
                    }
                    break;

case 'trigonometric':
                case 'exponential':
                    try {
                        // Per funzioni trigonometriche/esponenziali, cerchiamo punti dove la funzione non è definita
                        // o dove ci sono asintoti (semplificato)
                        const expr = functionDef.expression;

// Trova potenziali punti problematici (es: denominatori nulli, log(≤0), etc.)
                        // Questa è una implementazione molto semplificata
                        const problematicPoints = [];

// Cerca divisioni (potenziali denominatori nulli)
                        if (expr.includes('/')) {
                            const denominator = expr.split('/')[1];
                            const denomRoots = findPolynomialRoots(denominator);
                            problematicPoints.push(...denomRoots.map(r => parseFloat(r)));
                        }

// Cerca logaritmi (argomento ≤ 0)
                        if (expr.includes('log') || expr.includes('ln')) {
                            const logMatch = expr.match(/log$([^)]+)$/);
                            if (logMatch) {
                                const arg = logMatch[1];
                                // Trova dove arg ≤ 0 (semplificato)
                                // Qui dovremmo risolvere arg ≤ 0, ma per semplicità assumiamo x=0
                                problematicPoints.push(0);
                            }
                        }

// Analizza ogni punto problematico
                        points = problematicPoints.map(x => {
                            const rightLimit = evaluateExpression(expr, x + 0.001);
                            const leftLimit = evaluateExpression(expr, x - 0.001);

let type;
                            if (isNaN(leftLimit) || isNaN(rightLimit) ||
                                Math.abs(leftLimit) === Infinity || Math.abs(rightLimit) === Infinity) {
                                type = 'seconda specie';
                            } else if (leftLimit !== rightLimit) {
                                type = 'salto';
                            } else {
                                type = 'eliminabile';
                            }

functionExpression = expr;
                    } catch (e) {
                        return { error: "Errore nel parsing della funzione: " + e.message };
                    }
                    break;
            }

return {
                functionExpression: functionExpression,
                points: points,
                variable: variable
            };

} catch (e) {
            return { error: "Errore nell'analisi: " + e.message };
        }
    }

function findPolynomialRoots(polyStr) {
        // Implementazione semplificata per trovare radici di polinomi
        // In un'applicazione reale, useremmo una libreria come math.js
        try {
            // Prova a risolvere con math.js
            const expr = math.parse(polyStr);
            const code = expr.compile();
            let roots = [];

// Cerca radici nell'intervallo [-10, 10] con passo 0.1 (molto grezzo!)
            for (let x = -10; x <= 10; x += 0.1) {
                try {
                    const val = code.evaluate({x: x});
                    if (Math.abs(val) < 0.01) {
                        roots.push(x.toFixed(2));
                    }
                } catch (e) {
                    // Ignora errori (es: radice quadrata di negativo)
                }
            }

// Rimuovi duplicati
            return [...new Set(roots)];
        } catch (e) {
            console.error("Errore nel trovare le radici:", e);
            return [];
        }
    }

function calculateLimit(numeratorStr, denominatorStr, x, side, precision) {
        // Calcola il limite destro o sinistro in x per una funzione razionale
        const math = window.math;
        const h = 0.001; // Passo per l'approssimazione

try {
            const numerator = math.parse(numeratorStr);
            const denominator = math.parse(denominatorStr);

const xVal = side === 'right' ? x + h : x - h;
            const numVal = numerator.evaluate({x: xVal});
            const denomVal = denominator.evaluate({x: xVal});

if (denomVal === 0) {
                // Prova a semplificare la frazione
                try {
                    const simplified = math.simplify(`${numeratorStr}/${denominatorStr}`);
                    if (simplified) {
                        const simplifiedExpr = math.parse(simplified.toString());
                        return parseFloat(simplifiedExpr.evaluate({x: x}).toFixed(precision));
                    }
                } catch (e) {
                    // Se la semplificazione fallisce, restituisci infinito
                    return side === 'right' ? Infinity : -Infinity;
                }
            }

return parseFloat((numVal / denomVal).toFixed(precision));
        } catch (e) {
            console.error("Errore nel calcolo del limite:", e);
            return NaN;
        }
    }

function evaluateExpression(expr, xVal) {
        // Valuta un'espressione in un punto (semplificato)
        try {
            const math = window.math;
            const parsed = math.parse(expr);
            const result = parsed.evaluate({x: xVal});

if (typeof result === 'number') {
                return result;
            } else if (result instanceof math.type.Complex) {
                return NaN; // Ignora numeri complessi per semplicità
            } else {
                return NaN;
            }
        } catch (e) {
            return NaN;
        }
    }

function displayResults(analysisResult, precision) {
        if (analysisResult.error) {
            resultContent.innerHTML = `<div class="wpc-result-item">
                <div class="wpc-result-label">Errore:</div>
                <div class="wpc-result-value">${analysisResult.error}</div>
            </div>`;
            resultsDiv.style.display = 'block';
            return;
        }

if (analysisResult.points.length === 0) {
            resultContent.innerHTML = `<div class="wpc-result-item">
                <div class="wpc-result-value">Nessuna discontinuità trovata nella funzione analizzata.</div>
            </div>`;
            resultsDiv.style.display = 'block';
            return;
        }

let html = `
            <div class="wpc-result-item">
                <div class="wpc-result-label">Funzione analizzata:</div>
                <div class="wpc-result-value">${analysisResult.functionExpression}</div>
            </div>
            <div class="wpc-result-item">
                <div class="wpc-result-label">Numero di punti di discontinuità trovati:</div>
                <div class="wpc-result-value">${analysisResult.points.length}</div>
            </div>
        `;

analysisResult.points.forEach((point, index) => {
            html += `
            <div class="wpc-result-item">
                <div class="wpc-result-label">Punto ${index + 1} (x = ${point.x.toFixed(precision)}):</div>
                <div class="wpc-result-value">
                    <strong>Tipo:</strong> ${translateDiscontinuityType(point.type)}<br>
                    <strong>Limite sinistro:</strong> ${formatLimit(point.leftLimit, precision)}<br>
                    <strong>Limite destro:</strong> ${formatLimit(point.rightLimit, precision)}
                </div>
            </div>
            `;
        });

resultContent.innerHTML = html;
        resultsDiv.style.display = 'block';
    }

function translateDiscontinuityType(type) {
        const translations = {
            'eliminabile': 'Discontinuità eliminabile',
            'salto': 'Discontinuità di prima specie (salto)',
            'seconda specie': 'Discontinuità di seconda specie'
        };
        return translations[type] || type;
    }

function formatLimit(value, precision) {
        if (isNaN(value)) return "Non definito";
        if (value === Infinity) return "+∞";
        if (value === -Infinity) return "-∞";
        return value.toFixed(precision);
    }

function plotFunction(functionDef, points, precision) {
        const ctx = document.getElementById('wpc-chart').getContext('2d');
        const math = window.math;

// Distruggi il grafico precedente se esiste
        if (window.discontinuityChart) {
            window.discontinuityChart.destroy();
        }

// Genera dati per il grafico
        const xValues = [];
        const yValues = [];

// Determina il dominio in base ai punti di discontinuità
        let minX = Math.min(...points.map(p => p.x)) - 2;
        let maxX = Math.max(...points.map(p => p.x)) + 2;

// Se non ci sono punti di discontinuità, usa un dominio standard
        if (points.length === 0) {
            minX = -5;
            maxX = 5;
        }

const step = (maxX - minX) / 200;

try {
            let functionExpr;
            switch(functionDef.type) {
                case 'rational':
                    functionExpr = math.parse(`${functionDef.numerator}/${functionDef.denominator}`);
                    break;
                case 'piecewise':
                    // Per le funzioni a tratti, usiamo solo il primo pezzo per semplicità
                    const firstPiece = functionDef.definition.split(';')[0].split(':')[1];
                    functionExpr = math.parse(firstPiece);
                    break;
                case 'trigonometric':
                case 'exponential':
                    functionExpr = math.parse(functionDef.expression);
                    break;
            }

for (let x = minX; x <= maxX; x += step) {
                try {
                    const y = functionExpr.evaluate({x: x});
                    if (typeof y === 'number' && !isNaN(y) && Math.abs(y) < 1000) { // Evita valori estremi
                        xValues.push(x);
                        yValues.push(y);
                    }
                } catch (e) {
                    // Ignora errori (es: divisione per zero)
                }
            }

// Crea il grafico
            window.discontinuityChart = new Chart(ctx, {
                type: 'line',
                data: {
                    labels: xValues,
                    datasets: [{
                        label: 'f(x)',
                        data: yValues,
                        borderColor: '#2563eb',
                        backgroundColor: 'rgba(37, 99, 235, 0.1)',
                        borderWidth: 2,
                        tension: 0.1,
                        pointRadius: 0,
                        fill: false
                    }]
                },
                options: {
                    responsive: true,
                    maintainAspectRatio: false,
                    scales: {
                        x: {
                            title: {
                                display: true,
                                text: 'x'
                            },
                            grid: {
                                color: '#e2e8f0'
                            }
                        },
                        y: {
                            title: {
                                display: true,
                                text: 'f(x)'
                            },
                            grid: {
                                color: '#e2e8f0'
                            }
                        }
                    },
                    plugins: {
                        title: {
                            display: true,
                            text: 'Grafico della funzione con punti di discontinuità evidenziati',
                            font: {
                                size: 14
                            }
                        },
                        legend: {
                            position: 'top',
                        },
                        tooltip: {
                            callbacks: {
                                label: function(context) {
                                    return `f(${context.parsed.x.toFixed(2)}) = ${context.parsed.y.toFixed(precision)}`;
                                }
                            }
                        }
                    },
                    elements: {
                        line: {
                            borderJoinStyle: 'round'
                        }
                    }
                }
            });

// Aggiungi annotazioni per i punti di discontinuità
            const annotations = points.map(point => ({
                type: 'point',
                xValue: point.x,
                yValue: point.type === 'eliminabile' ?
                    (point.leftLimit + point.rightLimit) / 2 :
                    Math.max(Math.abs(point.leftLimit || 0), Math.abs(point.rightLimit || 0)),
                backgroundColor: point.type === 'eliminabile' ? '#10b981' :
                                 point.type === 'salto' ? '#f59e0b' : '#ef4444',
                borderColor: '#ffffff',
                borderWidth: 2,
                radius: 8,
                label: {
                    content: `x=${point.x.toFixed(precision)}`,
                    enabled: true,
                    position: 'top'
                }
            }));

// Aggiungi le annotazioni (richiede Chart.js Annotation Plugin)
            // In una implementazione completa, caricheremmo il plugin
            // Per ora simuliamo con punti sul grafico
            annotations.forEach(ann => {
                window.discontinuityChart.data.datasets.push({
                    label: ann.label.content,
                    data: [{x: ann.xValue, y: ann.yValue}],
                    backgroundColor: ann.backgroundColor,
                    borderColor: ann.borderColor,
                    borderWidth: ann.borderWidth,
                    pointRadius: ann.radius,
                    pointStyle: 'circle',
                    showLine: false
                });
            });

window.discontinuityChart.update();

} catch (e) {
            console.error("Errore nel plotting:", e);
        }
    }
});
</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-i-punti-di-discontinuita/#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">