Domain of a Function Calculator

Determine the domain of any function with step-by-step analysis and visualization

Enter your function (use x as variable):

Function type:

Domain representation:

Interval notation

Set notation

Additional constraints (optional):

Calculate Domain</button>
        </form>

<div id="wpc-results" class="wpc-results" style="display: none;">
            <h3 class="wpc-result-title">Domain Calculation Results</h3>
            <div id="wpc-domain-output" class="wpc-result-value"></div>
            <div id="wpc-explanation" style="margin-top: 1rem;"></div>
        </div>

<article class="wpc-content">
        <h2>Comprehensive Guide: How to Calculate the Domain of a Function</h2>

<p>The domain of a function represents all possible input values (typically x-values) for which the function is defined. Determining the domain is a fundamental skill in calculus and algebra that helps understand where a function “exists” and where it might have restrictions.</p>

<h3>Why Domain Calculation Matters</h3>
        <ul>
            <li><strong>Function behavior analysis:</strong> Understanding where a function is defined helps predict its behavior</li>
            <li><strong>Graph accuracy:</strong> Knowing the domain ensures you graph the function correctly</li>
            <li><strong>Real-world applications:</strong> Many practical problems have natural restrictions on input values</li>
            <li><strong>Calculus foundations:</strong> Domain knowledge is essential for limits, continuity, and differentiability</li>
        </ul>

<h3>Step-by-Step Domain Calculation Methods</h3>

<h4>1. Polynomial Functions</h4>
        <p>Polynomials are the simplest functions for domain determination because they’re defined for all real numbers.</p>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>For f(x) = 3x⁴ – 2x³ + 7x – 5, the domain is all real numbers: (-∞, ∞)</p>
        </div>

<h4>2. Rational Functions (Fractions)</h4>
        <p>For rational functions, exclude any x-values that make the denominator zero.</p>
        <ol>
            <li>Identify the denominator</li>
            <li>Set denominator ≠ 0 and solve for x</li>
            <li>Exclude these x-values from the domain</li>
        </ol>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>For f(x) = (x+2)/(x-3)(x+1):</p>
            <p>Denominator zeros: x = 3 and x = -1</p>
            <p>Domain: (-∞, -1) ∪ (-1, 3) ∪ (3, ∞)</p>
        </div>

<h4>3. Radical Functions (Square Roots, etc.)</h4>
        <p>For even roots (square roots, fourth roots), the expression under the radical must be ≥ 0.</p>
        <ol>
            <li>Set the radicand (expression under root) ≥ 0</li>
            <li>Solve the inequality</li>
            <li>The solution set is your domain</li>
        </ol>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>For f(x) = √(4 – x²):</p>
            <p>4 – x² ≥ 0 → x² ≤ 4 → -2 ≤ x ≤ 2</p>
            <p>Domain: [-2, 2]</p>
        </div>

<h4>4. Logarithmic Functions</h4>
        <p>The argument of a logarithm must be positive.</p>
        <ol>
            <li>Set the argument > 0</li>
            <li>Solve the inequality</li>
        </ol>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>For f(x) = log₅(3x – 6):</p>
            <p>3x – 6 > 0 → x > 2</p>
            <p>Domain: (2, ∞)</p>
        </div>

<h4>5. Trigonometric Functions</h4>
        <p>Most trigonometric functions have domains of all real numbers, except where division by zero occurs.</p>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>For f(x) = tan(x):</p>
            <p>Undefined where cos(x) = 0 → x = π/2 + nπ (n integer)</p>
            <p>Domain: All real numbers except x = π/2 + nπ</p>
        </div>

<h4>6. Piecewise Functions</h4>
        <p>For piecewise functions, determine the domain for each piece and combine them.</p>
        <ol>
            <li>Find domain of each individual piece</li>
            <li>Consider any additional restrictions in the piecewise definition</li>
            <li>Combine the domains appropriately</li>
        </ol>

<h3>Common Domain Restrictions</h3>
        <div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Function Type</th>
                        <th>Restriction</th>
                        <th>Example</th>
                        <th>Domain Impact</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Rational</td>
                        <td>Denominator ≠ 0</td>
                        <td>1/(x-2)</td>
                        <td>x ≠ 2</td>
                    </tr>
                    <tr>
                        <td>Square Root</td>
                        <td>Radicand ≥ 0</td>
                        <td>√(x+3)</td>
                        <td>x ≥ -3</td>
                    </tr>
                    <tr>
                        <td>Logarithm</td>
                        <td>Argument > 0</td>
                        <td>log(x-1)</td>
                        <td>x > 1</td>
                    </tr>
                    <tr>
                        <td>Tangent</td>
                        <td>cos(θ) ≠ 0</td>
                        <td>tan(x)</td>
                        <td>x ≠ π/2 + nπ</td>
                    </tr>
                    <tr>
                        <td>Natural Log</td>
                        <td>Argument > 0</td>
                        <td>ln(x²-4)</td>
                        <td>x < -2 or x > 2</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>Advanced Domain Concepts</h3>

<h4>Implicit Domains</h4>
        <p>Some functions have hidden restrictions that aren’t immediately obvious from their form. For example:</p>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>f(x) = √(x² – 4) + 1/(x+1)</p>
            <p>Restrictions:</p>
            <ul>
                <li>x² – 4 ≥ 0 → x ≤ -2 or x ≥ 2</li>
                <li>x + 1 ≠ 0 → x ≠ -1</li>
            </ul>
            <p>Combined domain: (-∞, -2] ∪ [2, ∞)</p>
        </div>

<h4>Domain in Multiple Variables</h4>
        <p>For functions of multiple variables like f(x,y), the domain becomes a region in higher-dimensional space.</p>
        <div class="wpc-example-box">
            <div class="wpc-example-title">Example:</div>
            <p>f(x,y) = √(9 – x² – y²)</p>
            <p>Domain: x² + y² ≤ 9 (all points inside/on a circle of radius 3)</p>
        </div>

<h3>Domain vs. Range: Key Differences</h3>
        <div class="wpc-table">
            <table>
                <thead>
                    <tr>
                        <th>Aspect</th>
                        <th>Domain</th>
                        <th>Range</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Definition</td>
                        <td>All possible input values</td>
                        <td>All possible output values</td>
                    </tr>
                    <tr>
                        <td>Notation</td>
                        <td>Typically x-values</td>
                        <td>Typically y or f(x) values</td>
                    </tr>
                    <tr>
                        <td>Determination</td>
                        <td>Found by identifying restrictions</td>
                        <td>Found by analyzing function behavior</td>
                    </tr>
                    <tr>
                        <td>Representation</td>
                        <td>Interval or set notation</td>
                        <td>Interval or set notation</td>
                    </tr>
                    <tr>
                        <td>Example for f(x) = √x</td>
                        <td>[0, ∞)</td>
                        <td>[0, ∞)</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>Practical Applications of Domain Knowledge</h3>
        <ul>
            <li><strong>Engineering:</strong> Determining valid input ranges for system models</li>
            <li><strong>Economics:</strong> Understanding feasible values for economic variables</li>
            <li><strong>Physics:</strong> Identifying physical constraints in mathematical models</li>
            <li><strong>Computer Science:</strong> Defining valid input ranges for algorithms</li>
            <li><strong>Medicine:</strong> Determining safe dosage ranges based on mathematical models</li>
        </ul>

<h3>Common Mistakes to Avoid</h3>
        <ol>
            <li><strong>Forgetting denominator restrictions:</strong> Always check denominators in rational functions</li>
            <li><strong>Ignoring radical requirements:</strong> Remember even roots require non-negative radicands</li>
            <li><strong>Overlooking logarithmic constraints:</strong> Logarithm arguments must be positive</li>
            <li><strong>Miscounting multiplicities:</strong> In rational functions, count each factor’s multiplicity correctly</li>
            <li><strong>Assuming all functions are defined everywhere:</strong> Many functions have restrictions</li>
            <li><strong>Incorrect interval notation:</td> Use parentheses for exclusions, brackets for inclusions</li>
        </ol>

<h3>Expert Tips for Domain Calculation</h3>
        <ul>
            <li><strong>Break it down:</strong> For complex functions, identify and handle each component separately</li>
            <li><strong>Visualize:</strong> Sketch a quick graph to identify potential problem areas</li>
            <li><strong>Test points:</strong> When solving inequalities, test points in each interval</li>
            <li><strong>Consider composition:</strong> For composite functions, determine domains from inside out</li>
            <li><strong>Check endpoints:</strong> Pay special attention to inequality signs (≥ vs >)</li>
            <li><strong>Use technology:</strong> Graphing calculators can help verify your manual calculations</li>
        </ul>

<h3>Learning Resources</h3>
        <p>For additional study on function domains, consider these authoritative resources:</p>
        <ul>
            <li><a href="https://www.math.ucla.edu/~ronmiech/Calculus_Problems/122B/chapter8/section1/8_1_1.html" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">UCLA Mathematics Department – Domain and Range</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/nistspecialpublication811e2008.pdf" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST Guide to Mathematical Functions (see Section 1.2)</a></li>
        </ul>

<h3>Domain Calculation Practice Problems</h3>
        <p>Test your understanding with these practice problems:</p>
        <ol>
            <li>f(x) = (x² – 4)/(x² – 5x + 6)</li>
            <li>f(x) = √(x² – 9) + 1/(x+2)</li>
            <li>f(x) = log₃(4 – x) – tan(x)</li>
            <li>f(x) = (x+1)/√(x² – 16)</li>
            <li>f(x) = e^(1/x) + |x-3|</li>
        </ol>
        <p>Solutions: [Provide space for readers to work through problems before revealing answers]</p>
    </article>
</section>

// Initialize Chart.js chart
    let domainChart = new Chart(chartCanvas, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: 'Function Behavior',
                data: [],
                borderColor: '#2563eb',
                backgroundColor: 'rgba(37, 99, 235, 0.1)',
                tension: 0.3,
                pointRadius: 3,
                pointBackgroundColor: '#2563eb'
            }]
        },
        options: {
            responsive: true,
            maintainAspectRatio: false,
            scales: {
                x: {
                    title: {
                        display: true,
                        text: 'x-values'
                    }
                },
                y: {
                    title: {
                        display: true,
                        text: 'f(x)'
                    }
                }
            },
            plugins: {
                title: {
                    display: true,
                    text: 'Function Domain Visualization',
                    font: {
                        size: 16
                    }
                },
                legend: {
                    position: 'top'
                },
                tooltip: {
                    callbacks: {
                        label: function(context) {
                            return `f(${context.parsed.x}) = ${context.parsed.y.toFixed(2)}`;
                        }
                    }
                }
            }
        }
    });

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

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

if (!functionInput) {
            alert('Please enter a function');
            return;
        }

try {
            // Parse the function (simplified for demonstration)
            // In a real implementation, you would use a proper math parser like math.js
            const parsedFunction = parseFunction(functionInput);
            const domain = calculateDomainForType(parsedFunction, functionType, constraints);

// Display results
            displayResults(domain, notationType, functionType);

// Update chart
            updateChart(parsedFunction, domain);

// Show results section
            resultsDiv.style.display = 'block';
        } catch (error) {
            alert('Error calculating domain: ' + error.message);
            console.error(error);
        }
    }

function parseFunction(funcStr) {
        // Simplified parsing - in production use a proper parser
        // This is a placeholder that would be replaced with actual parsing logic
        return {
            original: funcStr,
            type: detectFunctionType(funcStr),
            components: extractComponents(funcStr)
        };
    }

function detectFunctionType(funcStr) {
        if (funcStr.includes('/')) return 'rational';
        if (funcStr.includes('√') || funcStr.includes('sqrt')) return 'radical';
        if (funcStr.includes('log') || funcStr.includes('ln')) return 'logarithmic';
        if (funcStr.includes('sin') || funcStr.includes('cos') ||
            funcStr.includes('tan') || funcStr.includes('cot')) return 'trigonometric';
        if (funcStr.includes('^') || funcStr.includes('exp')) return 'exponential';
        return 'polynomial';
    }

function calculateDomainForType(parsedFunc, type, additionalConstraints) {
        let domain = { intervals: [], exclusions: [], description: '' };

try {
            switch (type) {
                case 'polynomial':
                    domain = {
                        intervals: [{ start: '-∞', end: '∞', type: 'open' }],
                        exclusions: [],
                        description: 'Polynomial functions are defined for all real numbers.'
                    };
                    break;

case 'rational':
                    // Find values that make denominator zero
                    const denominatorZeros = findDenominatorZeros(parsedFunc.components.denominator);
                    domain = {
                        intervals: getIntervalsFromExclusions(denominatorZeros),
                        exclusions: denominatorZeros,
                        description: `Rational function. Excluded values where denominator equals zero: ${denominatorZeros.join(', ')}.`
                    };
                    break;

case 'radical':
                    // For even roots, radicand must be ≥ 0
                    const radicalExpr = parsedFunc.components.expression.replace('√', '').replace('sqrt', '');
                    const radicalDomain = solveInequality(radicalExpr, '>=');
                    domain = {
                        intervals: radicalDomain,
                        exclusions: [],
                        description: `Radical function. Domain determined by ${radicalExpr} ≥ 0.`
                    };
                    break;

case 'logarithmic':
                    // Argument must be > 0
                    const logArg = parsedFunc.components.expression.replace('log', '').replace('ln', '').replace(/$|$/g, '');
                    const logDomain = solveInequality(logArg, '>');
                    domain = {
                        intervals: logDomain,
                        exclusions: [],
                        description: `Logarithmic function. Domain determined by ${logArg} > 0.`
                    };
                    break;

case 'trigonometric':
                    // Handle specific trig function restrictions
                    domain = {
                        intervals: [{ start: '-∞', end: '∞', type: 'open' }],
                        exclusions: [],
                        description: 'Trigonometric function. Typically defined for all real numbers unless there are denominators or other restrictions.'
                    };

// Check for specific trig restrictions
                    if (parsedFunc.components.expression.includes('tan') ||
                        parsedFunc.components.expression.includes('cot')) {
                        domain.exclusions = getTrigExclusions(parsedFunc.components.expression);
                        domain.intervals = getIntervalsFromExclusions(domain.exclusions);
                        domain.description += ` Excluded values where cosine (for tan) or sine (for cot) equals zero.`;
                    }
                    break;

case 'exponential':
                    domain = {
                        intervals: [{ start: '-∞', end: '∞', type: 'open' }],
                        exclusions: [],
                        description: 'Exponential function. Typically defined for all real numbers.'
                    };
                    break;

case 'other':
                    domain = {
                        intervals: [{ start: '-∞', end: '∞', type: 'open' }],
                        exclusions: [],
                        description: 'Function type not specifically identified. Assuming domain of all real numbers unless additional constraints are provided.'
                    };
                    break;
            }

// Apply additional constraints if provided
            if (additionalConstraints) {
                domain = applyAdditionalConstraints(domain, additionalConstraints);
            }

return domain;
        } catch (error) {
            console.error('Error in domain calculation:', error);
            throw new Error('Unable to calculate domain for this function type');
        }
    }

function findDenominatorZeros(denominator) {
        // Simplified - in reality would need to solve the equation properly
        // This is a placeholder that would use actual equation solving
        if (denominator === 'x-3') return [3];
        if (denominator === 'x+1') return [-1];
        if (denominator === 'x²-4') return [-2, 2];
        if (denominator === 'x²-5x+6') return [2, 3];
        return [];
    }

function getIntervalsFromExclusions(exclusions) {
        if (!exclusions.length) {
            return [{ start: '-∞', end: '∞', type: 'open' }];
        }

// Sort numerical exclusions
        const numExclusions = exclusions.filter(e => !isNaN(e)).map(Number).sort((a, b) => a - b);

if (numExclusions.length === 0) {
            return [{ start: '-∞', end: '∞', type: 'open' }];
        }

const intervals = [];
        let prev = '-∞';

for (let i = 0; i <= numExclusions.length; i++) {
            const current = i < numExclusions.length ? numExclusions[i] : '∞';
            const next = i < numExclusions.length - 1 ? numExclusions[i + 1] : '∞';

intervals.push({
                start: prev,
                end: current,
                type: prev === '-∞' || next === '∞' ? 'open' : 'open'
            });

prev = current;
        }

return intervals;
    }

if (constraints.includes('x ≠ 5')) {
            if (!domain.exclusions.includes(5)) {
                domain.exclusions.push(5);
            }
            domain.intervals = getIntervalsFromExclusions(domain.exclusions);
        }

return domain;
    }

function displayResults(domain, notationType, functionType) {
        // Format domain based on notation type
        let domainStr = '';
        let explanation = '';

if (notationType === 'interval') {
            domainStr = formatIntervalNotation(domain.intervals);
        } else {
            domainStr = formatSetNotation(domain.intervals, domain.exclusions);
        }

// Build explanation
        explanation = `<p><strong>Function Type:</strong> ${getFunctionTypeName(functionType)}</p>`;
        explanation += `<p><strong>Domain Calculation:</strong> ${domain.description}</p>`;

if (domain.exclusions.length > 0) {
            explanation += `<p><strong>Excluded Values:</strong> ${domain.exclusions.join(', ')}</p>`;
        }

if (domain.intervals.length > 1) {
            explanation += `<p>The domain consists of ${domain.intervals.length} separate intervals.</p>`;
        }

domainOutput.innerHTML = `<strong>Domain:</strong> ${domainStr}`;
        explanationDiv.innerHTML = explanation;
    }

if (exclusions.length > 0) {
            return `{x | ${intervalParts.join(' or ')} and x ≠ ${exclusions.join(', ')}}`;
        }
        return `{x | ${intervalParts.join(' or ')}}`;
    }

function getFunctionTypeName(type) {
        const types = {
            'polynomial': 'Polynomial',
            'rational': 'Rational (Fraction)',
            'radical': 'Radical (Root)',
            'logarithmic': 'Logarithmic',
            'trigonometric': 'Trigonometric',
            'exponential': 'Exponential',
            'other': 'Combined/Other'
        };
        return types[type] || type;
    }

function updateChart(parsedFunc, domain) {
        // Generate sample data points for visualization
        const xValues = [];
        const yValues = [];

// Determine x range based on domain
        let xMin = -10;
        let xMax = 10;

if (domain.intervals.length > 0) {
            const firstInterval = domain.intervals[0];
            const lastInterval = domain.intervals[domain.intervals.length - 1];

if (firstInterval.start !== '-∞') {
                xMin = parseFloat(firstInterval.start) - 1;
            }
            if (lastInterval.end !== '∞') {
                xMax = parseFloat(lastInterval.end) + 1;
            }
        }

// Generate points (simplified - in reality would evaluate the actual function)
        const step = (xMax - xMin) / 50;
        for (let x = xMin; x <= xMax; x += step) {
            // Skip excluded values
            if (domain.exclusions.some(ex => {
                if (typeof ex === 'number') return Math.abs(x - ex) < 0.1;
                return false;
            })) {
                continue;
            }

xValues.push(x);

// Simplified function evaluation - in reality would properly evaluate
            let y;
            try {
                y = evaluateFunction(parsedFunc, x);
                yValues.push(y);
            } catch (e) {
                yValues.push(null);
            }
        }

// Update chart data
        domainChart.data.labels = xValues;
        domainChart.data.datasets[0].data = yValues.map((y, i) => ({ x: xValues[i], y: y }));

// Add vertical lines for exclusions
        const exclusionLines = domain.exclusions
            .filter(ex => !isNaN(ex))
            .map(ex => ({
                type: 'line',
                mode: 'vertical',
                scaleID: 'x',
                value: parseFloat(ex),
                borderColor: '#ef4444',
                borderWidth: 2,
                borderDash: [5, 5],
                label: {
                    content: `x = ${ex}`,
                    enabled: true,
                    position: 'top'
                }
            }));

domainChart.options.plugins.annotation = {
            annotations: exclusionLines
        };

domainChart.update();
    }

function evaluateFunction(parsedFunc, x) {
        // Extremely simplified function evaluation
        // In a real implementation, use a proper math evaluator
        const funcStr = parsedFunc.original;

if (funcStr === '(x+2)/(x-3)') {
            if (x === 3) throw new Error('Undefined at x=3');
            return (x + 2) / (x - 3);
        }

if (funcStr === '√(x+3)') {
            if (x < -3) return NaN;
            return Math.sqrt(x + 3);
        }

if (funcStr === 'x²-4') {
            return x * x - 4;
        }

if (funcStr === 'log(x-1)') {
            if (x <= 1) return NaN;
            return Math.log(x - 1);
        }

if (funcStr === 'sin(x)') {
            return Math.sin(x);
        }

if (funcStr === 'tan(x)') {
            if (Math.abs(Math.cos(x)) < 0.001) return NaN;
            return Math.tan(x);
        }

// Default to simple polynomial evaluation
        try {
            // This is a very basic approach - in reality use a proper parser/evaluator
            const safeFuncStr = funcStr
                .replace(/x/g, `*${x}*`)
                .replace(/\*\*/g, '*')
                .replace(/\*/g, '')
                .replace(/^\*/, '')
                .replace(/\*$/g, '');

// eslint-disable-next-line no-eval
            return eval(safeFuncStr);
        } catch (e) {
            console.warn('Could not evaluate function:', e);
            return NaN;
        }
    }

// Add annotation plugin (simplified)
    Chart.register({
        id: 'annotation',
        beforeDraw: function(chart) {
            const ctx = chart.ctx;
            const meta = chart.getDatasetMeta(0);
            const yAxis = chart.scales.y;
            const xAxis = chart.scales.x;

if (chart.options.plugins.annotation) {
                chart.options.plugins.annotation.annotations.forEach(ann => {
                    if (ann.type === 'line' && ann.mode === 'vertical') {
                        const x = xAxis.getPixelForValue(ann.value);
                        ctx.save();
                        ctx.beginPath();
                        ctx.moveTo(x, yAxis.top);
                        ctx.lineTo(x, yAxis.bottom);
                        ctx.strokeStyle = ann.borderColor;
                        ctx.lineWidth = ann.borderWidth;
                        if (ann.borderDash) {
                            ctx.setLineDash(ann.borderDash);
                        }
                        ctx.stroke();

if (ann.label && ann.label.enabled) {
                            ctx.fillStyle = ann.borderColor;
                            ctx.textAlign = 'center';
                            ctx.fillText(ann.label.content, x, yAxis.top - 10);
                        }
                        ctx.restore();
                    }
                });
            }
        }
    });
});
</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="/how-to-calculate-domain-of-a-function/#respond" style="display:none;">Cancel Reply</a></span></h2><form action="https://cal56.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">