Calcolatore Dominio Funzione dal Grafico

Determina il dominio di una funzione analizzando le sue caratteristiche grafiche

Tipo di funzione

Denominatore (per funzioni razionali)

Indice della radice

Valore di n per radice n-esima

Base del logaritmo

Caratteristiche grafiche

Asintoti verticali

Buchi (punti di discontinuità eliminabile)

Radici con indice pari (restrizioni)

Logaritmi (argomento > 0)

Valori x degli asintoti verticali (separati da virgola)

Valori x dei buchi (separati da virgola)

Altre restrizioni (opzionale)

Calcola Dominio</button>

<div id="wpc-results" class="wpc-results">
            <h3 class="wpc-result-title">Risultati</h3>
            <div id="wpc-domain-result" class="wpc-result-item">
                <span class="wpc-result-label">Dominio della funzione:</span>
                <span id="wpc-domain-value"></span>
            </div>
            <div id="wpc-interval-result" class="wpc-result-item">
                <span class="wpc-result-label">Intervallo in notazione:</span>
                <span id="wpc-interval-value"></span>
            </div>
            <div id="wpc-exclusions-result" class="wpc-result-item">
                <span class="wpc-result-label">Valori esclusi:</span>
                <span id="wpc-exclusions-value"></span>
            </div>
        </div>

<div class="wpc-content">
        <article>
            <h2>Guida Completa: Come Calcolare il Dominio di una Funzione dal Grafico</h2>

<p>Il dominio di una funzione rappresenta l’insieme di tutti i valori di input (generalmente x) per i quali la funzione è definita. Quando si lavora con il grafico di una funzione, determinare il dominio richiede un’analisi attenta delle caratteristiche visive e delle proprietà matematiche sottostanti.</p>

<h3>1. Fondamenti del Dominio di una Funzione</h3>
            <p>Prima di esaminare i grafici, è essenziale comprendere cosa costituisce il dominio:</p>
            <ul>
                <li><strong>Funzioni polinomiali</strong>: Il dominio è sempre ℝ (tutti i numeri reali)</li>
                <li><strong>Funzioni razionali</strong>: Escludere i valori che annullano il denominatore</li>
                <li><strong>Funzioni con radici</strong>:
                    <ul>
                        <li>Indice pari: radicando ≥ 0</li>
                        <li>Indice dispari: radicando ∈ ℝ</li>
                    </ul>
                </li>
                <li><strong>Funzioni logaritmiche</strong>: Argomento > 0</li>
                <li><strong>Funzioni esponenziali</strong>: Dominio ℝ (ma codominio y > 0)</li>
            </ul>

<h3>2. Analisi Grafica per Determinare il Dominio</h3>
            <p>Quando si osservano i grafici, questi elementi visivi indicano restrizioni sul dominio:</p>

<div class="wpc-grid">
                <div class="wpc-card">
                    <h4 class="wpc-card-title">Asintoti Verticali</h4>
                    <p>Le linee verticali a cui il grafico si avvicina ma non tocca mai (asintoti) indicano valori di x che <strong>non</strong> appartengono al dominio. Ad esempio, in <em>f(x) = 1/(x-2)</em>, x=2 è un asintoto verticale.</p>
                </div>

<div class="wpc-card">
                    <h4 class="wpc-card-title">Buchi nel Grafico</h4>
                    <p>I punti vuoti (∘) sul grafico rappresentano discontinuità eliminabili. Questi valori di x sono esclusi dal dominio anche se la funzione potrebbe essere definita lì con un limite. Esempio: <em>f(x) = (x²-1)/(x-1)</em> ha un buco in x=1.</p>
                </div>

<div class="wpc-card">
                    <h4 class="wpc-card-title">Estremi del Grafico</h4>
                    <p>Se il grafico termina bruscamente con una linea verticale (come in √x), quel punto rappresenta un estremo del dominio. Per √x, il dominio inizia a x=0.</p>
                </div>
            </div>

<h3>3. Procedura Step-by-Step per Calcolare il Dominio dal Grafico</h3>
            <ol>
                <li><strong>Identificare il tipo di funzione</strong>: Polinomiale, razionale, radicale, etc.</li>
                <li><strong>Localizzare asintoti verticali</strong>: Tracciare linee verticali dove la funzione “schizza” all’infinito.</li>
                <li><strong>Individuare buchi</strong>: Cercare punti vuoti (∘) sul grafico.</li>
                <li><strong>Verificare estremi del grafico</strong>: Dove il grafico inizia/finisce improvvisamente.</li>
                <li><strong>Considerare restrizioni implicite</strong>:
                    <ul>
                        <li>Radici con indice pari: la curva esiste solo dove il radicando ≥ 0</li>
                        <li>Logaritmi: la curva esiste solo dove l’argomento > 0</li>
                    </ul>
                </li>
                <li><strong>Scrivere il dominio</strong>: Combinare tutte le osservazioni in notazione intervallare.</li>
            </ol>

<h3>4. Esempi Pratici con Grafici</h3>

<div class="wpc-card">
                <h4 class="wpc-card-title">Esempio 1: Funzione Razionale</h4>
                <p>Grafico di <em>f(x) = (x+1)/(x²-4)</em>:</p>
                <ul>
                    <li><strong>Asintoti verticali</strong>: x=-2 e x=2 (dove il denominatore è zero)</li>
                    <li><strong>Buco</strong>: Nessuno (il numeratore non annulla il denominatore)</li>
                    <li><strong>Dominio</strong>: (-∞, -2) ∪ (-2, 2) ∪ (2, ∞)</li>
                </ul>
            </div>

<div class="wpc-card">
                <h4 class="wpc-card-title">Esempio 2: Funzione con Radice</h4>
                <p>Grafico di <em>f(x) = √(x-3)</em>:</p>
                <ul>
                    <li><strong>Estremo del grafico</strong>: Inizia a x=3</li>
                    <li><strong>Radice con indice pari</strong>: Radicando (x-3) ≥ 0 → x ≥ 3</li>
                    <li><strong>Dominio</strong>: [3, ∞)</li>
                </ul>
            </div>

<h3>5. Errori Comuni da Evitare</h3>
            <table class="wpc-table">
                <thead>
                    <tr>
                        <th>Errore</th>
                        <th>Spiegazione</th>
                        <th>Correzione</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Ignorare i buchi</td>
                        <td>Confondere buchi (discontinuità eliminabili) con punti del dominio</td>
                        <td>I buchi <strong>escludono</strong> quel valore x dal dominio</td>
                    </tr>
                    <tr>
                        <td>Dimenticare radici pari</td>
                        <td>Non considerare che √(x) richiede x ≥ 0</td>
                        <td>Sempre verificare il radicando per radici con indice pari</td>
                    </tr>
                    <tr>
                        <td>Asintoti obliqui</td>
                        <td>Confondere asintoti obliqui con verticali per il dominio</td>
                        <td>Solo gli asintoti <strong>verticali</strong> influenzano il dominio</td>
                    </tr>
                    <tr>
                        <td>Logaritmi</td>
                        <td>Non ricordare che log(x) richiede x > 0</td>
                        <td>L’argomento deve essere <strong>strettamente positivo</strong></td>
                    </tr>
                </tbody>
            </table>

<h3>6. Confronto tra Metodi: Grafico vs. Analitico</h3>
            <table class="wpc-table">
                <thead>
                    <tr>
                        <th>Criterio</th>
                        <th>Metodo Grafico</th>
                        <th>Metodo Analitico</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Precisione</td>
                        <td>Approssimativa (dipende dalla scala)</td>
                        <td>Esatta (calcoli algebrici)</td>
                    </tr>
                    <tr>
                        <td>Velocità</td>
                        <td>Rapido per funzioni semplici</td>
                        <td>Può essere lento per funzioni complesse</td>
                    </tr>
                    <tr>
                        <td>Complessità</td>
                        <td>Ideale per funzioni con asintoti/buchi visibili</td>
                        <td>Necessario per funzioni senza grafico</td>
                    </tr>
                    <tr>
                        <td>Errori comuni</td>
                        <td>Trascurare dettagli grafici</td>
                        <td>Errori di calcolo algebrico</td>
                    </tr>
                    <tr>
                        <td>Strumenti richiesti</td>
                        <td>Grafico (cartaceo o digitale)</td>
                        <td>Conoscenze algebriche</td>
                    </tr>
                </tbody>
            </table>

<h3>7. Strumenti Utili per l’Analisi Grafica</h3>
            <ul>
                <li><strong>Software di grafici</strong>:
                    <ul>
                        <li>Desmos (gratuito, online)</li>
                        <li>GeoGebra (interattivo)</li>
                        <li>Wolfram Alpha (avanzato)</li>
                    </ul>
                </li>
                <li><strong>Calcolatrici grafiche</strong>:
                    <ul>
                        <li>TI-84 Plus</li>
                        <li>Casio fx-9860GII</li>
                    </ul>
                </li>
                <li><strong>Trucchi visivi</strong>:
                    <ul>
                        <li>Usare la “regola della matita”: se non puoi tracciare il grafico senza sollevare la matita, c’è una discontinuità</li>
                        <li>Cercare “salti” improvvisi nel grafico</li>
                    </ul>
                </li>
            </ul>

<h3>8. Applicazioni Pratiche del Dominio</h3>
            <p>Comprendere il dominio non è solo un esercizio accademico, ma ha applicazioni concrete:</p>
            <ul>
                <li><strong>Economia</strong>: Funzioni di costo/ricavo dove certi valori di x (quantità) non hanno senso (es: quantità negative)</li>
                <li><strong>Fisica</strong>: Equazioni dove certe variabili non possono assumere valori specifici (es: tempo negativo)</li>
                <li><strong>Biologia</strong>: Modelli di crescita dove la popolazione non può essere negativa</li>
                <li><strong>Ingegneria</strong>: Progettazione dove certi parametri hanno limiti fisici</li>
            </ul>

<h3>9. Approfondimenti Matematici</h3>
            <p>Per una comprensione più avanzata:</p>
            <ul>
                <li><strong>Teorema di Esistenza degli Zeri</strong>: Relazione tra dominio e radici della funzione</li>
                <li><strong>Continuità</strong>: Come il dominio influisce sulla continuità</li>
                <li><strong>Derivabilità</strong>: Punti del dominio dove la funzione non è derivabile</li>
                <li><strong>Limiti</strong>: Comportamento della funzione agli estremi del dominio</li>
            </ul>

<h3>10. Risorse Autorevoli per Ulteriori Studi</h3>
            <p>Per approfondire l’argomento, consultare queste risorse accademiche:</p>
            <ul>
                <li><a href="https://math.mit.edu/" class="wpc-authority-link" target="_blank" rel="noopener">MIT Mathematics</a> – Corsi avanzati su funzioni e loro domini</li>
                <li><a href="https://math.berkeley.edu/" class="wpc-authority-link" target="_blank" rel="noopener">UC Berkeley Math Department</a> – Risorse su analisi grafica</li>
                <li><a href="https://www.khanacademy.org/math" class="wpc-authority-link" target="_blank" rel="noopener">Khan Academy – Math</a> – Lezioni interattive su domini e grafici</li>
                <li><a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication811.pdf" class="wpc-authority-link" target="_blank" rel="noopener">NIST Guide to Mathematical Functions</a> (PDF) – Riferimento tecnico</li>
            </ul>

<h3>11. Esercizi Pratici con Soluzioni</h3>
            <p>Prova a determinare il dominio di queste funzioni basandoti sulle loro descrizioni grafiche:</p>
            <ol>
                <li><strong>Grafico 1</strong>: Curva che inizia a x=-2, ha un asintoto verticale in x=3 e un buco in x=0.
                    <div style="margin: 1rem 0; padding: 1rem; background-color: #f1f5f9; border-radius: 0.375rem;">
                        <strong>Soluzione</strong>: Dominio = [-2, 0) ∪ (0, 3) ∪ (3, ∞)
                    </div>
                </li>
                <li><strong>Grafico 2</strong>: Curva che esiste solo sopra l’asse x, con estremi a x=-1 e x=4.
                    <div style="margin: 1rem 0; padding: 1rem; background-color: #f1f5f9; border-radius: 0.375rem;">
                        <strong>Soluzione</strong>: Dominio = [-1, 4] (probabile funzione radicale con radicando ≥ 0 in questo intervallo)
                    </div>
                </li>
                <li><strong>Grafico 3</strong>: Curva con asintoti verticali in x=-π/2 e x=π/2, che si ripete ogni 2π.
                    <div style="margin: 1rem 0; padding: 1rem; background-color: #f1f5f9; border-radius: 0.375rem;">
                        <strong>Soluzione</strong>: Dominio = ℝ eccetto x = π/2 + kπ, k ∈ ℤ (tipico di secante o cosecante)
                    </div>
                </li>
            </ol>

<h3>12. Domande Frequenti</h3>
            <div class="wpc-card">
                <h4 class="wpc-card-title">D: Come faccio a sapere se un punto è un buco o un asintoto?</h4>
                <p><strong>R:</strong> Un <strong>buco</strong> appare quando sia il numeratore che il denominatore hanno una radice comune (fattore cancellabile). Un <strong>asintoto verticale</strong> si verifica quando solo il denominatore ha una radice (fattore non cancellabile).</p>
            </div>

<div class="wpc-card">
                <h4 class="wpc-card-title">D: Il dominio può essere vuoto?</h4>
                <p><strong>R:</strong> Sì, ma è raro. Ad esempio, <em>f(x) = 1/√(x² + 1) + log(-x²)</em> non ha valori reali di x che soddisfano entrambe le condizioni (x² + 1 > 0 è sempre vero, ma -x² > 0 richiede x=0, che però annulla il denominatore).</p>
            </div>

<div class="wpc-card">
                <h4 class="wpc-card-title">D: Come si rappresenta l’unione di intervalli?</h4>
                <p><strong>R:</strong> Usa il simbolo “∪” (unione). Esempio: (-∞, -1) ∪ (1, ∞) significa tutti i numeri reali tranne quelli tra -1 e 1 (inclusi).</p>
            </div>

<div class="wpc-card">
                <h4 class="wpc-card-title">D: Le funzioni esponenziali hanno sempre dominio ℝ?</h4>
                <p><strong>R:</strong> Quasi sempre. L’eccezione è quando la base è una funzione di x con restrizioni. Esempio: <em>f(x) = (x-1)^x</em> richiede x-1 > 0 → x > 1.</p>
            </div>
        </article>
    </div>
</section>

// Chart instance
    let domainChart = null;

// Event listeners for dynamic form
    functionTypeSelect.addEventListener('change', function() {
        const type = this.value;

// Hide all optional groups first
        denominatorGroup.style.display = 'none';
        rootGroup.style.display = 'none';
        rootNGroup.style.display = 'none';
        logBaseGroup.style.display = 'none';

// Show relevant groups based on function type
        if (type === 'rational') {
            denominatorGroup.style.display = 'block';
        } else if (type === 'root') {
            rootGroup.style.display = 'block';
        } else if (type === 'logarithmic') {
            logBaseGroup.style.display = 'block';
        }
    });

rootIndexSelect.addEventListener('change', function() {
        rootNGroup.style.display = this.value === 'n' ? 'block' : 'none';
    });

hasVerticalAsymptotes.addEventListener('change', function() {
        asymptotesGroup.style.display = this.checked ? 'block' : 'none';
    });

hasHoles.addEventListener('change', function() {
        holesGroup.style.display = this.checked ? 'block' : 'none';
    });

// Calculate domain function
    calculateBtn.addEventListener('click', function() {
        const functionType = functionTypeSelect.value;
        if (!functionType) {
            alert('Seleziona il tipo di funzione');
            return;
        }

// Collect all restrictions
        const restrictions = {
            type: functionType,
            denominator: denominatorInput.value.trim(),
            rootIndex: rootIndexSelect.value,
            rootN: rootNInput.value.trim(),
            logBase: logBaseInput.value.trim(),
            hasVerticalAsymptotes: hasVerticalAsymptotes.checked,
            verticalAsymptotes: asymptotesInput.value.trim(),
            hasHoles: hasHoles.checked,
            holes: holesInput.value.trim(),
            hasRootRestrictions: hasRootRestrictions.checked,
            hasLogRestrictions: hasLogRestrictions.checked,
            customRestrictions: customRestrictions.value.trim()
        };

// Calculate domain
        const domainResult = calculateDomain(restrictions);

// Display results
        domainValue.textContent = domainResult.description;
        intervalValue.textContent = domainResult.intervalNotation;
        exclusionsValue.textContent = domainResult.exclusions.length > 0
            ? domainResult.exclusions.join(', ')
            : 'Nessuno';

// Show results section
        resultsDiv.classList.add('active');

// Render chart
        renderDomainChart(domainResult);
    });

// Domain calculation logic
    function calculateDomain(restrictions) {
        let domainDescription = '';
        let intervalNotation = 'ℝ';
        const exclusions = [];

// Handle different function types
        switch (restrictions.type) {
            case 'polynomial':
                domainDescription = 'Tutti i numeri reali (le funzioni polinomiali sono definite ovunque)';
                break;

case 'rational':
                domainDescription = 'Tutti i numeri reali eccetto dove il denominatore è zero';
                if (restrictions.denominator) {
                    // Simple parsing for denominator roots (this is a simplified version)
                    const denominatorRoots = parseSimpleEquation(restrictions.denominator);
                    if (denominatorRoots.length > 0) {
                        exclusions.push(...denominatorRoots);
                        intervalNotation = createIntervalNotation(denominatorRoots);
                    }
                }
                break;

case 'root':
                const rootIndex = restrictions.rootIndex === 'n' && restrictions.rootN
                    ? parseInt(restrictions.rootN)
                    : parseInt(restrictions.rootIndex);

if (rootIndex % 2 === 0) {
                    domainDescription = `Tutti i numeri reali dove il radicando ≥ 0 (radice con indice pari: ${rootIndex})`;
                    intervalNotation = '[0, ∞)'; // Simplified - would need radicand expression
                    if (restrictions.hasRootRestrictions) {
                        domainDescription += ' (con restrizioni aggiuntive dalle radici)';
                    }
                } else {
                    domainDescription = 'Tutti i numeri reali (radice con indice dispari)';
                }
                break;

case 'logarithmic':
                domainDescription = 'Tutti i numeri reali dove l\'argomento del logaritmo > 0';
                intervalNotation = '(0, ∞)'; // Simplified - would need argument expression
                break;

case 'exponential':
                domainDescription = 'Tutti i numeri reali (le funzioni esponenziali sono definite ovunque)';
                break;

case 'trigonometric':
                domainDescription = 'Tutti i numeri reali (la maggior parte delle funzioni trigonometriche sono definite ovunque)';
                // Exceptions like tan(x) would need special handling
                break;

case 'piecewise':
                domainDescription = 'Dipende dalla definizione in ciascun intervallo (analisi caso per caso richiesta)';
                break;
        }

// Handle vertical asymptotes
        if (restrictions.hasVerticalAsymptotes && restrictions.verticalAsymptotes) {
            const asymptotes = restrictions.verticalAsymptotes.split(',')
                .map(x => x.trim())
                .filter(x => x !== '');
            exclusions.push(...asymptotes);
        }

// Handle holes
        if (restrictions.hasHoles && restrictions.holes) {
            const holes = restrictions.holes.split(',')
                .map(x => x.trim())
                .filter(x => x !== '');
            exclusions.push(...holes);
        }

// Handle custom restrictions
        if (restrictions.customRestrictions) {
            const customExclusions = parseCustomRestrictions(restrictions.customRestrictions);
            exclusions.push(...customExclusions);
        }

// If we have exclusions, update the interval notation
        if (exclusions.length > 0) {
            intervalNotation = createIntervalNotation(exclusions);
        }

// Handle special cases
        if (restrictions.hasLogRestrictions) {
            domainDescription += ' con restrizioni aggiuntive per i logaritmi (argomento > 0)';
        }

return {
            description: domainDescription,
            intervalNotation: intervalNotation,
            exclusions: [...new Set(exclusions)] // Remove duplicates
        };
    }

// Helper function to parse simple equations like "x-2" or "x^2+1"
    function parseSimpleEquation(equation) {
        // This is a simplified parser - in a real app you'd use a proper math parser
        const roots = [];

// Handle simple linear case: "x-2" or "2x+3"
        if (equation.includes('x')) {
            if (equation.match(/x\s*[-+]\s*\d+/)) {
                const num = equation.match(/[-+]\s*\d+/);
                if (num) {
                    const root = -parseFloat(num[0]);
                    roots.push(root.toString());
                }
            }
            // Add more cases as needed
        }

return roots;
    }

// Helper function to parse custom restrictions like "x ≠ 0, x > 5"
    function parseCustomRestrictions(text) {
        const exclusions = [];

// Simple parsing for "x ≠ value" patterns
        const notEqualMatches = text.match(/x\s*≠\s*([-\d]+)/g);
        if (notEqualMatches) {
            notEqualMatches.forEach(match => {
                const value = match.match(/[-\d]+/)[0];
                exclusions.push(value);
            });
        }

// Could add more sophisticated parsing here

return exclusions;
    }

// Create interval notation from exclusions
    function createIntervalNotation(exclusions) {
        if (exclusions.length === 0) return 'ℝ';

// Sort exclusions numerically
        const sorted = exclusions
            .map(x => parseFloat(x))
            .filter(x => !isNaN(x))
            .sort((a, b) => a - b);

if (sorted.length === 0) return 'ℝ';

// Build interval notation
        let notation = '';
        let prev = -Infinity;

for (let i = 0; i <= sorted.length; i++) {
            const current = i < sorted.length ? sorted[i] : Infinity;

if (current !== prev) {
                if (notation !== '') notation += ' ∪ ';

if (prev === -Infinity) {
                    notation += '(-∞, ';
                } else {
                    notation += `(${prev}, `;
                }

if (current === Infinity) {
                    notation += '∞)';
                } else {
                    notation += `${current})`;
                }
            }

prev = current;
        }

return notation;
    }

// Render domain chart
    function renderDomainChart(domainResult) {
        const ctx = chartCanvas.getContext('2d');

// Destroy previous chart if it exists
        if (domainChart) {
            domainChart.destroy();
        }

// Generate data for the chart
        const exclusions = domainResult.exclusions.map(x => parseFloat(x)).filter(x => !isNaN(x));

// Create labels and data for the chart
        const labels = [];
        const data = [];

// Generate x values from -10 to 10
        for (let x = -10; x <= 10; x += 0.5) {
            labels.push(x);
            // Function value is 1 where defined, 0 where excluded
            data.push(exclusions.includes(x) ? 0 : 1);
        }

// Create the chart
        domainChart = new Chart(ctx, {
            type: 'line',
            data: {
                labels: labels,
                datasets: [{
                    label: 'Dominio della funzione',
                    data: data,
                    borderColor: '#2563eb',
                    backgroundColor: 'rgba(37, 99, 235, 0.1)',
                    borderWidth: 2,
                    tension: 0.1,
                    pointRadius: 0,
                    segment: {
                        borderDash: ctx => {
                            // Dash the line where the function is not defined
                            const index = ctx.p0DataIndex;
                            const x = parseFloat(labels[index]);
                            return exclusions.some(ex => Math.abs(ex - x) < 0.1) ? [5, 5] : [];
                        }
                    }
                }]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    x: {
                        title: {
                            display: true,
                            text: 'Valori di x',
                            color: '#334155',
                            font: {
                                weight: 'bold'
                            }
                        },
                        grid: {
                            color: '#e2e8f0'
                        }
                    },
                    y: {
                        title: {
                            display: true,
                            text: 'Definita (1) / Non definita (0)',
                            color: '#334155',
                            font: {
                                weight: 'bold'
                            }
                        },
                        min: -0.1,
                        max: 1.1,
                        ticks: {
                            stepSize: 1
                        },
                        grid: {
                            color: '#e2e8f0'
                        }
                    }
                },
                plugins: {
                    title: {
                        display: true,
                        text: `Dominio: ${domainResult.intervalNotation}`,
                        color: '#0f172a',
                        font: {
                            size: 16,
                            weight: 'bold'
                        },
                        padding: {
                            top: 10,
                            bottom: 20
                        }
                    },
                    legend: {
                        position: 'top',
                        labels: {
                            color: '#334155'
                        }
                    },
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                const x = labels[context.dataIndex];
                                const isExcluded = exclusions.some(ex => Math.abs(ex - x) < 0.1);
                                return isExcluded ? `x = ${x}: Non definita` : `x = ${x}: Definita`;
                            }
                        }
                    }
                },
                elements: {
                    line: {
                        borderJoinStyle: 'round'
                    }
                }
            }
        });
    }

// Initialize chart with empty data
    const ctx = chartCanvas.getContext('2d');
    domainChart = new Chart(ctx, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: 'Dominio della funzione',
                data: [],
                borderColor: '#2563eb',
                backgroundColor: 'rgba(37, 99, 235, 0.1)',
                borderWidth: 2
            }]
        },
        options: {
            responsive: true,
            maintainAspectRatio: false,
            plugins: {
                title: {
                    display: true,
                    text: 'Calcola il dominio per visualizzare il grafico',
                    color: '#64748b',
                    font: {
                        size: 14,
                        style: 'italic'
                    }
                }
            }
        }
    });
});
</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-dominio-funzione-dal-grafico/#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">