Definitionsbereich Bestimmen Rechner

Berechnen Sie den Definitionsbereich (Domain) einer Funktion mit diesem präzisen mathematischen Werkzeug

Mathematische Funktion (f(x)) Verwenden Sie Standardnotation: + – * / ^ (für Potenzen), sqrt(), log(), sin(), cos(), tan()

Funktionstyp

Polynom

Rationale Funktion

Wurzelausdruck

Logarithmus

Manuelle Einschränkungen (optional)

<label for="wpc-precision" class="wpc-label">Genauigkeit</label>
                <select id="wpc-precision" class="wpc-select">
                    <option value="2">2 Dezimalstellen</option>
                    <option value="4" selected>4 Dezimalstellen</option>
                    <option value="6">6 Dezimalstellen</option>
                    <option value="8">8 Dezimalstellen</option>
                </select>
            </div>

<button type="submit" class="wpc-button">Definitionsbereich Berechnen</button>
        </form>

<div id="wpc-results" class="wpc-results">
            <h2 class="wpc-result-title">Ergebnisse</h2>
            <div id="wpc-domain-result" class="wpc-result-item">
                <span class="wpc-result-label">Definitionsbereich:</span>
                <span id="wpc-domain-value" class="wpc-result-value"></span>
            </div>
            <div id="wpc-exclusions" class="wpc-result-item">
                <span class="wpc-result-label">Ausgeschlossene Werte:</span>
                <span id="wpc-exclusions-value" class="wpc-result-value"></span>
            </div>
            <div id="wpc-intervals" class="wpc-result-item">
                <span class="wpc-result-label">Intervallnotation:</span>
                <span id="wpc-intervals-value" class="wpc-result-value"></span>
            </div>
            <div class="wpc-chart-container">
                <canvas id="wpc-chart"></canvas>
            </div>
        </div>
    </div>

<article class="wpc-content">
        <h2>Umfassender Leitfaden: Definitionsbereich Bestimmen</h2>

<p>Der Definitionsbereich (auch Domain genannt) einer Funktion gibt an, welche Werte die unabhängige Variable (meist x) annehmen darf. Die korrekte Bestimmung des Definitionsbereichs ist grundlegend für die Analysis und wird in vielen mathematischen Anwendungen benötigt.</p>

<h3>1. Grundlagen des Definitionsbereichs</h3>
        <p>Der Definitionsbereich D einer Funktion f ist die Menge aller x-Werte, für die f(x) definiert ist. Mathematisch ausgedrückt:</p>
        <p style="text-align: center; font-style: italic;">D = {x ∈ ℝ | f(x) ist definiert}</p>

<h3>2. Methoden zur Bestimmung des Definitionsbereichs</h3>

<h4>2.1 Polynomfunktionen</h4>
        <p>Polynome sind überall definiert. Für eine Funktion der Form:</p>
        <p style="text-align: center;">f(x) = aₙxⁿ + aₙ₋₁xⁿ⁻¹ + … + a₁x + a₀</p>
        <p>gilt immer: D = ℝ (alle reellen Zahlen)</p>

<h4>2.2 Rationale Funktionen</h4>
        <p>Bei Bruchfunktionen müssen Nenner ungleich Null sein. Für:</p>
        <p style="text-align: center;">f(x) = P(x)/Q(x)</p>
        <p>ist D = ℝ \ {x | Q(x) = 0}</p>

<div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Funktionstyp</th>
                        <th>Definitionsbereich</th>
                        <th>Beispiel</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Polynom</td>
                        <td>ℝ (alle reellen Zahlen)</td>
                        <td>f(x) = x² + 3x – 2</td>
                    </tr>
                    <tr>
                        <td>Rationale Funktion</td>
                        <td>ℝ \ {Nullstellen des Nenners}</td>
                        <td>f(x) = 1/(x-2) → D = ℝ \ {2}</td>
                    </tr>
                    <tr>
                        <td>Wurzel (gerade)</td>
                        <td>Radikand ≥ 0</td>
                        <td>f(x) = √(x-3) → D = [3, ∞)</td>
                    </tr>
                    <tr>
                        <td>Logarithmus</td>
                        <td>Argument > 0</td>
                        <td>f(x) = log(x+1) → D = (-1, ∞)</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h4>2.3 Wurzelfunktionen</h4>
        <p>Für gerade Wurzeln (√, ⁴√ etc.) muss der Radikand nicht-negativ sein:</p>
        <p style="text-align: center;">√(g(x)) → g(x) ≥ 0</p>
        <p>Für ungerade Wurzeln (³√) gilt: D = ℝ</p>

<h4>2.4 Logarithmusfunktionen</h4>
        <p>Das Argument muss positiv sein:</p>
        <p style="text-align: center;">logₐ(g(x)) → g(x) > 0</p>

<h3>3. Schritt-für-Schritt Anleitung</h3>
        <ol>
            <li><strong>Funktion analysieren:</strong> Identifizieren Sie den Funktionstyp (Polynom, rational, Wurzel etc.)</li>
            <li><strong>Einschränkungen finden:</strong>
                <ul>
                    <li>Nenner ≠ 0 bei Bruchfunktionen</li>
                    <li>Radikand ≥ 0 bei geraden Wurzeln</li>
                    <li>Argument > 0 bei Logarithmen</li>
                </ul>
            </li>
            <li><strong>Gleichungen lösen:</strong> Bestimmen Sie die Werte, die ausgeschlossen werden müssen</li>
            <li><strong>Intervallnotation:</strong> Geben Sie den Definitionsbereich in Intervallschreibweise an</li>
            <li><strong>Graphische Darstellung:</strong> Visualisieren Sie den Definitionsbereich (wie in unserem Rechner)</li>
        </ol>

<h3>4. Häufige Fehler und Fallstricke</h3>
        <ul>
            <li><span class="wpc-highlight">Vergessen von Nennerbedingungen:</span> Bei f(x) = 1/(x²-4) werden oft nur x=2 aber nicht x=-2 ausgeschlossen</li>
            <li><span class="wpc-highlight">Wurzelbedingungen:</span> √(x²-5x+6) erfordert x²-5x+6 ≥ 0, nicht nur x ≥ 0</li>
            <li><span class="wpc-highlight">Logarithmusargument:</span> log(x²-1) erfordert x²-1 > 0 → x < -1 oder x > 1</li>
            <li><span class="wpc-highlight">Mehrere Bedingungen:</span> Bei kombinierten Funktionen müssen alle Bedingungen gleichzeitig erfüllt sein</li>
        </ul>

<h3>5. Praktische Anwendungsbeispiele</h3>

<div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Funktion</th>
                        <th>Definitionsbereich</th>
                        <th>Lösungsweg</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>f(x) = (x+3)/(x²-9)</td>
                        <td>ℝ \ {-3, 3}</td>
                        <td>Nenner x²-9 = 0 → x = ±3</td>
                    </tr>
                    <tr>
                        <td>f(x) = √(16-x²)</td>
                        <td>[-4, 4]</td>
                        <td>16-x² ≥ 0 → x² ≤ 16 → -4 ≤ x ≤ 4</td>
                    </tr>
                    <tr>
                        <td>f(x) = log(2x-6) + 1/√(x-4)</td>
                        <td>(4, ∞)</td>
                        <td>
                            <ol style="margin: 0; padding-left: 1rem;">
                                <li>2x-6 > 0 → x > 3</li>
                                <li>x-4 > 0 → x > 4</li>
                                <li>Schnittmenge: x > 4</li>
                            </ol>
                        </td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>6. Wissenschaftliche Grundlagen</h3>
        <p>Die Theorie der Definitionsbereiche basiert auf fundamentalen mathematischen Konzepten:</p>
        <ul>
            <li><strong>Funktionsbegriff:</strong> Nach Dirichlet (1837) ist eine Funktion eine Zuordnung, die jedem Element einer Definitionsmenge genau ein Element einer Zielmenge zuweist</li>
            <li><strong>Reelle Analysis:</strong> Die Eigenschaften reeller Funktionen werden in der Analysis systematisch untersucht (Rudin, 1976)</li>
            <li><strong>Algebraische Strukturen:</strong> Polynome und rationale Funktionen werden in der abstrakten Algebra behandelt (van der Waerden, 1930)</li>
        </ul>

<h3>7. Weiterführende Ressourcen</h3>
        <p>Für vertiefende Informationen empfehlen wir diese autoritativen Quellen:</p>
        <ul>
            <li><a href="https://www.math.ucdavis.edu/~kouba/CalcOneDIRECTORY/precalcdirectory/PiecewiseFunction.html" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">University of California, Davis – Domain of Piecewise Functions</a></li>
            <li><a href="https://mathworld.wolfram.com/FunctionDomain.html" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">Wolfram MathWorld – Function Domain</a></li>
            <li><a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication811.pdf" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST Guide to Mathematical Functions (PDF)</a></li>
        </ul>

<h3>8. Häufig gestellte Fragen</h3>

<h4>8.1 Warum ist der Definitionsbereich wichtig?</h4>
        <p>Der Definitionsbereich ist essenziell weil:</p>
        <ol>
            <li>Er die Gültigkeit mathematischer Operationen sicherstellt</li>
            <li>Er die Grundlage für Funktionsgraphen bildet</li>
            <li>Er in Anwendungen (z.B. Physik, Wirtschaft) realistische Eingabewerte definiert</li>
            <li>Er für die korrekte Interpretation von Funktionswerten notwendig ist</li>
        </ol>

<h4>8.2 Wie gibt man den Definitionsbereich an?</h4>
        <p>Es gibt drei gängige Notationen:</p>
        <ol>
            <li><strong>Mengennotation:</strong> D = {x ∈ ℝ | -2 ≤ x < 5}</li>
            <li><strong>Intervallnotation:</strong> D = [-2, 5)</li>
            <li><strong>Ungleichungen:</strong> -2 ≤ x < 5</li>
        </ol>

<h4>8.3 Was ist der Unterschied zwischen Definitionsbereich und Wertebereich?</h4>
        <p>
            <table style="width: 100%; margin: 1rem 0;">
                <thead>
                    <tr>
                        <th style="background-color: #2563eb; color: white; padding: 0.5rem; text-align: left;">Definitionsbereich</th>
                        <th style="background-color: #2563eb; color: white; padding: 0.5rem; text-align: left;">Wertebereich</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td style="padding: 0.5rem; border-bottom: 1px solid #e2e8f0;">Alle möglichen x-Werte (Eingaben)</td>
                        <td style="padding: 0.5rem; border-bottom: 1px solid #e2e8f0;">Alle möglichen f(x)-Werte (Ausgaben)</td>
                    </tr>
                    <tr>
                        <td style="padding: 0.5rem; border-bottom: 1px solid #e2e8f0;">Wird oft mit D bezeichnet</td>
                        <td style="padding: 0.5rem; border-bottom: 1px solid #e2e8f0;">Wird oft mit W oder R(f) bezeichnet</td>
                    </tr>
                    <tr>
                        <td style="padding: 0.5rem;">Bestimmt durch Funktionseigenschaften</td>
                        <td style="padding: 0.5rem;">Abhängig von Definitionsbereich und Funktionstyp</td>
                    </tr>
                </tbody>
            </table>
        </p>

<h4>8.4 Kann eine Funktion mehrere Definitionsbereiche haben?</h4>
        <p>Nein, eine Funktion hat genau einen Definitionsbereich. Allerdings kann man:</p>
        <ul>
            <li>Funktionen auf verschiedene Definitionsbereiche <strong>einschränken</strong></li>
            <li>Piecewise-Funktionen definieren, die auf verschiedenen Intervallen unterschiedliche Ausdrücke haben</li>
            <li>Funktionen mit Löchern (hebbare Definitionslücken) betrachten</li>
        </ul>

<h3>9. Fortgeschrittene Themen</h3>

<h4>9.1 Definitionsbereich in mehreren Variablen</h4>
        <p>Für Funktionen f(x,y) ist der Definitionsbereich eine Teilmenge von ℝ². Beispiel:</p>
        <p style="text-align: center;">f(x,y) = ln(xy – x²) → D = {(x,y) | xy – x² > 0}</p>

<h4>9.2 Komplexe Funktionen</h4>
        <p>In der komplexen Analysis (Funktionentheorie) sind Definitionsbereiche oft offen und zusammenhängend. Beispiel:</p>
        <p style="text-align: center;">f(z) = 1/(z² + 1) ist definiert für z ∈ ℂ \ {±i}</p>

<h4>9.3 Verallgemeinerte Funktionen</h4>
        <p>In der Distributionentheorie (z.B. Dirac-Delta) werden Definitionsbereiche auf Testfunktionsräume erweitert.</p>

<h3>10. Zusammenfassung und Ausblick</h3>
        <p>Die Bestimmung des Definitionsbereichs ist eine fundamentale Fähigkeit in der Mathematik mit weitreichenden Anwendungen. Dieser Rechner hilft Ihnen, schnell und präzise den Definitionsbereich verschiedener Funktionstypen zu bestimmen. Für komplexere Funktionen (z.B. mit mehreren Variablen oder speziellen Bedingungen) empfehlen wir den Einsatz von Computeralgebrasystemen wie Mathematica oder Maple.</p>
        <p>Mit Übung werden Sie in der Lage sein, Definitionsbereiche auch für komplizierte Funktionen mental zu bestimmen – eine wertvolle Fähigkeit für Studium und Beruf.</p>
    </article>
</section>

let domainChart = null;

calculatorForm.addEventListener('submit', function(e) {
        e.preventDefault();
        calculateDomain();
    });

function calculateDomain() {
        const functionInput = document.getElementById('wpc-function-input').value.trim();
        const functionType = document.querySelector('input[name="wpc-function-type"]:checked').value;
        const restrictions = document.getElementById('wpc-domain-restrictions').value.trim();
        const precision = parseInt(document.getElementById('wpc-precision').value);

try {
            // Parse the function using math.js
            const node = math.parse(functionInput);
            const compiled = node.compile();

// Determine domain based on function type
            let domainInfo = determineDomain(functionInput, functionType, restrictions);

// Format results
            domainValue.textContent = domainInfo.domainDescription;
            exclusionsValue.textContent = domainInfo.exclusions.length > 0
                ? domainInfo.exclusions.join(', ')
                : 'Keine';
            intervalsValue.textContent = domainInfo.intervalNotation;

// Show results
            resultsDiv.style.display = 'block';

// Create chart
            createDomainChart(domainInfo);

// Scroll to results
            resultsDiv.scrollIntoView({ behavior: 'smooth' });

} catch (error) {
            alert('Fehler bei der Berechnung: ' + error.message);
            console.error(error);
        }
    }

function determineDomain(functionStr, functionType, restrictions) {
        let domain = { allReal: true, exclusions: [], inequalities: [] };
        let intervalNotation = '(-∞, ∞)';
        let domainDescription = 'Alle reellen Zahlen (ℝ)';

// Process based on function type
        switch(functionType) {
            case 'polynomial':
                domainDescription = 'Alle reellen Zahlen (ℝ) - Polynome sind überall definiert';
                break;

case 'rational':
                // Find denominator and set to zero
                const denominatorMatch = functionStr.match(/\/$([^)]+)$/);
                if (denominatorMatch) {
                    const denominator = denominatorMatch[1];
                    try {
                        const denNode = math.parse(denominator);
                        const denCompiled = denNode.compile();

// Find roots of denominator (simplified approach)
                        // Note: This is a simplified version - real implementation would need proper equation solving
                        const roots = findSimpleRoots(denominator);
                        domain.exclusions = roots;
                        domain.allReal = roots.length === 0;

if (roots.length > 0) {
                            domainDescription = `Alle reellen Zahlen außer x = ${roots.join(', ')}`;
                            intervalNotation = createIntervalNotationFromExclusions(roots);
                        }
                    } catch (e) {
                        console.error('Error processing denominator:', e);
                    }
                }
                break;

case 'root':
                // Find expression inside root and ensure it's non-negative
                const rootMatch = functionStr.match(/sqrt$([^)]+)$/i);
                if (rootMatch) {
                    const radicand = rootMatch[1];
                    domain.inequalities.push(radicand + ' ≥ 0');
                    domain.allReal = false;

try {
                        // Solve inequality (simplified)
                        const solution = solveSimpleInequality(radicand + '>=0');
                        domainDescription = `Alle x für die ${radicand} ≥ 0 (${solution})`;
                        intervalNotation = solution;
                    } catch (e) {
                        console.error('Error solving root inequality:', e);
                        domainDescription = `Alle x für die ${radicand} ≥ 0`;
                        intervalNotation = 'Abhängig von der Lösung der Ungleichung';
                    }
                }
                break;

case 'logarithm':
                // Find argument of logarithm and ensure it's positive
                const logMatch = functionStr.match(/log$([^)]+)$/i);
                if (logMatch) {
                    const argument = logMatch[1];
                    domain.inequalities.push(argument + ' > 0');
                    domain.allReal = false;

try {
                        // Solve inequality (simplified)
                        const solution = solveSimpleInequality(argument + '>0');
                        domainDescription = `Alle x für die ${argument} > 0 (${solution})`;
                        intervalNotation = solution;
                    } catch (e) {
                        console.error('Error solving log inequality:', e);
                        domainDescription = `Alle x für die ${argument} > 0`;
                        intervalNotation = 'Abhängig von der Lösung der Ungleichung';
                    }
                }
                break;
        }

// Process manual restrictions
        if (restrictions) {
            const restrictionParts = restrictions.split(',');
            for (const part of restrictionParts) {
                const trimmed = part.trim();
                if (trimmed.startsWith('x ≠')) {
                    const value = trimmed.replace('x ≠', '').trim();
                    if (!domain.exclusions.includes(value)) {
                        domain.exclusions.push(value);
                    }
                } else if (trimmed.includes('>') || trimmed.includes('<') || trimmed.includes('≥') || trimmed.includes('≤')) {
                    domain.inequalities.push(trimmed);
                }
            }

// Update descriptions if restrictions were added
            if (domain.exclusions.length > 0) {
                domainDescription += domainDescription.includes('außer')
                    ? ', ' + domain.exclusions.join(', ')
                    : ' außer x = ' + domain.exclusions.join(', ');
            }

if (domain.inequalities.length > 0) {
                domainDescription += ' mit zusätzlichen Bedingungen: ' + domain.inequalities.join(', ');
            }
        }

// Finalize interval notation if we have exclusions
        if (domain.exclusions.length > 0 && domain.allReal) {
            intervalNotation = createIntervalNotationFromExclusions(domain.exclusions);
        }

return {
            domainDescription: domainDescription,
            exclusions: domain.exclusions,
            intervalNotation: intervalNotation,
            inequalities: domain.inequalities,
            allReal: domain.allReal
        };
    }

function findSimpleRoots(expression) {
        // Very simplified root finding - in a real app you'd use proper equation solving
        // This just looks for simple linear factors like (x-a)
        const rootPattern = /$x\s*([+-]\s*\d+)$/g;
        const roots = [];
        let match;

while ((match = rootPattern.exec(expression)) !== null) {
            const root = match[1].replace(/\s+/g, '');
            if (!roots.includes(root)) {
                roots.push(root);
            }
        }

return roots.length > 0 ? roots : ['(konnte nicht bestimmt werden)'];
    }

function solveSimpleInequality(inequality) {
        // Very simplified inequality solving
        // In a real implementation, you'd use a proper computer algebra system

// Handle simple linear inequalities like "x + a > b"
        const linearMatch = inequality.match(/([^-+]+)\s*([<>]=?)\s*([^-+]+)/);
        if (linearMatch) {
            const left = linearMatch[1].trim();
            const op = linearMatch[2].trim();
            const right = linearMatch[3].trim();

if (left === 'x') {
                return op === '>=' ? `[${right}, ∞)` :
                       op === '<=' ? `(-∞, ${right}]` :
                       op === '>' ? `(${right}, ∞)` :
                       `(-∞, ${right})`;
            } else if (left.endsWith('x')) {
                // Simple case like "2x > 4" -> "x > 2"
                const coeff = left.replace('x', '').trim() || '1';
                const numRight = parseFloat(right);
                const numCoeff = parseFloat(coeff);

if (!isNaN(numRight) && !isNaN(numCoeff) && numCoeff !== 0) {
                    const solutionValue = numRight / numCoeff;
                    return op === '>=' ? `[${solutionValue}, ∞)` :
                           op === '<=' ? `(-∞, ${solutionValue}]` :
                           op === '>' ? `(${solutionValue}, ∞)` :
                           `(-∞, ${solutionValue})`;
                }
            }
        }

// Handle quadratic inequalities like "x^2 - a > 0"
        const quadraticMatch = inequality.match(/x\^2\s*([+-]\s*\d+)\s*([<>]=?)\s*(\d+)/);
        if (quadraticMatch) {
            const b = quadraticMatch[1].replace(/\s+/g, '');
            const op = quadraticMatch[2].trim();
            const c = quadraticMatch[3];

const numB = parseFloat(b) || 0;
            const numC = parseFloat(c) || 0;

// Solve x^2 + bx + c > 0 (simplified)
            const discriminant = numB*numB - 4*numC;
            if (discriminant > 0) {
                const root1 = (-numB - Math.sqrt(discriminant))/2;
                const root2 = (-numB + Math.sqrt(discriminant))/2;
                if (op === '>=' || op === '>') {
                    return `(-∞, ${root1}] ∪ [${root2}, ∞)`;
                } else {
                    return `[${root1}, ${root2}]`;
                }
            }
        }

// Default response for complex cases
        return 'Lösung der Ungleichung ' + inequality;
    }

function createIntervalNotationFromExclusions(exclusions) {
        if (exclusions.length === 0) return '(-∞, ∞)';

// Sort exclusions numerically
        const numericExclusions = exclusions
            .map(ex => {
                const num = parseFloat(ex);
                return isNaN(num) ? null : num;
            })
            .filter(ex => ex !== null)
            .sort((a, b) => a - b);

if (numericExclusions.length === 0) return '(-∞, ∞)';

// Create intervals between exclusions
        let intervals = [];
        let prev = -Infinity;

for (const ex of numericExclusions) {
            intervals.push(`(${prev}, ${ex})`);
            prev = ex;
        }

intervals.push(`(${prev}, ∞)`);

return intervals.join(' ∪ ');
    }

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

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

// Create data for visualization
        const labels = [];
        const data = [];

// Generate x values from -10 to 10
        for (let x = -10; x <= 10; x += 0.5) {
            labels.push(x.toFixed(1));
            data.push(1); // Default value
        }

// Mark excluded points
        const excludedIndices = [];
        domainInfo.exclusions.forEach(ex => {
            const numEx = parseFloat(ex);
            if (!isNaN(numEx)) {
                const index = Math.round((numEx + 10) * 2);
                if (index >= 0 && index < labels.length) {
                    excludedIndices.push(index);
                    data[index] = 0; // Mark as excluded
                }
            }
        });

// Create dataset
        const dataset = {
            label: 'Definitionsbereich (1 = definiert, 0 = undefiniert)',
            data: data,
            backgroundColor: labels.map((_, i) =>
                excludedIndices.includes(i) ? '#ef4444' : '#2563eb'
            ),
            borderWidth: 1
        };

// Create chart
        domainChart = new Chart(ctx, {
            type: 'bar',
            data: {
                labels: labels,
                datasets: [dataset]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    x: {
                        title: {
                            display: true,
                            text: 'x-Werte'
                        }
                    },
                    y: {
                        beginAtZero: true,
                        max: 1,
                        ticks: {
                            stepSize: 1,
                            callback: function(value) {
                                return value === 1 ? 'Definiert' : 'Undefiniert';
                            }
                        },
                        title: {
                            display: true,
                            text: 'Definitionsstatus'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    },
                    title: {
                        display: true,
                        text: 'Visualisierung des Definitionsbereichs',
                        font: {
                            size: 16
                        }
                    },
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                return context.raw === 1
                                    ? 'Funktion definiert bei x = ' + context.label
                                    : 'Funktion UNDFINIERT bei x = ' + context.label;
                            }
                        }
                    }
                }
            }
        });
    }

// Initialize math.js with required functions
    math.import({
        'import':     function () { throw new Error('Function import is disabled') },
        'createUnit': function () { throw new Error('Function createUnit is disabled') },
        'parse':      math.parse,
        'evaluate':   math.evaluate,
        'derivative': function () { throw new Error('Function derivative is disabled') },
        'simplify':   function () { throw new Error('Function simplify is disabled') }
    }, {override: true});
});
</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="/definitionsbereich-bestimmen-rechner/#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">