Calcolatore Derivata di Funzione Non Continua

Inserisci i parametri della tua funzione non continua per calcolare la derivata e visualizzare il grafico

Tipo di funzione

Punto di analisi (x)

Definizione della funzione (usare x come variabile)

Separare i diversi tratti con una riga vuota. Usare ≤, ≥, <, > per definire gli intervalli.
                </small>
            </div>

<div class="wpc-form-group">
                <label class="wpc-label">Metodo di calcolo</label>
                <div class="wpc-radio-group">
                    <label class="wpc-radio-label">
                        <input type="radio" name="wpc-method" value="limit" checked>
                        <span>Limite della definizione</span>
                    </label>
                    <label class="wpc-radio-label">
                        <input type="radio" name="wpc-method" value="numerical">
                        <span>Approssimazione numerica</span>
                    </label>
                </div>
            </div>

<div class="wpc-form-group">
                <label for="wpc-precision" class="wpc-label">Precisione (per metodo numerico)</label>
                <select id="wpc-precision" class="wpc-select">
                    <option value="0.01">Bassa (0.01)</option>
                    <option value="0.001" selected>Media (0.001)</option>
                    <option value="0.0001">Alta (0.0001)</option>
                    <option value="0.00001">Molto alta (0.00001)</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 10.01 7.302a.5.5 0 0 0-.793-.015l-3.5 3.5a.5.5 0 0 0 .708.708L7.302 10.01a.5.5 0 0 0 .015-.793L4.854 6.146a.5.5 0 0 0-.708.708l3.5 3.5a.5.5 0 0 0 .708 0l3.5-3.5a.5.5 0 0 0 0-.708l-3.5-3.5a.5.5 0 0 0-.708 0z"/>
                </svg>
                Calcola Derivata
            </button>
        </form>

<div id="wpc-results" class="wpc-results">
            <h3 class="wpc-result-title">Risultati del calcolo</h3>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Punto analizzato:</span>
                <span class="wpc-result-value" id="wpc-result-point"></span>
            </div>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Derivata sinistra:</span>
                <span class="wpc-result-value" id="wpc-result-left"></span>
            </div>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Derivata destra:</span>
                <span class="wpc-result-value" id="wpc-result-right"></span>
            </div>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Derivata nel punto:</span>
                <span class="wpc-result-value" id="wpc-result-derivative"></span>
            </div>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Continuità:</span>
                <span class="wpc-result-value" id="wpc-result-continuity"></span>
            </div>
            <div class="wpc-result-item">
                <span class="wpc-result-label">Derivabilità:</span>
                <span class="wpc-result-value" id="wpc-result-differentiability"></span>
            </div>

<article class="wpc-content">
        <h2>Guida Completa: Come Calcolare la Derivata di una Funzione Non Continua</h2>

<p>Il calcolo della derivata per funzioni non continue rappresenta uno dei concetti più importanti e spesso ostici dell’analisi matematica. Mentre per le funzioni continue il processo di derivazione segue regole ben definite, le funzioni non continue richiedono un’approccio più attento, specialmente nei punti di discontinuità.</p>

<h3>Cosa sono le funzioni non continue?</h3>
        <p>Una funzione si dice <strong>non continua</strong> in un punto quando non soddisfa una o più delle seguenti condizioni:</p>
        <ol>
            <li><strong>Esistenza del limite:</strong> Il limite della funzione per x che tende al punto deve esistere</li>
            <li><strong>Finitezza del limite:</strong> Il limite deve essere un numero finito</li>
            <li><strong>Uguaglianza:</strong> Il limite deve essere uguale al valore della funzione nel punto</li>
        </ol>

<p>Le discontinuità si classificano in:</p>
        <ul>
            <li><strong>Di prima specie:</strong> Esistono finiti i limiti destro e sinistro ma sono diversi</li>
            <li><strong>Di seconda specie:</strong> Almeno uno dei limiti (destro o sinistro) non esiste o è infinito</li>
            <li><strong>Di terza specie (eliminabile):</strong> Il limite esiste ma non coincide con il valore della funzione</li>
        </ul>

<h3>Derivabilità e continuità: relazione fondamentale</h3>
        <p>Un teorema fondamentale dell’analisi matematica afferma che:</p>
        <blockquote style="border-left: 4px solid #2563eb; padding-left: 1rem; margin: 1.5rem 0; color: #1e293b; font-style: italic;">
            “Se una funzione è derivabile in un punto, allora è anche continua in quel punto.”
        </blockquote>
        <p>Il contrario non è necessariamente vero: una funzione può essere continua in un punto senza essere derivabile (esempio classico: |x| in x=0).</p>

<h3>Metodi per calcolare la derivata in punti di discontinuità</h3>

<h4>1. Definizione di derivata come limite</h4>
        <p>La derivata in un punto x₀ è definita come:</p>
        <p style="text-align: center; font-size: 1.25rem; margin: 1.5rem 0;">
            f'(x₀) = lim<sub>h→0</sub> [f(x₀ + h) – f(x₀)] / h
        </p>
        <p>Per funzioni non continue, dobbiamo calcolare separatamente:</p>
        <ul>
            <li><strong>Derivata destra:</strong> lim<sub>h→0⁺</sub> [f(x₀ + h) – f(x₀)] / h</li>
            <li><strong>Derivata sinistra:</strong> lim<sub>h→0⁻</sub> [f(x₀ + h) – f(x₀)] / h</li>
        </ul>
        <p>La funzione è derivabile nel punto solo se queste due derivate laterali esistono, sono finite e uguali.</p>

<h4>2. Approssimazione numerica</h4>
        <p>Quando il calcolo analitico è complesso, possiamo ricorrere a metodi numerici:</p>
        <ol>
            <li><strong>Metodo delle differenze finite:</strong>
                <p>f'(x) ≈ [f(x + h) – f(x – h)] / (2h)</p>
            </li>
            <li><strong>Metodo di Richardson:</strong>
                <p>Usa estrapolazione per migliorare l’accuratezza</p>
            </li>
            <li><strong>Differenze finite in avanti/indietro:</strong>
                <p>Utile per derivate laterali</p>
            </li>
        </ol>

<h3>Esempi pratici</h3>

<h4>Esempio 1: Funzione valore assoluto</h4>
        <p>Consideriamo f(x) = |x| in x = 0:</p>
        <ul>
            <li>Derivata destra: lim<sub>h→0⁺</sub> [|0 + h| – |0|]/h = lim<sub>h→0⁺</sub> h/h = 1</li>
            <li>Derivata sinistra: lim<sub>h→0⁻</sub> [|0 + h| – |0|]/h = lim<sub>h→0⁻</sub> -h/h = -1</li>
            <li>Conclusione: Le derivate laterali sono diverse → non derivabile in x=0</li>
        </ul>

<h4>Esempio 2: Funzione a tratti</h4>
        <p>Sia f(x) definita come:</p>
        <pre style="background: #f1f5f9; padding: 1rem; border-radius: 0.5rem; overflow-x: auto;">
f(x) = x²    per x ≤ 1
f(x) = 2x    per x > 1
        </pre>
        <p>In x = 1:</p>
        <ul>
            <li>Derivata sinistra: f'(1⁻) = 2*1 = 2</li>
            <li>Derivata destra: f'(1⁺) = 2</li>
            <li>Conclusione: f'(1) = 2 → derivabile in x=1 nonostante il cambio di definizione</li>
        </ul>

<h3>Errori comuni da evitare</h3>
        <table class="wpc-table">
            <thead>
                <tr>
                    <th>Errore</th>
                    <th>Conseguenza</th>
                    <th>Come evitarlo</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Confondere continuità con derivabilità</td>
                    <td>Errata classificazione dei punti</td>
                    <td>Ricordare che derivabilità ⇒ continuità, ma non viceversa</td>
                </tr>
                <tr>
                    <td>Non calcolare entrambe le derivate laterali</td>
                    <td>Risultati incompleti</td>
                    <td>Sempre verificare sia f'(x⁻) che f'(x⁺)</td>
                </tr>
                <tr>
                    <td>Usare regole di derivazione senza verificare la continuità</td>
                    <td>Risultati errati nei punti di discontinuità</td>
                    <td>Prima verificare la continuità, poi applicare le regole</td>
                </tr>
                <tr>
                    <td>Ignorare i punti di non derivabilità</td>
                    <td>Grafici imprecisi</td>
                    <td>Segnalare sempre i punti angolosi o di cuspide</td>
                </tr>
            </tbody>
        </table>

<h3>Applicazioni pratiche</h3>
        <p>Il calcolo delle derivate per funzioni non continue ha importanti applicazioni in:</p>
        <ul>
            <li><strong>Fisica:</strong> Studio di fenomeni con cambi di stato (es. transizioni di fase)</li>
            <li><strong>Economia:</strong> Funzioni di costo con cambi di regime</li>
            <li><strong>Ingegneria:</strong> Controllo di sistemi con comportamenti diversi in diversi intervalli</li>
            <li><strong>Biologia:</strong> Modelli di crescita con soglie</li>
        </ul>

<h3>Confronto tra metodi di calcolo</h3>
        <table class="wpc-table">
            <thead>
                <tr>
                    <th>Metodo</th>
                    <th>Precisione</th>
                    <th>Complessità</th>
                    <th>Casi d’uso</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Definizione limite</td>
                    <td>Alta (esatta)</td>
                    <td>Media-Alta</td>
                    <td>Funzioni con espressione analitica</td>
                </tr>
                <tr>
                    <td>Differenze finite</td>
                    <td>Media (dipende da h)</td>
                    <td>Bassa</td>
                    <td>Funzioni complesse o dati sperimentali</td>
                </tr>
                <tr>
                    <td>Metodo di Richardson</td>
                    <td>Alta</td>
                    <td>Media</td>
                    <td>Quando serve alta precisione numerica</td>
                </tr>
                <tr>
                    <td>Derivazione simbolica</td>
                    <td>Alta</td>
                    <td>Alta</td>
                    <td>Funzioni con molte regole a tratti</td>
                </tr>
            </tbody>
        </table>

<h3>Strumenti per il calcolo</h3>
        <p>Oltre al nostro calcolatore, ecco alcuni strumenti utili:</p>
        <ul>
            <li><strong>Wolfram Alpha:</strong> Potente motore di calcolo simbolico</li>
            <li><strong>GeoGebra:</strong> Per visualizzazione grafica interattiva</li>
            <li><strong>SymPy (Python):</strong> Libreria per calcolo simbolico</li>
            <li><strong>MATLAB:</strong> Per analisi numerica avanzata</li>
        </ul>

<h3>Approfondimenti teorici</h3>
        <p>Per una trattazione rigorosa dell’argomento, consultare:</p>
        <ol>
            <li><a href="https://math.mit.edu/~djk/calculus_beginners/" class="wpc-authority-link" target="_blank" rel="noopener">Calculus for Beginners – MIT Mathematics</a> (introduzione accessibile)</li>
            <li><a href="https://www.math.ucdavis.edu/~hunter/m125a/intro_analysis.pdf" class="wpc-authority-link" target="_blank" rel="noopener">Introduction to Real Analysis – UC Davis</a> (trattazione avanzata)</li>
            <li><a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication811.pdf" class="wpc-authority-link" target="_blank" rel="noopener">Guide for the Use of the International System of Units – NIST</a> (per applicazioni pratiche)</li>
        </ol>

<h3>Domande frequenti</h3>

<h4>1. Una funzione può essere derivabile in un punto di discontinuità?</h4>
        <p>No. La derivabilità implica necessariamente la continuità. Se una funzione è discontinua in un punto, non può essere derivabile in quel punto.</p>

<h4>2. Come si riconosce una discontinuità di prima specie?</h4>
        <p>Una discontinuità è di prima specie quando:</p>
        <ul>
            <li>Esistono finiti entrambi i limiti destro e sinistro</li>
            <li>I due limiti sono diversi tra loro</li>
            <li>Il “salto” è finito</li>
        </ul>

<h4>3. Qual è la differenza tra punto angoloso e cuspide?</h4>
        <p>
            <ul>
                <li><strong>Punto angoloso:</strong> Le derivate destra e sinistra esistono ma sono diverse (es. |x| in x=0)</li>
                <li><strong>Cuspide:</strong> Almeno una delle derivate laterali è infinita (es. f(x) = x^(2/3) in x=0)</li>
            </ul>
        </p>

<h4>4. Come si calcola la derivata di una funzione definita a tratti?</h4>
        <p>Bisogna:</p>
        <ol>
            <li>Derivare separatamente ogni tratto</li>
            <li>Verificare la continuità nei punti di raccordo</li>
            <li>Calcolare le derivate laterali nei punti di raccordo</li>
            <li>Confrontare le derivate laterali per verificare la derivabilità</li>
        </ol>

<h4>5. È possibile che una funzione sia continua ma non derivabile in nessun punto?</h4>
        <p>Sì. Un esempio famoso è la <span class="wpc-highlight">funzione di Weierstrass</span>, continua ovunque ma non derivabile in nessun punto. Questa funzione è definita come:</p>
        <p style="text-align: center; font-style: italic; margin: 1rem 0;">
            f(x) = Σ<sub>n=0</sub><sup>∞</sup> a<sup>n</sup> cos(b<sup>n</sup>πx)
        </p>
        <p>dove 0 < a < 1, b è un intero dispari, e ab > 1 + 3π/2.</p>

<h3>Conclusione</h3>
        <p>Il calcolo delle derivate per funzioni non continue richiede una comprensione profonda dei concetti di limite, continuità e derivabilità. Mentre le funzioni continue permettono l’applicazione diretta delle regole di derivazione, le funzioni non continue richiedono un’analisi più attenta, specialmente nei punti di discontinuità.</p>
        <p>Ricordate sempre che:</p>
        <ul>
            <li>La derivabilità implica la continuità, ma non viceversa</li>
            <li>Nei punti di discontinuità, la funzione non è mai derivabile</li>
            <li>Anche in punti di continuità, la funzione potrebbe non essere derivabile (es. punti angolosi)</li>
            <li>Le derivate laterali sono strumenti essenziali per analizzare la derivabilità</li>
        </ul>
        <p>Utilizzate il nostro calcolatore per verificare i vostri esercizi e approfondite la teoria con le risorse linkate per padronanza completa dell’argomento.</p>
    </article>
</section>

functionType.addEventListener('change', function() {
        piecewiseGroup.style.display = 'none';
        absoluteGroup.style.display = 'none';
        stepGroup.style.display = 'none';
        customGroup.style.display = 'none';

switch(this.value) {
            case 'piecewise':
                piecewiseGroup.style.display = 'block';
                break;
            case 'absolute':
                absoluteGroup.style.display = 'block';
                break;
            case 'step':
                stepGroup.style.display = 'block';
                break;
            case 'custom':
                customGroup.style.display = 'block';
                break;
        }
    });

// Gestione form
    const form = document.getElementById('wpc-derivative-form');
    const resultsDiv = document.getElementById('wpc-results');

form.addEventListener('submit', function(e) {
        e.preventDefault();
        calculateDerivative();
    });

function calculateDerivative() {
        // Leggi input
        const functionType = document.getElementById('wpc-function-type').value;
        const xPoint = parseFloat(document.getElementById('wpc-point-x').value);
        const method = document.querySelector('input[name="wpc-method"]:checked').value;
        const precision = parseFloat(document.getElementById('wpc-precision').value);

let functionDefinition = {};
        let leftDerivative, rightDerivative, derivative, continuity, differentiability;

try {
            // Definisci la funzione in base al tipo
            switch(functionType) {
                case 'piecewise':
                    const f1 = document.getElementById('wpc-piecewise-f1').value;
                    const f2 = document.getElementById('wpc-piecewise-f2').value;
                    const a = parseFloat(document.getElementById('wpc-piecewise-a').value);

functionDefinition = {
                        type: 'piecewise',
                        f1: f1,
                        f2: f2,
                        point: a,
                        x: xPoint
                    };

// Calcola derivate
                    const result = calculatePiecewiseDerivative(f1, f2, a, xPoint, method, precision);
                    leftDerivative = result.leftDerivative;
                    rightDerivative = result.rightDerivative;
                    derivative = result.derivative;
                    continuity = result.continuity;
                    differentiability = result.differentiability;
                    break;

case 'absolute':
                    const innerFunc = document.getElementById('wpc-absolute-function').value;
                    functionDefinition = {
                        type: 'absolute',
                        innerFunc: innerFunc,
                        x: xPoint
                    };

const absResult = calculateAbsoluteDerivative(innerFunc, xPoint, method, precision);
                    leftDerivative = absResult.leftDerivative;
                    rightDerivative = absResult.rightDerivative;
                    derivative = absResult.derivative;
                    continuity = absResult.continuity;
                    differentiability = absResult.differentiability;
                    break;

case 'step':
                    const height = parseFloat(document.getElementById('wpc-step-height').value);
                    const position = parseFloat(document.getElementById('wpc-step-position').value);

functionDefinition = {
                        type: 'step',
                        height: height,
                        position: position,
                        x: xPoint
                    };

const stepResult = calculateStepDerivative(height, position, xPoint);
                    leftDerivative = stepResult.leftDerivative;
                    rightDerivative = stepResult.rightDerivative;
                    derivative = stepResult.derivative;
                    continuity = stepResult.continuity;
                    differentiability = stepResult.differentiability;
                    break;

case 'custom':
                    const customFunc = document.getElementById('wpc-custom-function').value;
                    functionDefinition = {
                        type: 'custom',
                        definition: customFunc,
                        x: xPoint
                    };

const customResult = calculateCustomDerivative(customFunc, xPoint, method, precision);
                    leftDerivative = customResult.leftDerivative;
                    rightDerivative = customResult.rightDerivative;
                    derivative = customResult.derivative;
                    continuity = customResult.continuity;
                    differentiability = customResult.differentiability;
                    break;

default:
                    throw new Error('Selezionare un tipo di funzione');
            }

// Mostra risultati
            displayResults(xPoint, leftDerivative, rightDerivative, derivative, continuity, differentiability);
            plotFunction(functionDefinition);

} catch (error) {
            alert('Errore nel calcolo: ' + error.message);
            console.error(error);
        }
    }

function calculatePiecewiseDerivative(f1, f2, a, x, method, h) {
        // Crea funzioni matematiche
        const scope1 = {x: x};
        const scope2 = {x: x};

try {
            const expr1 = math.parse(f1);
            const expr2 = math.parse(f2);

const f1Value = expr1.evaluate(scope1);
            const f2Value = expr2.evaluate(scope2);

// Verifica continuità
            let continuous = true;
            let continuityText = 'Continua';

if (Math.abs(x - a) < 1e-6) {
                // Punto di raccordo
                const leftLimit = expr1.evaluate({x: a});
                const rightLimit = expr2.evaluate({x: a});
                if (Math.abs(leftLimit - rightLimit) > 1e-6) {
                    continuous = false;
                    continuityText = `Discontinua (salto: ${(leftLimit - rightLimit).toFixed(4)})`;
                }
            }

// Calcola derivate
            let leftDeriv, rightDeriv, deriv;

if (method === 'limit') {
                // Metodo analitico (derivata simbolica)
                try {
                    const df1 = math.derivative(f1, 'x');
                    const df2 = math.derivative(f2, 'x');

if (x < a) {
                        leftDeriv = rightDeriv = df1.evaluate({x: x});
                        deriv = leftDeriv;
                    } else if (x > a) {
                        leftDeriv = rightDeriv = df2.evaluate({x: x});
                        deriv = leftDeriv;
                    } else {
                        // Punto di raccordo
                        leftDeriv = df1.evaluate({x: a});
                        rightDeriv = df2.evaluate({x: a});
                        deriv = (Math.abs(leftDeriv - rightDeriv) < 1e-6) ? leftDeriv : 'Non definita';
                    }
                } catch (e) {
                    // Se fallisce la derivazione simbolica, usa metodo numerico
                    method = 'numerical';
                }
            }

if (method === 'numerical') {
                // Metodo numerico
                if (x < a) {
                    // Solo funzione f1
                    leftDeriv = rightDeriv = numericalDerivative(f1, x, h);
                    deriv = leftDeriv;
                } else if (x > a) {
                    // Solo funzione f2
                    leftDeriv = rightDeriv = numericalDerivative(f2, x, h);
                    deriv = leftDeriv;
                } else {
                    // Punto di raccordo
                    leftDeriv = numericalDerivative(f1, a, h, 'left');
                    rightDeriv = numericalDerivative(f2, a, h, 'right');
                    deriv = (Math.abs(leftDeriv - rightDeriv) < 1e-3) ? (leftDeriv + rightDeriv)/2 : 'Non definita';
                }
            }

// Verifica derivabilità
            let differentiable = true;
            let differentiabilityText = 'Derivabile';

if (Math.abs(x - a) < 1e-6) {
                if (Math.abs(leftDeriv - rightDeriv) > 1e-3) {
                    differentiable = false;
                    differentiabilityText = `Non derivabile (derivata sinistra: ${leftDeriv.toFixed(4)}, destra: ${rightDeriv.toFixed(4)})`;
                }
            } else if (deriv === 'Non definita') {
                differentiable = false;
                differentiabilityText = 'Non derivabile';
            }

return {
                leftDerivative: formatNumber(leftDeriv),
                rightDerivative: formatNumber(rightDeriv),
                derivative: formatNumber(deriv),
                continuity: continuityText,
                differentiability: differentiabilityText
            };

} catch (error) {
            console.error('Error in piecewise calculation:', error);
            throw new Error('Impossibile calcolare la derivata per la funzione a tratti fornita');
        }
    }

function calculateAbsoluteDerivative(innerFunc, x, method, h) {
        // Funzione valore assoluto: f(x) = |g(x)| dove g(x) = innerFunc
        const scope = {x: x};

try {
            const gExpr = math.parse(innerFunc);
            const gValue = gExpr.evaluate(scope);

// Verifica continuità (|g(x)| è sempre continua)
            const continuityText = 'Continua';

// Calcola derivata
            let deriv, leftDeriv, rightDeriv;

if (method === 'limit') {
                try {
                    // Derivata di |g(x)| = g'(x) * sign(g(x)) quando g(x) ≠ 0
                    const dgExpr = math.derivative(innerFunc, 'x');
                    const gPrime = dgExpr.evaluate(scope);

if (Math.abs(gValue) > 1e-6) {
                        // Punto regolare
                        const sign = Math.sign(gValue);
                        leftDeriv = rightDeriv = deriv = gPrime * sign;
                    } else {
                        // Punto critico (g(x) = 0)
                        leftDeriv = -gPrime;
                        rightDeriv = gPrime;
                        deriv = 'Non definita';
                    }
                } catch (e) {
                    method = 'numerical';
                }
            }

if (method === 'numerical') {
                const absFunc = `abs(${innerFunc})`;

if (Math.abs(gValue) > 1e-6) {
                    // Punto regolare
                    leftDeriv = rightDeriv = numericalDerivative(absFunc, x, h);
                    deriv = leftDeriv;
                } else {
                    // Punto critico
                    leftDeriv = numericalDerivative(absFunc, x, h, 'left');
                    rightDeriv = numericalDerivative(absFunc, x, h, 'right');
                    deriv = 'Non definita';
                }
            }

// Verifica derivabilità
            let differentiabilityText;
            if (Math.abs(gValue) < 1e-6) {
                differentiabilityText = 'Non derivabile (punto di cuspide)';
            } else if (deriv === 'Non definita') {
                differentiabilityText = 'Non derivabile';
            } else {
                differentiabilityText = 'Derivabile';
            }

} catch (error) {
            console.error('Error in absolute value calculation:', error);
            throw new Error('Impossibile calcolare la derivata per la funzione valore assoluto fornita');
        }
    }

function calculateStepDerivative(height, position, x) {
        // Funzione gradino: f(x) = 0 per x < position, f(x) = height per x ≥ position

// Verifica continuità
        let continuityText = 'Continua';
        if (Math.abs(x - position) < 1e-6) {
            continuityText = `Discontinua (salto: ${height})`;
        }

// Calcola derivate
        let leftDeriv = 0;
        let rightDeriv = 0;
        let deriv = 0;

if (x < position || x > position) {
            // Fuori dal punto di discontinuità
            leftDeriv = rightDeriv = deriv = 0;
        } else {
            // Nel punto di discontinuità
            leftDeriv = 0;
            rightDeriv = 0;
            deriv = 'Non definita';
        }

return {
            leftDerivative: leftDeriv,
            rightDerivative: rightDeriv,
            derivative: deriv,
            continuity: continuityText,
            differentiability: 'Non derivabile nel punto di discontinuità'
        };
    }

function calculateCustomDerivative(definition, x, method, h) {
        // Analizza la definizione personalizzata
        const lines = definition.split('\n');
        let pieces = [];
        let conditions = [];

for (const line of lines) {
            if (line.trim() === '') continue;

// Estrai condizione e funzione
            const match = line.match(/per\s*(.+):\s*(.+)/i);
            if (match) {
                conditions.push(match[1].trim());
                pieces.push(match[2].trim());
            }
        }

if (pieces.length === 0) {
            throw new Error('Definizione della funzione non valida');
        }

// Determina in quale pezzo ricade x
        let activePiece = -1;
        let isBoundary = false;
        let boundaryValue = null;

for (let i = 0; i < conditions.length; i++) {
            const cond = conditions[i];

try {
                // Sostituisci x con il valore numerico
                const condExpr = cond.replace(/x/g, x);
                const result = math.evaluate(condExpr);

if (result) {
                    activePiece = i;
                    break;
                }
            } catch (e) {
                // Prova a valutare come espressione booleana
                const scope = {x: x};
                try {
                    const expr = math.parse(cond);
                    const result = expr.evaluate(scope);

if (result) {
                        activePiece = i;
                        break;
                    }
                } catch (e2) {
                    console.warn('Condizione non valutabile:', cond);
                }
            }

// Verifica se x è un punto di confine
            const boundaryMatch = cond.match(/x\s*([<=])\s*([-\d.]+)/);
            if (boundaryMatch) {
                const op = boundaryMatch[1];
                const val = parseFloat(boundaryMatch[2]);

if (Math.abs(x - val) < 1e-6) {
                    isBoundary = true;
                    boundaryValue = val;
                }
            }
        }

if (activePiece === -1 && !isBoundary) {
            throw new Error(`Il punto x = ${x} non ricade in nessuna definizione della funzione`);
        }

// Valuta continuità
        let continuityText = 'Continua';
        if (isBoundary) {
            // Verifica continuità nel punto di confine
            let leftLimit, rightLimit;

// Trova i pezzi adiacenti
            let leftPiece = -1, rightPiece = -1;

for (let i = 0; i < conditions.length; i++) {
                const cond = conditions[i];

// Cerca il pezzo per x ≤ boundaryValue
                if (cond.includes('x <=') || cond.includes('x ≤')) {
                    const valMatch = cond.match(/x\s*([<=])\s*([-\d.]+)/);
                    if (valMatch && Math.abs(parseFloat(valMatch[2]) - boundaryValue) < 1e-6) {
                        leftPiece = i;
                    }
                }

// Cerca il pezzo per x > boundaryValue
                if (cond.includes('x >')) {
                    const valMatch = cond.match(/x\s*(>)\s*([-\d.]+)/);
                    if (valMatch && Math.abs(parseFloat(valMatch[2]) - boundaryValue) < 1e-6) {
                        rightPiece = i;
                    }
                }
            }

if (leftPiece !== -1 && rightPiece !== -1) {
                try {
                    const scope = {x: boundaryValue};
                    leftLimit = math.parse(pieces[leftPiece]).evaluate(scope);
                    rightLimit = math.parse(pieces[rightPiece]).evaluate(scope);

if (Math.abs(leftLimit - rightLimit) > 1e-6) {
                        continuityText = `Discontinua (salto: ${(leftLimit - rightLimit).toFixed(4)})`;
                    }
                } catch (e) {
                    console.warn('Impossibile valutare i limiti:', e);
                }
            }
        }

// Calcola derivate
        let leftDeriv, rightDeriv, deriv;

if (isBoundary) {
            // Punto di confine - calcola derivate laterali
            let leftPiece = -1, rightPiece = -1;

for (let i = 0; i < conditions.length; i++) {
                const cond = conditions[i];

if ((cond.includes('x <=') || cond.includes('x ≤')) &&
                    !cond.includes('x >') && !cond.includes('x >=')) {
                    const valMatch = cond.match(/x\s*([<=])\s*([-\d.]+)/);
                    if (valMatch && Math.abs(parseFloat(valMatch[2]) - boundaryValue) < 1e-6) {
                        leftPiece = i;
                    }
                }

if (cond.includes('x >') || cond.includes('x >=')) {
                    const valMatch = cond.match(/x\s*(>=?)\s*([-\d.]+)/);
                    if (valMatch && Math.abs(parseFloat(valMatch[2]) - boundaryValue) < 1e-6) {
                        rightPiece = i;
                    }
                }
            }

if (leftPiece !== -1) {
                if (method === 'limit') {
                    try {
                        leftDeriv = math.derivative(pieces[leftPiece], 'x').evaluate({x: boundaryValue});
                    } catch (e) {
                        leftDeriv = numericalDerivative(pieces[leftPiece], boundaryValue, h, 'left');
                    }
                } else {
                    leftDeriv = numericalDerivative(pieces[leftPiece], boundaryValue, h, 'left');
                }
            }

if (rightPiece !== -1) {
                if (method === 'limit') {
                    try {
                        rightDeriv = math.derivative(pieces[rightPiece], 'x').evaluate({x: boundaryValue});
                    } catch (e) {
                        rightDeriv = numericalDerivative(pieces[rightPiece], boundaryValue, h, 'right');
                    }
                } else {
                    rightDeriv = numericalDerivative(pieces[rightPiece], boundaryValue, h, 'right');
                }
            }

// Verifica derivabilità
            if (Math.abs(leftDeriv - rightDeriv) < 1e-3) {
                deriv = (leftDeriv + rightDeriv) / 2;
            } else {
                deriv = 'Non definita';
            }

} else {
            // Punto interno a un pezzo
            const piece = pieces[activePiece];

if (method === 'limit') {
                try {
                    deriv = math.derivative(piece, 'x').evaluate({x: x});
                    leftDeriv = rightDeriv = deriv;
                } catch (e) {
                    leftDeriv = rightDeriv = deriv = numericalDerivative(piece, x, h);
                }
            } else {
                leftDeriv = rightDeriv = deriv = numericalDerivative(piece, x, h);
            }
        }

// Verifica derivabilità
        let differentiabilityText;
        if (isBoundary) {
            if (Math.abs(leftDeriv - rightDeriv) < 1e-3) {
                differentiabilityText = 'Derivabile';
            } else {
                differentiabilityText = `Non derivabile (derivata sinistra: ${leftDeriv.toFixed(4)}, destra: ${rightDeriv.toFixed(4)})`;
            }
        } else {
            differentiabilityText = 'Derivabile';
        }

return {
            leftDerivative: formatNumber(leftDeriv),
            rightDerivative: formatNumber(rightDeriv),
            derivative: formatNumber(deriv),
            continuity: continuityText,
            differentiability: differentiabilityText
        };
    }

function numericalDerivative(f, x, h, side = 'central') {
        const scope = {x: x};
        try {
            const fx = math.parse(f).evaluate(scope);

if (side === 'left') {
                const scopeLeft = {x: x - h};
                const fLeft = math.parse(f).evaluate(scopeLeft);
                return (fx - fLeft) / h;
            } else if (side === 'right') {
                const scopeRight = {x: x + h};
                const fRight = math.parse(f).evaluate(scopeRight);
                return (fRight - fx) / h;
            } else {
                // Central difference
                const scopeLeft = {x: x - h};
                const scopeRight = {x: x + h};
                const fLeft = math.parse(f).evaluate(scopeLeft);
                const fRight = math.parse(f).evaluate(scopeRight);
                return (fRight - fLeft) / (2 * h);
            }
        } catch (e) {
            console.error('Error in numerical derivative:', e);
            return NaN;
        }
    }

function formatNumber(num) {
        if (num === 'Non definita') return num;
        if (isNaN(num)) return 'Non definita';
        if (Math.abs(num) < 1e-6) return '0';

// Formatta con massimo 6 decimali significativi
        if (Math.abs(num) >= 1) {
            return num.toFixed(6).replace(/(\.\d*?[1-9])0+$/, '$1').replace(/\.$/, '');
        } else {
            // Per numeri molto piccoli, usa notazione scientifica
            return num.toExponential(3);
        }
    }

function displayResults(x, leftDeriv, rightDeriv, deriv, continuity, differentiability) {
        document.getElementById('wpc-result-point').textContent = x.toFixed(4);
        document.getElementById('wpc-result-left').textContent = leftDeriv;
        document.getElementById('wpc-result-right').textContent = rightDeriv;
        document.getElementById('wpc-result-derivative').textContent = deriv;
        document.getElementById('wpc-result-continuity').textContent = continuity;
        document.getElementById('wpc-result-differentiability').textContent = differentiability;

resultsDiv.style.display = 'block';

// Scroll ai risultati
        resultsDiv.scrollIntoView({behavior: 'smooth'});
    }

function plotFunction(functionDefinition) {
        const ctx = document.getElementById('wpc-chart').getContext('2d');

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

const xValues = [];
        const yValues = [];

// Genera punti per il grafico
        const xMin = functionDefinition.x - 5;
        const xMax = functionDefinition.x + 5;
        const step = 0.1;

for (let x = xMin; x <= xMax; x += step) {
            xValues.push(x);
            yValues.push(evaluateFunctionAt(functionDefinition, x));
        }

// Crea il grafico
        window.functionChart = new Chart(ctx, {
            type: 'line',
            data: {
                labels: xValues,
                datasets: [{
                    label: 'Funzione',
                    data: yValues,
                    borderColor: '#2563eb',
                    backgroundColor: 'rgba(37, 99, 235, 0.1)',
                    borderWidth: 2,
                    tension: 0.1,
                    pointRadius: 0,
                    pointHitRadius: 10
                }]
            },
            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: {
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                return `f(${context.parsed.x.toFixed(2)}) = ${context.parsed.y.toFixed(4)}`;
                            }
                        }
                    },
                    legend: {
                        position: 'top',
                    },
                    annotation: {
                        annotations: {
                            point: {
                                type: 'point',
                                xValue: functionDefinition.x,
                                yValue: evaluateFunctionAt(functionDefinition, functionDefinition.x),
                                backgroundColor: '#ef4444',
                                borderColor: '#ffffff',
                                borderWidth: 2,
                                radius: 8,
                                label: {
                                    content: `x = ${functionDefinition.x.toFixed(2)}`,
                                    enabled: true,
                                    position: 'top'
                                }
                            }
                        }
                    }
                }
            },
            plugins: [{
                id: 'customAnnotation',
                beforeDraw: function(chart) {
                    const ctx = chart.ctx;
                    const xAxis = chart.scales.x;
                    const yAxis = chart.scales.y;
                    const x = functionDefinition.x;
                    const y = evaluateFunctionAt(functionDefinition, x);

// Disegna linea verticale nel punto analizzato
                    ctx.save();
                    ctx.beginPath();
                    ctx.moveTo(xAxis.getPixelForValue(x), yAxis.top);
                    ctx.lineTo(xAxis.getPixelForValue(x), yAxis.bottom);
                    ctx.strokeStyle = '#ef4444';
                    ctx.lineWidth = 1;
                    ctx.setLineDash([5, 5]);
                    ctx.stroke();
                    ctx.restore();
                }
            }]
        });
    }

case 'absolute':
                    const scope = {x: x};
                    const innerVal = math.parse(functionDefinition.innerFunc).evaluate(scope);
                    return Math.abs(innerVal);

case 'step':
                    return x < functionDefinition.position ? 0 : functionDefinition.height;

case 'custom':
                    const lines = functionDefinition.definition.split('\n');
                    for (const line of lines) {
                        if (line.trim() === '') continue;

const match = line.match(/per\s*(.+):\s*(.+)/i);
                        if (match) {
                            const cond = match[1].trim();
                            const expr = match[2].trim();

try {
                                // Valuta la condizione
                                const scope = {x: x};
                                const condExpr = math.parse(cond);
                                const condResult = condExpr.evaluate(scope);

if (condResult) {
                                    const exprScope = {x: x};
                                    return math.parse(expr).evaluate(exprScope);
                                }
                            } catch (e) {
                                // Prova valutazione diretta
                                const condExpr = cond.replace(/x/g, x);
                                const result = math.evaluate(condExpr);
                                if (result) {
                                    const exprScope = {x: x};
                                    return math.parse(expr).evaluate(exprScope);
                                }
                            }
                        }
                    }
                    return NaN;

default:
                    return 0;
            }
        } catch (e) {
            console.error('Error evaluating function:', e);
            return NaN;
        }
    }
});
</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-la-derivta-di-una-funzione-non-continua/#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">