Definitionsbereich Funktionen Rechner

Berechnen Sie den Definitionsbereich (Domäne) mathematischer Funktionen mit diesem präzisen Online-Tool

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

Funktionstyp

Polynomfunktion

Rationale Funktion

Wurzel-/Radikalfunktion

Logarithmusfunktion

Manuelle Einschränkungen (optional)

<label for="wpc-precision" class="wpc-label">Genauigkeit der Berechnung</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-calculate-btn">Definitionsbereich berechnen</button>
        </form>

<div id="wpc-results" class="wpc-results">
            <h3 class="wpc-results-title">Ergebnisse der Berechnung</h3>
            <div id="wpc-result-domain" class="wpc-result-item">
                <span class="wpc-result-label">Definitionsbereich:</span>
                <span class="wpc-result-value" id="wpc-domain-output"></span>
            </div>
            <div id="wpc-result-interval" class="wpc-result-item">
                <span class="wpc-result-label">Intervallnotation:</span>
                <span class="wpc-result-value" id="wpc-interval-output"></span>
            </div>
            <div id="wpc-result-exclusions" class="wpc-result-item">
                <span class="wpc-result-label">Ausgeschlossene Werte:</span>
                <span class="wpc-result-value" id="wpc-exclusions-output"></span>
            </div>
            <div id="wpc-result-warnings" class="wpc-result-item" style="color: #991b1b; display: none;">
                <span class="wpc-result-label">Hinweise:</span>
                <span class="wpc-result-value" id="wpc-warnings-output"></span>
            </div>
        </div>

<article class="wpc-content">
        <h2>Umfassender Leitfaden: Definitionsbereich von Funktionen berechnen</h2>

<p>Der Definitionsbereich (auch Domäne genannt) einer Funktion gibt an, für welche Input-Werte (x-Werte) die Funktion definiert ist. Die Bestimmung des Definitionsbereichs ist ein fundamentaler Schritt in der Analysis und hat praktische Anwendungen in Ingenieurwissenschaften, Wirtschaft und Naturwissenschaften.</p>

<h3>1. Grundlagen des Definitionsbereichs</h3>

<p>Der Definitionsbereich einer Funktion f(x) besteht aus allen reellen Zahlen x, für die f(x) definiert ist. Für verschiedene Funktionstypen gelten unterschiedliche Regeln:</p>

<ul>
            <li><strong>Polynomfunktionen</strong>: Immer definiert für alle reellen Zahlen (ℝ)</li>
            <li><strong>Rationale Funktionen</strong>: Definiert für alle x außer wo der Nenner null wird</li>
            <li><strong>Wurzel-/Radikalfunktionen</strong>: Definiert wenn der Radikand ≥ 0 (bei geraden Wurzeln)</li>
            <li><strong>Logarithmusfunktionen</strong>: Definiert wenn das Argument > 0</li>
            <li><strong>Trigonometrische Funktionen</strong>: Sinus und Kosinus immer definiert; Tangens undefined wo cos(x) = 0</li>
        </ul>

<h3>2. Schritt-für-Schritt Anleitung zur Bestimmung des Definitionsbereichs</h3>

<ol>
            <li><strong>Funktionstyp identifizieren</strong>: Bestimmen Sie, zu welcher Kategorie die Funktion gehört (Polynom, rational, Wurzel etc.)</li>
            <li><strong>Einschränkungen analysieren</strong>:
                <ul>
                    <li>Nenner ≠ 0 bei rationalen Funktionen</li>
                    <li>Radikand ≥ 0 bei Wurzelfunktionen mit geradem Exponenten</li>
                    <li>Argument > 0 bei Logarithmusfunktionen</li>
                </ul>
            </li>
            <li><strong>Gleichungen lösen</strong>: Lösen Sie die Gleichungen, die sich aus den Einschränkungen ergeben</li>
            <li><strong>Intervallnotation erstellen</strong>: Drücken Sie den Definitionsbereich in Intervallnotation aus</li>
            <li><strong>Graphische Verifikation</strong>: Zeichnen Sie die Funktion, um den Definitionsbereich visuell zu bestätigen</li>
        </ol>

<h3>3. Häufige Fehler und wie man sie vermeidet</h3>

<p>Bei der Bestimmung des Definitionsbereichs kommen häufig folgende Fehler vor:</p>

<table>
            <thead>
                <tr>
                    <th>Fehler</th>
                    <th>Korrekte Vorgehensweise</th>
                    <th>Beispiel</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Vergessen, Nenner auf Null zu prüfen</td>
                    <td>Immer Nenner ≠ 0 sicherstellen</td>
                    <td>f(x) = 1/(x-2) → x ≠ 2</td>
                </tr>
                <tr>
                    <td>Falsche Annahme, dass alle Wurzeln Einschränkungen haben</td>
                    <td>Nur gerade Wurzeln (√, ∜ etc.) benötigen nicht-negative Radikanden</td>
                    <td>f(x) = ∛x definiert für alle ℝ</td>
                </tr>
                <tr>
                    <td>Logarithmus-Argument nicht auf Positivität prüfen</td>
                    <td>Argument muss strikt > 0 sein</td>
                    <td>f(x) = log(x+3) → x > -3</td>
                </tr>
                <tr>
                    <td>Vergessen von impliziten Einschränkungen</td>
                    <td>Komplexe Funktionen können versteckte Einschränkungen haben</td>
                    <td>f(x) = 1/(1+1/(1+x)) → x ≠ -1 und x ≠ 0</td>
                </tr>
            </tbody>
        </table>

<h3>4. Praktische Anwendungen des Definitionsbereichs</h3>

<p>Die Bestimmung des Definitionsbereichs hat wichtige praktische Anwendungen:</p>

<ul>
            <li><strong>Ingenieurwesen</strong>: Bei der Modellierung physikalischer Systeme müssen Definitionsbereiche berücksichtigt werden, um realistische Lösungen zu garantieren. Beispiel: Bei der Berechnung von Spannungen in Materialien dürfen bestimmte Werte nicht überschritten werden.</li>
            <li><strong>Wirtschaftswissenschaften</strong>: In Kosten-Nutzen-Analysen müssen Definitionsbereiche von Produktionsfunktionen beachtet werden, um realistische Szenarien zu modellieren.</li>
            <li><strong>Medizinische Forschung</strong>: Bei der Modellierung von Dosis-Wirkungs-Beziehungen müssen Definitionsbereiche berücksichtigt werden, um toxische Dosen auszuschließen.</li>
            <li><strong>Informatik</strong>: In Algorithmen müssen Definitionsbereiche von Funktionen geprüft werden, um Laufzeitfehler zu vermeiden.</li>
        </ul>

<h3>5. Vergleich von Funktionen und ihren Definitionsbereichen</h3>

<p>Die folgende Tabelle zeigt einen Vergleich verschiedener Funktionstypen mit ihren typischen Definitionsbereichen:</p>

<table>
            <thead>
                <tr>
                    <th>Funktionstyp</th>
                    <th>Allgemeine Form</th>
                    <th>Typischer Definitionsbereich</th>
                    <th>Beispiel</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Polynomfunktion</td>
                    <td>f(x) = aₙxⁿ + … + a₀</td>
                    <td>Alle reellen Zahlen (ℝ)</td>
                    <td>f(x) = 3x⁴ – 2x² + 1</td>
                </tr>
                <tr>
                    <td>Rationale Funktion</td>
                    <td>f(x) = P(x)/Q(x)</td>
                    <td>ℝ außer Nullstellen von Q(x)</td>
                    <td>f(x) = (x²-1)/(x-2) → x ≠ 2</td>
                </tr>
                <tr>
                    <td>Wurzelfunktion (gerade)</td>
                    <td>f(x) = √(g(x))</td>
                    <td>g(x) ≥ 0</td>
                    <td>f(x) = √(x²-4) → x ≤ -2 oder x ≥ 2</td>
                </tr>
                <tr>
                    <td>Logarithmusfunktion</td>
                    <td>f(x) = logₐ(g(x))</td>
                    <td>g(x) > 0</td>
                    <td>f(x) = ln(x+5) → x > -5</td>
                </tr>
                <tr>
                    <td>Trigonometrische Funktion</td>
                    <td>f(x) = sin(x), cos(x), tan(x)</td>
                    <td>sin, cos: ℝ; tan: x ≠ (π/2)+kπ</td>
                    <td>f(x) = tan(x) → x ≠ π/2, 3π/2, …</td>
                </tr>
            </tbody>
        </table>

<h3>6. Fortgeschrittene Techniken</h3>

<p>Für komplexere Funktionen sind erweiterte Techniken erforderlich:</p>

<ul>
            <li><strong>Zusammengesetzte Funktionen</strong>: Bestimmen Sie zunächst die Definitionsbereiche der Teilfunktionen und finden Sie dann die Schnittmenge.</li>
            <li><strong>Implizite Funktionen</strong>: Verwenden Sie algebraische Manipulation, um Einschränkungen zu identifizieren.</li>
            <li><strong>Stückweise Funktionen</strong>: Bestimmen Sie den Definitionsbereich für jedes Segment separat.</li>
            <li><strong>Mehrvariable Funktionen</strong>: Betrachten Sie Einschränkungen für jede Variable.</li>
        </ul>

<h3>7. Tools und Ressourcen</h3>

<p>Für die praktische Arbeit mit Definitionsbereichen stehen verschiedene Tools zur Verfügung:</p>

<ul>
            <li><strong>Symbolische Mathematik-Software</strong>:
                <ul>
                    <li>Wolfram Alpha (<a href="https://www.wolframalpha.com/" class="wpc-authority-link" target="_blank" rel="noopener">www.wolframalpha.com</a>) – Kann Definitionsbereiche komplexer Funktionen berechnen</li>
                    <li>Mathematica – Professionelle Software für symbolische Mathematik</li>
                    <li>Maple – Umfassendes Computeralgebra-System</li>
                </ul>
            </li>
            <li><strong>Online-Rechner</strong>:
                <ul>
                    <li>Symbolab (<a href="https://www.symbolab.com/" class="wpc-authority-link" target="_blank" rel="noopener">www.symbolab.com</a>) – Bietet Schritt-für-Schritt-Lösungen</li>
                    <li>Desmos (<a href="https://www.desmos.com/calculator" class="wpc-authority-link" target="_blank" rel="noopener">www.desmos.com/calculator</a>) – Visualisierung von Funktionen und ihren Definitionsbereichen</li>
                </ul>
            </li>
            <li><strong>Lernressourcen</strong>:
                <ul>
                    <li>Khan Academy – Kostenlose Lektionen zu Definitionsbereichen (<a href="https://www.khanacademy.org/" class="wpc-authority-link" target="_blank" rel="noopener">www.khanacademy.org</a>)</li>
                    <li>MIT OpenCourseWare – Fortgeschrittene Mathematik-Kurse (<a href="https://ocw.mit.edu/" class="wpc-authority-link" target="_blank" rel="noopener">ocw.mit.edu</a>)</li>
                </ul>
            </li>
        </ul>

<h3>8. Wissenschaftliche Grundlagen</h3>

<p>Die theoretischen Grundlagen für Definitionsbereiche finden sich in der Mengenlehre und Analysis:</p>

<ul>
            <li><strong>Mengenlehre</strong>: Der Definitionsbereich ist eine Teilmenge der reellen Zahlen (oder komplexen Zahlen für komplexe Funktionen).</li>
            <li><strong>Funktionstheorie</strong>: Eine Funktion ist eine Relation, die jedem Element des Definitionsbereichs genau ein Element des Wertebereichs zuordnet.</li>
            <li><strong>Topologie</strong>: Offene und abgeschlossene Intervalle spielen eine Rolle bei der Beschreibung von Definitionsbereichen.</li>
        </ul>

<p>Für vertiefende Informationen zu den mathematischen Grundlagen empfehlen wir die Lektüre von:</p>

<ul>
            <li>“Introduction to Real Analysis” von Robert G. Bartle und Donald R. Sherbert</li>
            <li>“Principles of Mathematical Analysis” von Walter Rudin</li>
            <li>“Naive Set Theory” von Paul R. Halmos für die mengentheoretischen Grundlagen</li>
        </ul>

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

<p><strong>Frage:</strong> Warum ist der Definitionsbereich wichtig?</p>
        <p><strong>Antwort:</strong> Der Definitionsbereich ist wichtig, weil er angibt, für welche Eingabewerte eine Funktion gültige Ausgabewerte produziert. Ohne die Berücksichtigung des Definitionsbereichs können Berechnungen zu undefinierten Ergebnissen oder Fehlern führen. In praktischen Anwendungen hilft der Definitionsbereich, realistische Grenzen für Modelle zu setzen.</p>

<p><strong>Frage:</strong> Wie gebe ich den Definitionsbereich in Intervallnotation an?</p>
        <p><strong>Antwort:</strong> Die Intervallnotation verwendet Klammern und eckige Klammern, um Intervalle darzustellen:
        <ul>
            <li>(a, b) – Offenes Intervall (a und b nicht eingeschlossen)</li>
            <li>[a, b] – Geschlossenes Intervall (a und b eingeschlossen)</li>
            <li>(a, b] – Halboffen (a nicht, b eingeschlossen)</li>
            <li>(-∞, a) ∪ (b, ∞) – Vereinigung zweier Intervalle</li>
        </ul>
        Beispiel: x < -2 oder x ≥ 3 wird als (-∞, -2) ∪ [3, ∞) geschrieben.</p>

<p><strong>Frage:</strong> Was ist der Unterschied zwischen Definitionsbereich und Wertebereich?</p>
        <p><strong>Antwort:</strong> Der Definitionsbereich (Domäne) gibt an, welche Input-Werte eine Funktion akzeptiert, während der Wertebereich (Range) angibt, welche Output-Werte die Funktion produzieren kann. Zum Beispiel hat die Funktion f(x) = x² den Definitionsbereich ℝ (alle reellen Zahlen), aber den Wertebereich [0, ∞) (nur nicht-negative reelle Zahlen).</p>

<p><strong>Frage:</strong> Wie bestimme ich den Definitionsbereich einer zusammengesetzten Funktion?</p>
        <p><strong>Antwort:</strong> Für eine zusammengesetzte Funktion f(g(x)) müssen Sie:
        <ol>
            <li>Den Definitionsbereich von g(x) bestimmen (D₁)</li>
            <li>Den Definitionsbereich von f(u) bestimmen (D₂)</li>
            <li>Die Bedingung g(x) ∈ D₂ lösen (D₃)</li>
            <li>Die Schnittmenge D₁ ∩ D₃ bilden</li>
        </ol>
        Beispiel: Für f(x) = √(x-1) und g(x) = 1/x ist f(g(x)) = √(1/x – 1). Der Definitionsbereich ist x > 0 und 1/x – 1 ≥ 0 → x ∈ (0, 1].</p>

<h3>10. Zusammenfassung und Best Practices</h3>

<p>Die Bestimmung des Definitionsbereichs ist eine grundlegende Fähigkeit in der Mathematik mit weitreichenden Anwendungen. Hier sind die wichtigsten Punkte zusammengefasst:</p>

<ul>
            <li>Identifizieren Sie immer den Funktionstyp, um die relevanten Einschränkungen zu erkennen</li>
            <li>Lösen Sie systematisch alle Gleichungen, die sich aus den Einschränkungen ergeben</li>
            <li>Drücken Sie den Definitionsbereich in Intervallnotation aus für klare Kommunikation</li>
            <li>Verifizieren Sie Ihre Ergebnisse graphisch, wann immer möglich</li>
            <li>Berücksichtigen Sie bei praktischen Problemen zusätzliche reale Einschränkungen</li>
            <li>Nutzen Sie Technologie (wie diesen Rechner) zur Überprüfung Ihrer manuellen Berechnungen</li>
            <li>Üben Sie regelmäßig mit verschiedenen Funktionstypen, um Ihre Fähigkeiten zu verbessern</li>
        </ul>

<p>Durch das Verständnis und die korrekte Anwendung dieser Konzepte werden Sie in der Lage sein, Definitionsbereiche für praktisch jede Funktion, der Sie begegnen, genau zu bestimmen.</p>
    </article>
</section>

// Form submission handler
    document.getElementById('wpc-domain-calculator').addEventListener('submit', function(e) {
        e.preventDefault();

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

// Validate input
        if (!functionInput) {
            alert('Bitte geben Sie eine Funktion ein');
            return;
        }

try {
            // Parse the function using math.js
            const parsedFunc = math.parse(functionInput);
            const domainResult = calculateDomain(parsedFunc, functionType, restrictions);

// Display results
            displayResults(domainResult, precision);

// Plot the function with domain highlights
            plotFunction(parsedFunc, domainResult.domainIntervals, domainResult.excludedPoints);

} catch (error) {
            console.error('Calculation error:', error);
            alert('Fehler bei der Berechnung. Bitte überprüfen Sie Ihre Eingabe: ' + error.message);
        }
    });

function calculateDomain(parsedFunc, functionType, manualRestrictions) {
        const result = {
            domainIntervals: [],
            excludedPoints: [],
            warnings: [],
            functionType: functionType
        };

// Common restrictions based on function type
        switch(functionType) {
            case 'polynomial':
                result.domainIntervals = ['(-∞, ∞)'];
                break;

case 'rational':
                // Find denominator zeros
                const denominator = getDenominator(parsedFunc);
                if (denominator) {
                    const zeros = findZeros(denominator);
                    result.excludedPoints = zeros.map(z => z.toString());
                    result.domainIntervals = createIntervalsFromExclusions(zeros, '-∞', '∞');
                } else {
                    result.domainIntervals = ['(-∞, ∞)'];
                }
                break;

case 'root':
                // For even roots, radicand must be >= 0
                const radicand = getRadicand(parsedFunc);
                if (radicand) {
                    const inequality = math.parse(radicand + '>= 0');
                    const solution = solveInequality(inequality);
                    result.domainIntervals = solution.intervals;
                    result.warnings = solution.warnings;
                } else {
                    result.domainIntervals = ['(-∞, ∞)'];
                }
                break;

case 'logarithmic':
                // Argument must be > 0
                const logArg = getLogArgument(parsedFunc);
                if (logArg) {
                    const inequality = math.parse(logArg + '> 0');
                    const solution = solveInequality(inequality);
                    result.domainIntervals = solution.intervals;
                    result.warnings = solution.warnings;
                } else {
                    result.domainIntervals = ['(-∞, ∞)'];
                    result.warnings = ['Kein Logarithmus in der Funktion gefunden - standardmäßiger Definitionsbereich angenommen'];
                }
                break;
        }

// Apply manual restrictions if any
        if (manualRestrictions) {
            const manualSolution = parseManualRestrictions(manualRestrictions);
            if (manualSolution) {
                result.domainIntervals = intersectIntervals(result.domainIntervals, manualSolution.intervals);
                result.excludedPoints = [...new Set([...result.excludedPoints, ...manualSolution.excludedPoints])];
                result.warnings = [...result.warnings, ...manualSolution.warnings];
            }
        }

// Clean up intervals
        result.domainIntervals = mergeIntervals(result.domainIntervals);

return result;
    }

function displayResults(result, precision) {
        const resultsDiv = document.getElementById('wpc-results');
        const domainOutput = document.getElementById('wpc-domain-output');
        const intervalOutput = document.getElementById('wpc-interval-output');
        const exclusionsOutput = document.getElementById('wpc-exclusions-output');
        const warningsOutput = document.getElementById('wpc-warnings-output');
        const warningsDiv = document.getElementById('wpc-result-warnings');

// Format domain description
        let domainDescription = '';
        if (result.domainIntervals.length === 1 && result.domainIntervals[0] === '(-∞, ∞)') {
            domainDescription = 'Alle reellen Zahlen (ℝ)';
        } else if (result.domainIntervals.length === 0) {
            domainDescription = 'Leere Menge (keine reellen Zahlen)';
        } else {
            domainDescription = result.domainIntervals.join(' ∪ ');
        }

// Format excluded points
        let exclusionsText = result.excludedPoints.length > 0
            ? result.excludedPoints.join(', ')
            : 'Keine';

// Format warnings
        if (result.warnings && result.warnings.length > 0) {
            warningsDiv.style.display = 'block';
            warningsOutput.textContent = result.warnings.join('; ');
        } else {
            warningsDiv.style.display = 'none';
        }

// Update DOM
        domainOutput.textContent = domainDescription;
        intervalOutput.textContent = result.domainIntervals.join(' ∪ ');
        exclusionsOutput.textContent = exclusionsText;

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

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

function plotFunction(parsedFunc, domainIntervals, excludedPoints) {
        // Destroy previous chart if exists
        if (domainChart) {
            domainChart.destroy();
        }

// Generate x values (focus on interesting parts near exclusions)
        const xValues = [];
        const yValues = [];
        const domainColor = [];
        const excludedX = excludedPoints.map(p => parseFloat(p));

// Determine plotting range based on domain
        let minX = -10;
        let maxX = 10;

if (domainIntervals.length > 0 && domainIntervals[0] !== '(-∞, ∞)') {
            // Find finite bounds in domain intervals
            const bounds = domainIntervals.flatMap(interval => {
                const match = interval.match(/([$\[\-∞])([^,]+),([^,]+)([$\]∞])/);
                if (match) {
                    const left = match[2].trim() !== '-∞' ? parseFloat(match[2]) : -Infinity;
                    const right = match[3].trim() !== '∞' ? parseFloat(match[3]) : Infinity;
                    return [left, right];
                }
                return [];
            }).filter(n => !isNaN(n) && isFinite(n));

if (bounds.length > 0) {
                minX = Math.min(...bounds) - 2;
                maxX = Math.max(...bounds) + 2;
            }
        }

// Generate points
        const step = (maxX - minX) / 200;
        for (let x = minX; x <= maxX; x += step) {
            xValues.push(x);

try {
                const y = parsedFunc.evaluate({x: x});
                yValues.push(y);

// Check if x is in domain
                const inDomain = isInDomain(x, domainIntervals, excludedPoints);
                domainColor.push(inDomain ? 'rgba(37, 99, 235, 0.3)' : 'rgba(255, 0, 0, 0.2)');
            } catch (e) {
                yValues.push(NaN);
                domainColor.push('rgba(255, 0, 0, 0.2)');
            }
        }

// Create datasets
        const datasets = [
            {
                label: 'Funktion f(x)',
                data: yValues.map((y, i) => ({x: xValues[i], y: y})),
                borderColor: '#2563eb',
                backgroundColor: domainColor,
                borderWidth: 2,
                pointRadius: 0,
                showLine: true
            }
        ];

// Add vertical lines for excluded points
        excludedX.forEach(x => {
            datasets.push({
                label: `Ausgeschlossen: x = ${x}`,
                data: [{x: x, y: minY}, {x: x, y: maxY}],
                borderColor: '#ef4444',
                borderWidth: 1,
                borderDash: [5, 5],
                pointRadius: 0,
                showLine: true
            });
        });

// Determine y range (excluding NaN values)
        const validY = yValues.filter(y => !isNaN(y) && isFinite(y));
        const minY = validY.length > 0 ? Math.min(...validY) - 1 : -10;
        const maxY = validY.length > 0 ? Math.max(...validY) + 1 : 10;

// Create chart
        domainChart = new Chart(ctx, {
            type: 'line',
            data: {
                datasets: datasets
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    x: {
                        type: 'linear',
                        position: 'bottom',
                        title: {
                            display: true,
                            text: 'x (Definitionsbereich)'
                        },
                        min: minX,
                        max: maxX
                    },
                    y: {
                        title: {
                            display: true,
                            text: 'f(x)'
                        },
                        min: minY,
                        max: maxY
                    }
                },
                plugins: {
                    legend: {
                        position: 'top',
                    },
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                if (context.datasetIndex === 0) {
                                    return `f(${context.parsed.x.toFixed(2)}) = ${context.parsed.y.toFixed(2)}`;
                                }
                                return context.dataset.label;
                            }
                        }
                    },
                    annotation: {
                        annotations: domainIntervals.map((interval, i) => ({
                            type: 'box',
                            xMin: parseIntervalBound(interval.split(',')[0].trim()),
                            xMax: parseIntervalBound(interval.split(',')[1].trim()),
                            yMin: minY,
                            yMax: maxY,
                            backgroundColor: 'rgba(37, 99, 235, 0.05)',
                            borderColor: 'rgba(37, 99, 235, 0.2)',
                            borderWidth: 1,
                            label: {
                                content: `Domain ${i+1}`,
                                enabled: false
                            }
                        }))
                    }
                }
            },
            plugins: [{
                id: 'domainHighlighter',
                beforeDraw: (chart) => {
                    const ctx = chart.ctx;
                    const meta = chart.getDatasetMeta(0);
                    const yAxis = chart.scales.y;
                    const xAxis = chart.scales.x;

// Highlight domain areas
                    ctx.save();
                    ctx.globalAlpha = 0.1;
                    domainIntervals.forEach(interval => {
                        const left = parseIntervalBound(interval.split(',')[0].trim());
                        const right = parseIntervalBound(interval.split(',')[1].trim());

const xStart = xAxis.getPixelForValue(left);
                        const xEnd = xAxis.getPixelForValue(right);
                        const yBottom = yAxis.getPixelForValue(minY);
                        const yTop = yAxis.getPixelForValue(maxY);

ctx.fillStyle = '#3b82f6';
                        ctx.fillRect(xStart, yTop, xEnd - xStart, yBottom - yTop);
                    });
                    ctx.restore();
                }
            }]
        });
    }

// Helper functions
    function parseIntervalBound(boundStr) {
        if (boundStr === '-∞') return -Infinity;
        if (boundStr === '∞') return Infinity;
        if (boundStr.startsWith('(') || boundStr.startsWith('[')) {
            return parseFloat(boundStr.substring(1));
        }
        return parseFloat(boundStr);
    }

function isInDomain(x, domainIntervals, excludedPoints) {
        // Check if x is in any of the domain intervals
        let inDomain = domainIntervals.some(interval => {
            const [left, right] = interval.split(',').map(s => s.trim());
            const leftBound = parseIntervalBound(left);
            const rightBound = parseIntervalBound(right);
            const leftInclusive = left.startsWith('[');
            const rightInclusive = right.endsWith(']');

if (leftBound === -Infinity && rightBound === Infinity) return true;
            if (leftBound === -Infinity) return rightInclusive ? x <= rightBound : x < rightBound;
            if (rightBound === Infinity) return leftInclusive ? x >= leftBound : x > leftBound;

const leftOk = leftInclusive ? x >= leftBound : x > leftBound;
            const rightOk = rightInclusive ? x <= rightBound : x < rightBound;
            return leftOk && rightOk;
        });

// Check if x is in excluded points
        if (inDomain) {
            inDomain = !excludedPoints.some(p => Math.abs(x - parseFloat(p)) < 1e-6);
        }

return inDomain;
    }

function findZeros(expr) {
        try {
            // This is a simplified approach - in a real app you'd want a more robust solver
            const compiled = expr.compile();
            const zeros = [];

// Try some common values
            const testValues = [-10, -5, -2, -1, -0.5, 0, 0.5, 1, 2, 5, 10];
            for (const x of testValues) {
                try {
                    const val = compiled.evaluate({x: x});
                    if (Math.abs(val) < 1e-6) {
                        zeros.push(x);
                    }
                } catch (e) {
                    // Skip errors (like division by zero)
                }
            }

// Remove duplicates
            return [...new Set(zeros)];
        } catch (e) {
            console.error('Error finding zeros:', e);
            return [];
        }
    }

function solveInequality(inequality) {
        // Simplified inequality solver - in a real app you'd want a more complete solution
        const result = {
            intervals: [],
            warnings: []
        };

try {
            // For simple inequalities like "x > a" or "x^2 >= b"
            const expr = inequality.expression;
            const op = inequality.op;
            const right = inequality.right ? inequality.right : math.parse('0');

if (expr.type === 'SymbolNode' && expr.name === 'x') {
                // Simple inequality like x > 5
                const value = right.evaluate();
                if (op === '>') {
                    result.intervals = [`(${value}, ∞)`];
                } else if (op === '>=') {
                    result.intervals = [`[${value}, ∞)`];
                } else if (op === '<') {
                    result.intervals = [`(-∞, ${value})`];
                } else if (op === '<=') {
                    result.intervals = [`(-∞, ${value}]`];
                }
            } else {
                // More complex expressions - this is where you'd implement a real solver
                result.intervals = ['(-∞, ∞)'];
                result.warnings = ['Komplexe Ungleichung - standardmäßiger Definitionsbereich angenommen'];
            }
        } catch (e) {
            result.intervals = ['(-∞, ∞)'];
            result.warnings = ['Fehler bei der Lösung der Ungleichung: ' + e.message];
        }

return result;
    }

function parseManualRestrictions(text) {
        const result = {
            intervals: [],
            excludedPoints: [],
            warnings: []
        };

// Simple parsing of manual restrictions
        const parts = text.split(',').map(p => p.trim());

for (const part of parts) {
            if (part.includes('≠')) {
                const value = part.split('≠')[1].trim();
                result.excludedPoints.push(value);
            } else if (part.includes('>')) {
                const [left, right] = part.split('>').map(p => p.trim());
                if (left === 'x') {
                    const value = parseFloat(right);
                    result.intervals.push(`(${value}, ∞)`);
                }
            } else if (part.includes('<')) {
                const [left, right] = part.split('<').map(p => p.trim());
                if (left === 'x') {
                    const value = parseFloat(right);
                    result.intervals.push(`(-∞, ${value})`);
                }
            } else if (part.includes('≥')) {
                const [left, right] = part.split('≥').map(p => p.trim());
                if (left === 'x') {
                    const value = parseFloat(right);
                    result.intervals.push(`[${value}, ∞)`);
                }
            } else if (part.includes('≤')) {
                const [left, right] = part.split('≤').map(p => p.trim());
                if (left === 'x') {
                    const value = parseFloat(right);
                    result.intervals.push(`(-∞, ${value}]`);
                }
            }
        }

if (parts.length > 0 && result.intervals.length === 0 && result.excludedPoints.length === 0) {
            result.warnings.push('Manuelle Einschränkungen konnten nicht interpretiert werden');
        }

return result;
    }

function createIntervalsFromExclusions(exclusions, leftBound, rightBound) {
        if (exclusions.length === 0) {
            return [`(${leftBound}, ${rightBound})`];
        }

// Sort exclusions
        const sorted = [...exclusions].sort((a, b) => a - b);
        const intervals = [];
        let currentLeft = leftBound;

for (let i = 0; i <= sorted.length; i++) {
            const currentRight = i < sorted.length ? sorted[i] : rightBound;
            const nextLeft = i < sorted.length ? sorted[i] : rightBound;

if (currentLeft !== '-∞' && currentRight !== '∞') {
                intervals.push(`(${currentLeft}, ${currentRight})`);
            } else if (currentLeft === '-∞' && currentRight !== '∞') {
                intervals.push(`(-∞, ${currentRight})`);
            } else if (currentLeft !== '-∞' && currentRight === '∞') {
                intervals.push(`(${currentLeft}, ∞)`);
            }

currentLeft = nextLeft;
        }

return intervals;
    }

function intersectIntervals(intervalsA, intervalsB) {
        if (intervalsB.length === 0) return [];

const result = [];
        const aIntervals = parseIntervals(intervalsA);
        const bIntervals = parseIntervals(intervalsB);

for (const a of aIntervals) {
            for (const b of bIntervals) {
                const intersection = intersectTwoIntervals(a, b);
                if (intersection) {
                    result.push(intersection);
                }
            }
        }

return result.map(formatInterval);
    }

function intersectTwoIntervals(a, b) {
        const left = Math.max(a.left, b.left);
        const right = Math.min(a.right, b.right);

if (left > right) return null;

const leftInclusive = a.left === left ? a.leftInclusive : b.leftInclusive;
        const rightInclusive = a.right === right ? a.rightInclusive : b.rightInclusive;

return { left, right, leftInclusive, rightInclusive };
    }

function mergeIntervals(intervalStrings) {
        if (intervalStrings.length <= 1) return intervalStrings;

const intervals = parseIntervals(intervalStrings);
        intervals.sort((a, b) => a.left - b.left);

const merged = [];
        let current = intervals[0];

for (let i = 1; i < intervals.length; i++) {
            const next = intervals[i];

if (next.left <= current.right ||
                (next.left === current.right && (current.rightInclusive || next.leftInclusive))) {
                // Overlapping or adjacent intervals, merge them
                current.right = next.right;
                current.rightInclusive = next.rightInclusive;
            } else {
                merged.push(current);
                current = next;
            }
        }
        merged.push(current);

return merged.map(formatInterval);
    }
});
</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-funktionen-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">