Definitionsbereich Rechner Online

Berechnen Sie den Definitionsbereich mathematischer Funktionen mit diesem präzisen Online-Tool. Ideal für Schüler, Studenten und Professionals.

Mathematische Funktion (f(x)) Verwenden Sie Standardnotation: + – * / ^ ( ) 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">
                <svg width="20" height="20" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" style="margin-right: 8px;">
                    <path d="M15 3H21V5H17V19H21V21H15V17H13V5H15V3ZM3 13H7V15H5V19H9V21H3V17H5V13ZM11 3H13V7H19V9H11V3ZM7 5H9V3H15V5H17V9H15V11H7V5Z" fill="currentColor"/>
                </svg>
                Definitionsbereich berechnen
            </button>
        </form>

<div id="wpc-results" class="wpc-results">
            <h3 class="wpc-result-title">Ergebnisse der Berechnung</h3>
            <div id="wpc-domain-result" class="wpc-result-item">
                <span class="wpc-result-label">Definitionsbereich:</span>
                <span class="wpc-result-value" id="wpc-domain-value"></span>
            </div>
            <div id="wpc-interval-result" class="wpc-result-item">
                <span class="wpc-result-label">Intervallnotation:</span>
                <span class="wpc-result-value" id="wpc-interval-value"></span>
            </div>
            <div id="wpc-exclusions-result" class="wpc-result-item">
                <span class="wpc-result-label">Ausgeschlossene Werte:</span>
                <span class="wpc-result-value" id="wpc-exclusions-value"></span>
            </div>
            <div id="wpc-visualization-note" class="wpc-result-item" style="margin-top: 1rem; font-style: italic; color: #64748b;">
                Visualisierung der kritischen Punkte im Diagramm unten:
            </div>
        </div>

<article class="wpc-content">
        <h2>Umfassender Leitfaden: Definitionsbereich berechnen (mit Beispielen)</h2>

<p>Der Definitionsbereich (auch Definitionsmenge genannt) einer Funktion gibt an, für welche Input-Werte (x-Werte) die Funktion definiert ist. Die korrekte Bestimmung des Definitionsbereichs ist essenziell für:</p>

<ul>
            <li>Die Analyse von Funktionen in der Mathematik</li>
            <li>Die Vermeidung von Rechenfehlern durch undefinierte Ausdrücke</li>
            <li>Die korrekte Interpretation grafischer Darstellungen</li>
            <li>Anwendungen in Physik, Ingenieurwesen und Wirtschaftswissenschaften</li>
        </ul>

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

<p>Der Definitionsbereich D einer Funktion f(x) ist die Menge aller reellen Zahlen x, für die f(x) definiert ist. Formal geschrieben:</p>

<p style="text-align: center; font-style: italic; font-size: 1.1rem; margin: 1.5rem 0; padding: 1rem; background-color: #f8fafc; border-left: 4px solid #2563eb;">
            D = {x ∈ ℝ | f(x) ist definiert}
        </p>

<p>Bei der Bestimmung des Definitionsbereichs müssen wir besonders auf folgende Elemente achten:</p>

<div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Funktionstyp</th>
                        <th>Kritische Punkte</th>
                        <th>Beispiel</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Polynome</td>
                        <td>Immer definiert für alle reellen Zahlen</td>
                        <td>f(x) = 3x<sup>4</sup> – 2x<sup>2</sup> + 5</td>
                    </tr>
                    <tr>
                        <td>Rationale Funktionen</td>
                        <td>Nenner ≠ 0</td>
                        <td>f(x) = (x+2)/(x<sup>2</sup>-4)</td>
                    </tr>
                    <tr>
                        <td>Wurzelfunktionen</td>
                        <td>Radikand ≥ 0 (bei geraden Wurzeln)</td>
                        <td>f(x) = √(4 – x<sup>2</sup>)</td>
                    </tr>
                    <tr>
                        <td>Logarithmusfunktionen</td>
                        <td>Argument > 0</td>
                        <td>f(x) = ln(x<sup>2</sup> – 5x)</td>
                    </tr>
                    <tr>
                        <td>Trigonometrische Funktionen</td>
                        <td>Sin/Cos immer definiert; Tan/Cot bei bestimmten Werten undefiniert</td>
                        <td>f(x) = tan(x)</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>2. Schritt-für-Schritt Anleitung zur Berechnung</h3>

<ol>
            <li>
                <strong>Funktion analysieren:</strong> Identifizieren Sie alle Komponenten der Funktion (Brüche, Wurzeln, Logarithmen etc.)
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #fef3c7; border-radius: 4px;">
                    <strong>Beispiel:</strong> f(x) = (x<sup>2</sup> – 5x + 6)/(x – 2) · √(x + 3)
                </div>
            </li>
            <li>
                <strong>Kritische Punkte identifizieren:</strong>
                <ul>
                    <li>Nenner ≠ 0: x – 2 ≠ 0 → x ≠ 2</li>
                    <li>Wurzel definiert: x + 3 ≥ 0 → x ≥ -3</li>
                </ul>
            </li>
            <li>
                <strong>Schnittmenge bilden:</strong> Kombinieren Sie alle Bedingungen mit “UND”
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #dcfce7; border-radius: 4px;">
                    x ≥ -3 <strong>UND</strong> x ≠ 2
                </div>
            </li>
            <li>
                <strong>Intervallnotation:</strong> [-3, 2) ∪ (2, ∞)
            </li>
            <li>
                <strong>Überprüfung:</strong> Testen Sie Grenzwerte und kritische Punkte
            </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>

<ul>
            <li>
                <strong>Vergessen von Wurzelbedingungen:</strong> Bei Funktionen mit Quadratwurzeln wird oft übersehen, dass der Radikand nicht negativ sein darf.
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #fee2e2; border-radius: 4px;">
                    ❌ Falsch: f(x) = √(x<sup>2</sup> – 9) → D = ℝ<br>
                    ✅ Richtig: D = (-∞, -3] ∪ [3, ∞)
                </div>
            </li>
            <li>
                <strong>Nenner Nullstellen:</strong> Bei rationalen Funktionen werden manchmal nicht alle Nullstellen des Nenners erkannt, besonders bei faktorisierten Formen.
            </li>
            <li>
                <strong>Logarithmus-Bedingungen:</strong> Das Argument muss strikt positiv sein (nicht nur ≥ 0).
            </li>
            <li>
                <strong>Verkettete Funktionen:</strong> Bei zusammengesetzten Funktionen werden manchmal nur die äußeren Bedingungen geprüft.
            </li>
        </ul>

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

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

<div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Anwendungsbereich</th>
                        <th>Beispiel</th>
                        <th>Relevanz des Definitionsbereichs</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Physik</td>
                        <td>Beschleunigung a(t) = F/m</td>
                        <td>Masse m ≠ 0 (Division durch Null vermeiden)</td>
                    </tr>
                    <tr>
                        <td>Wirtschaft</td>
                        <td>Gewinnfunktion P(x) = E(x) – K(x)</td>
                        <td>Produktionsmenge x ≥ 0 (negative Mengen unmöglich)</td>
                    </tr>
                    <tr>
                        <td>Ingenieurwesen</td>
                        <td>Spannungsberechnung U = I·R</td>
                        <td>Widerstand R ≠ 0 (Kurzschluss vermeiden)</td>
                    </tr>
                    <tr>
                        <td>Medizin</td>
                        <td>Dosierungsberechnung D(m) = k·m<sup>2/3</sup></td>
                        <td>Körpermasse m > 0 (negative Werte biologisch unmöglich)</td>
                    </tr>
                    <tr>
                        <td>Informatik</td>
                        <td>Algorithmus-Laufzeit T(n) = n log(n)</td>
                        <td>Inputgröße n > 0 (log(0) undefiniert)</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>5. Erweiterte Themen und Sonderfälle</h3>

<p>Für fortgeschrittene Anwendungen sollten folgende Sonderfälle beachtet werden:</p>

<ul>
            <li>
                <strong>Komplexe Zahlen:</strong> In einigen Kontexten (z.B. Elektrotechnik) werden Funktionen auf komplexe Zahlen erweitert. Der Definitionsbereich umfasst dann ℂ statt ℝ.
            </li>
            <li>
                <strong>Mehrdimensionale Funktionen:</strong> Bei Funktionen mit mehreren Variablen f(x,y) wird der Definitionsbereich zu einer Menge von Tupeln (x,y).
            </li>
            <li>
                <strong>Implizite Funktionen:</strong> Bei implizit definierten Funktionen (z.B. x<sup>2</sup> + y<sup>2</sup> = 1) muss der Definitionsbereich für jede Variable separat bestimmt werden.
            </li>
            <li>
                <strong>Stückweise definierte Funktionen:</strong> Jeder Abschnitt kann unterschiedliche Definitionsbereiche haben, die dann vereint werden müssen.
            </li>
            <li>
                <strong>Funktionen mit Parametern:</strong> Wenn die Funktion von Parametern abhängt (z.B. f<sub>a</sub>(x) = √(ax – 2)), muss der Definitionsbereich in Abhängigkeit vom Parameter angegeben werden.
            </li>
        </ul>

<h3>6. Tools und Ressourcen für die Berechnung</h3>

<p>Neben unserem Online-Rechner gibt es weitere hilfreiche Tools:</p>

<ul>
            <li>
                <strong>Wolfram Alpha:</strong> Umfassende mathematische Berechnungen inkl. Definitionsbereich
                <div style="margin-top: 0.5rem;">
                    <a href="https://www.wolframalpha.com/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">https://www.wolframalpha.com/</a>
                </div>
            </li>
            <li>
                <strong>GeoGebra:</strong> Interaktive Grafiken mit automatischer Definitionsbereichs-Anzeige
                <div style="margin-top: 0.5rem;">
                    <a href="https://www.geogebra.org/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">https://www.geogebra.org/</a>
                </div>
            </li>
            <li>
                <strong>Symbolab:</strong> Schritt-für-Schritt Lösungen für Definitionsbereichs-Probleme
                <div style="margin-top: 0.5rem;">
                    <a href="https://www.symbolab.com/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">https://www.symbolab.com/</a>
                </div>
            </li>
        </ul>

<p>Für theoretische Vertiefung empfehlen wir folgende akademische Ressourcen:</p>

<ul>
            <li>
                <a href="https://math.mit.edu/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">MIT Mathematics Department</a> – Umfassende Materialien zu Funktionen und ihren Eigenschaften
            </li>
            <li>
                <a href="https://math.berkeley.edu/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">UC Berkeley Mathematics</a> – Vorlesungsnotizen zu Analysis und algebraischen Strukturen
            </li>
            <li>
                <a href="https://www.nist.gov/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST Digital Library of Mathematical Functions</a> – Offizielle Referenz für mathematische Funktionen und ihre Definitionsbereiche
            </li>
        </ul>

<h3>7. Übungsaufgaben mit Lösungen</h3>

<p>Testen Sie Ihr Verständnis mit diesen Übungsaufgaben:</p>

<ol>
            <li>
                <strong>Aufgabe:</strong> Bestimmen Sie den Definitionsbereich von f(x) = (x<sup>3</sup> – 8)/(x<sup>2</sup> – 4)
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #f3f4f6; border-radius: 4px;">
                    <strong>Lösung:</strong> D = ℝ \ {-2, 2}<br>
                    <strong>Begründung:</strong> Nenner wird Null bei x = ±2. Zähler ist bei x=2 ebenfalls Null (hebbare Definitionslücke), aber der Punkt bleibt ausgeschlossen.
                </div>
            </li>
            <li>
                <strong>Aufgabe:</strong> Geben Sie den Definitionsbereich von f(x) = ln(9 – x<sup>2</sup>) an
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #f3f4f6; border-radius: 4px;">
                    <strong>Lösung:</strong> D = (-3, 3)<br>
                    <strong>Begründung:</strong> Argument des Logarithmus muss positiv sein: 9 – x<sup>2</sup> > 0 → x<sup>2</sup> < 9 → -3 < x < 3
                </div>
            </li>
            <li>
                <strong>Aufgabe:</strong> Bestimmen Sie den Definitionsbereich von f(x) = √(x – 1) / (x<sup>2</sup> – 3x + 2)
                <div style="margin-top: 0.5rem; padding: 0.75rem; background-color: #f3f4f6; border-radius: 4px;">
                    <strong>Lösung:</strong> D = [1, 2) ∪ (2, ∞)<br>
                    <strong>Begründung:</strong>
                    <ul style="margin-top: 0.5rem;">
                        <li>Wurzelbedingung: x – 1 ≥ 0 → x ≥ 1</li>
                        <li>Nennerbedingung: x<sup>2</sup> – 3x + 2 ≠ 0 → x ≠ 1 und x ≠ 2</li>
                        <li>Schnittmenge: x ≥ 1 aber x ≠ 1 und x ≠ 2 → x ∈ [1, 2) ∪ (2, ∞)</li>
                    </ul>
                </div>
            </li>
        </ol>

<h3>8. Häufig gestellte Fragen (FAQ)</h3>

<p><strong>Frage:</strong> Warum ist der Definitionsbereich wichtig?</p>
        <p><strong>Antwort:</strong> Der Definitionsbereich ist entscheidend, weil:</p>
        <ul>
            <li>Undefinierte Operationen (wie Division durch Null) zu mathematischen Fehlern führen</li>
            <li>Er die Gültigkeit von Berechnungen und Ableitungen bestimmt</li>
            <li>In Anwendungen oft physikalische oder praktische Grenzen widerspiegelt</li>
            <li>Er für die korrekte Interpretation von Funktionsgraphen notwendig ist</li>
        </ul>

<p><strong>Frage:</strong> Wie gebe ich den Definitionsbereich richtig an?</p>
        <p><strong>Antwort:</strong> Es gibt drei gängige Notationen:</p>
        <ol>
            <li>
                <strong>Mengennotation:</strong> D = {x ∈ ℝ | x ≥ -2}<br>
                <small>Gelesen als: “D ist die Menge aller reellen x, für die x größer gleich -2 gilt”</small>
            </li>
            <li>
                <strong>Intervallnotation:</strong> D = [-2, ∞)<br>
                <small>Verwendet eckige Klammern für inklusive Grenzen und runde Klammern für exklusive Grenzen</small>
            </li>
            <li>
                <strong>Ungleichungsnotation:</strong> x ≥ -2<br>
                <small>Direkte Angabe der Bedingungen</small>
            </li>
        </ol>

<p><strong>Frage:</strong> Was ist der Unterschied zwischen Definitionsbereich und Wertebereich?</p>
        <p><strong>Antwort:</strong></p>
        <div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Aspekt</th>
                        <th>Definitionsbereich</th>
                        <th>Wertebereich</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Definition</td>
                        <td>Alle möglichen Input-Werte (x)</td>
                        <td>Alle möglichen Output-Werte (f(x))</td>
                    </tr>
                    <tr>
                        <td>Notation</td>
                        <td>D oder Def(f)</td>
                        <td>W oder Wer(f)</td>
                    </tr>
                    <tr>
                        <td>Bestimmung</td>
                        <td>Durch Analyse der Funktionseigenschaften</td>
                        <td>Durch Analyse des Funktionsverhaltens</td>
                    </tr>
                    <tr>
                        <td>Beispiel für f(x) = x<sup>2</sup></td>
                        <td>D = ℝ (alle reellen Zahlen)</td>
                        <td>W = [0, ∞) (nur nicht-negative Zahlen)</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>9. Historische Entwicklung des Funktionsbegriffs</h3>

<p>Der moderne Funktionsbegriff hat sich über Jahrhunderte entwickelt:</p>

<ul>
            <li>
                <strong>17. Jahrhundert:</strong> Leibniz und Newton verwendeten den Begriff “Funktion” informell für mathematische Abhängigkeiten.
            </li>
            <li>
                <strong>18. Jahrhundert:</strong> Euler definierte Funktionen als analytische Ausdrücke (z.B. Polynome, trigonometrische Funktionen).
            </li>
            <li>
                <strong>19. Jahrhundert:</strong> Dirichlet führte die moderne Definition ein: Eine Funktion ist eine Zuordnung, die jedem x genau ein y zuweist.
            </li>
            <li>
                <strong>20. Jahrhundert:</strong> Erweiterung auf mehrdeutige und verallgemeinerte Funktionen in der Funktionalanalysis.
            </li>
        </ul>

<p>Interessanterweise wurde der Definitionsbereich erst im 19. Jahrhundert als eigenständiges Konzept systematisch betrachtet, als die Analysis auf solide Grundlagen gestellt wurde.</p>

<h3>10. Aktuelle Forschung und offene Fragen</h3>

<p>Auch heute gibt es noch aktive Forschungsgebiete rund um Definitionsbereiche:</p>

<ul>
            <li>
                <strong>Verallgemeinerte Funktionen:</strong> In der Distributionentheorie (z.B. Dirac-Delta-Funktion) werden Definitionsbereiche auf Testfunktionsräume erweitert.
            </li>
            <li>
                <strong>Algebraische Geometrie:</strong> Untersuchung von Definitionsbereichen über algebraischen Varietäten.
            </li>
            <li>
                <strong>Numerische Analysis:</strong> Entwicklung von Algorithmen zur automatischen Bestimmung von Definitionsbereichen komplexer Funktionen.
            </li>
            <li>
                <strong>Künstliche Intelligenz:</strong> Automatische Erkennung von Definitionsbereichen in symbolischen KI-Systemen.
            </li>
        </ul>

<p>Für aktuelle Forschungsprojekte empfehlen wir die Datenbanken des <a href="https://www.ams.org/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">American Mathematical Society</a> oder <a href="https://arxiv.org/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">arXiv</a>.</p>

<h2>Zusammenfassung und Ausblick</h2>

<p>Die korrekte Bestimmung des Definitionsbereichs ist eine fundamentale Fähigkeit in der Mathematik mit weitreichenden Anwendungen. Dieser Leitfaden hat gezeigt:</p>

<ul>
            <li>Die systematische Vorgehensweise zur Bestimmung von Definitionsbereichen</li>
            <li>Typische Fallstricke und wie man sie vermeidet</li>
            <li>Praktische Anwendungen in verschiedenen Disziplinen</li>
            <li>Fortgeschrittene Konzepte und aktuelle Forschungsfragen</li>
        </ul>

<p>Mit unserem Online-Rechner und diesem umfassenden Leitfaden sollten Sie nun in der Lage sein, Definitionsbereiche für die meisten Standardfunktionen korrekt zu bestimmen. Für komplexere Fälle empfehlen wir den Einsatz spezialisierter Mathematik-Software oder die Konsultation mit Fachleuten.</p>

<p>Denken Sie daran: Ein korrekt bestimmter Definitionsbereich ist der erste Schritt zu jeder seriösen Funktionsanalyse – ob in der Schule, im Studium oder in der professionellen Anwendung.</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="wpc-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 (simplified for demo - in real app use proper parser)
            const parsedFunc = math.parse(functionInput);
            const domainResult = calculateDomain(functionInput, functionType, restrictions);

// Display results
            displayResults(domainResult, precision);

// Create chart
            createDomainChart(domainResult.criticalPoints, functionInput);

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

function calculateDomain(functionStr, type, restrictions) {
        // This is a simplified version - a real implementation would use a proper math parser
        // and symbolic computation library for accurate domain calculation

const result = {
            domainDescription: '',
            intervalNotation: '',
            excludedValues: [],
            criticalPoints: []
        };

// Basic pattern matching for demo purposes
        if (type === 'polynomial') {
            result.domainDescription = 'Alle reellen Zahlen (ℝ)';
            result.intervalNotation = '(-∞, ∞)';
        }
        else if (type === 'rational') {
            // Look for denominators (simplified)
            const denominatorMatch = functionStr.match(/$([^)]+)$/g);
            if (denominatorMatch) {
                const denominator = denominatorMatch[denominatorMatch.length - 1].replace(/[()]/g, '');
                result.excludedValues = findRoots(denominator);
                result.criticalPoints = result.excludedValues.map(x => ({x: parseFloat(x), type: 'vertical asymptote'}));

if (result.excludedValues.length > 0) {
                    result.domainDescription = `Alle reellen Zahlen außer x = ${result.excludedValues.join(', ')}`;
                    result.intervalNotation = createIntervalNotation(result.excludedValues);
                } else {
                    result.domainDescription = 'Alle reellen Zahlen (ℝ)';
                    result.intervalNotation = '(-∞, ∞)';
                }
            }
        }
        else if (type === 'root') {
            // Look for square roots (simplified)
            const rootMatch = functionStr.match(/√$([^)]+)$/);
            if (rootMatch) {
                const radicand = rootMatch[1];
                const roots = findRoots(radicand);
                result.criticalPoints = roots.map(x => ({x: parseFloat(x), type: 'boundary'}));

if (roots.length > 0) {
                    const rootValue = parseFloat(roots[0]);
                    result.domainDescription = `x ≥ ${rootValue}`;
                    result.intervalNotation = `[${rootValue}, ∞)`;
                }
            }
        }
        else if (type === 'logarithm') {
            // Look for logarithms (simplified)
            const logMatch = functionStr.match(/log$([^)]+)$|ln$([^)]+)$/);
            if (logMatch) {
                const argument = logMatch[1] || logMatch[2];
                const roots = findRoots(argument);
                result.criticalPoints = roots.map(x => ({x: parseFloat(x), type: 'boundary'}));

if (roots.length > 0) {
                    const rootValue = parseFloat(roots[0]);
                    result.domainDescription = `x > ${rootValue}`;
                    result.intervalNotation = `(${rootValue}, ∞)`;
                }
            }
        }

// Apply manual restrictions if any
        if (restrictions) {
            const manualExclusions = restrictions.match(/-?\d+(\.\d+)?/g) || [];
            result.excludedValues = [...new Set([...result.excludedValues, ...manualExclusions])];

if (manualExclusions.length > 0) {
                result.domainDescription += (result.domainDescription ? ' und ' : '') +
                                           `x ≠ ${manualExclusions.join(', ')}`;
            }
        }

return result;
    }

function findRoots(expression) {
        // Extremely simplified root finding - in real app use proper solver
        try {
            // Try to solve expression = 0
            const roots = [];
            const expr = math.parse(expression);

// Try some common roots
            const testValues = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5];
            for (const val of testValues) {
                const scope = {x: val};
                const result = expr.evaluate(scope);
                if (Math.abs(result) < 0.0001) {
                    roots.push(val.toString());
                }
            }

return roots.length > 0 ? roots : ['0']; // Fallback
        } catch (e) {
            console.error('Error finding roots:', e);
            return [];
        }
    }

function createIntervalNotation(excludedValues) {
        if (excludedValues.length === 0) return '(-∞, ∞)';

// Sort numerically
        const sorted = excludedValues.map(x => parseFloat(x)).sort((a, b) => a - b);
        let notation = '';
        let prev = -Infinity;

for (const val of sorted) {
            if (val > prev + 0.0001) {
                if (notation) notation += ' ∪ ';
                notation += `(-∞, ${val})`;
            }
            notation += ` ∪ (${val}, ∞)`;
            prev = val;
        }

// Simplify for single exclusion
        if (sorted.length === 1) {
            return `(-∞, ${sorted[0]}) ∪ (${sorted[0]}, ∞)`;
        }

return notation;
    }

function displayResults(result, precision) {
        const resultsDiv = document.getElementById('wpc-results');
        const domainValue = document.getElementById('wpc-domain-value');
        const intervalValue = document.getElementById('wpc-interval-value');
        const exclusionsValue = document.getElementById('wpc-exclusions-value');

// Format results based on precision
        const formatNumber = (num) => {
            if (!num) return num;
            const n = parseFloat(num);
            return isNaN(n) ? num : n.toFixed(precision);
        };

// Set values
        domainValue.textContent = result.domainDescription;

// Format interval notation
        let intervalText = result.intervalNotation;
        if (result.excludedValues.length > 0) {
            intervalText += ` (ausgeschlossen: ${result.excludedValues.map(formatNumber).join(', ')})`;
        }
        intervalValue.textContent = intervalText;

// Format exclusions
        exclusionsValue.textContent = result.excludedValues.length > 0 ?
            result.excludedValues.map(formatNumber).join(', ') : 'Keine';

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

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

function createDomainChart(criticalPoints, functionStr) {
        if (domainChart) {
            domainChart.destroy();
        }

// Prepare data
        const labels = [];
        const dataPoints = [];
        const backgroundColors = [];
        const borderColors = [];

// Generate x values around critical points
        const xValues = [];
        if (criticalPoints.length > 0) {
            const minX = Math.min(...criticalPoints.map(p => p.x)) - 2;
            const maxX = Math.max(...criticalPoints.map(p => p.x)) + 2;

// Generate points with higher density near critical points
            for (let x = minX; x <= maxX; x += 0.1) {
                xValues.push(x);
            }

// Add exact critical points
            criticalPoints.forEach(p => {
                if (!xValues.includes(p.x)) {
                    xValues.push(p.x);
                }
            });

xValues.sort((a, b) => a - b);
        } else {
            // Default range if no critical points
            for (let x = -5; x <= 5; x += 0.5) {
                xValues.push(x);
            }
        }

// Evaluate function at each point (simplified)
        xValues.forEach(x => {
            labels.push(x.toFixed(1));

try {
                const scope = {x: x};
                const expr = math.parse(functionStr);
                const y = expr.evaluate(scope);

// Check if point is in domain
                const isInDomain = !criticalPoints.some(p =>
                    Math.abs(x - p.x) < 0.01 && p.type === 'vertical asymptote'
                );

dataPoints.push(isInDomain ? y : null);
                backgroundColors.push(isInDomain ? 'rgba(37, 99, 235, 0.2)' : 'rgba(255, 99, 132, 0.2)');
                borderColors.push(isInDomain ? 'rgba(37, 99, 235, 1)' : 'rgba(255, 99, 132, 1)');
            } catch (e) {
                dataPoints.push(null);
                backgroundColors.push('rgba(255, 99, 132, 0.2)');
                borderColors.push('rgba(255, 99, 132, 1)');
            }
        });

// Create dataset
        const dataset = {
            label: `f(x) = ${functionStr}`,
            data: dataPoints,
            backgroundColor: backgroundColors,
            borderColor: borderColors,
            borderWidth: 2,
            pointRadius: 3,
            pointHoverRadius: 5,
            tension: 0.1,
            segment: {
                borderDash: ctx => {
                    const index = ctx.p0DataIndex;
                    if (index < dataPoints.length && dataPoints[index] === null) {
                        return [5, 5];
                    }
                    return [];
                }
            }
        };

// Add vertical lines for critical points
        const verticalLinePlugins = {
            id: 'verticalLines',
            afterDraw: (chart) => {
                const {ctx, chartArea: {top, bottom, left, right}, scales: {x}} = chart;
                ctx.save();

criticalPoints.forEach(point => {
                    const xPos = x.getPixelForValue(point.x);
                    ctx.beginPath();
                    ctx.moveTo(xPos, top);
                    ctx.lineTo(xPos, bottom);
                    ctx.strokeStyle = point.type === 'vertical asymptote' ? '#ef4444' : '#0891b2';
                    ctx.lineWidth = point.type === 'vertical asymptote' ? 2 : 1;
                    ctx.setLineDash(point.type === 'vertical asymptote' ? [5, 5] : [2, 2]);
                    ctx.stroke();
                    ctx.restore();

// Add label
                    ctx.save();
                    ctx.fillStyle = point.type === 'vertical asymptote' ? '#ef4444' : '#0891b2';
                    ctx.font = '12px Inter';
                    ctx.textAlign = 'center';
                    ctx.fillText(`x=${point.x}`, xPos, top + 20);
                    ctx.restore();
                });
            }
        };

// Create chart
        domainChart = new Chart(ctx, {
            type: 'line',
            data: {
                labels: labels,
                datasets: [dataset]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                plugins: {
                    legend: {
                        position: 'top',
                    },
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                return context.parsed.y !== null ?
                                    `f(${context.label}) = ${context.parsed.y.toFixed(2)}` :
                                    'Nicht definiert';
                            }
                        }
                    }
                },
                scales: {
                    x: {
                        title: {
                            display: true,
                            text: 'x-Werte'
                        },
                        grid: {
                            color: '#e2e8f0'
                        }
                    },
                    y: {
                        title: {
                            display: true,
                            text: 'f(x)'
                        },
                        grid: {
                            color: '#e2e8f0'
                        }
                    }
                }
            },
            plugins: [verticalLinePlugins]
        });
    }

// Initialize with empty chart
    domainChart = new Chart(ctx, {
        type: 'line',
        data: {
            labels: [],
            datasets: []
        },
        options: {
            responsive: true,
            maintainAspectRatio: false
        }
    });
});
</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-rechner-online/#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">